From 2a09ee1cb1ae2fd442d25337fd668e1d68bd6b40 Mon Sep 17 00:00:00 2001 From: downgoon Date: Mon, 5 Jun 2017 09:54:10 +0800 Subject: [PATCH 1/4] add table of content in vertx core --- core/Core.md | 323 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 323 insertions(+) diff --git a/core/Core.md b/core/Core.md index bf522e5..fd67559 100644 --- a/core/Core.md +++ b/core/Core.md @@ -1,5 +1,328 @@ # Vert.x Core 文档手册 + + +- [Vert.x Core 文档手册](#vertx-core-文档手册) + - [中英对照表](#中英对照表) + - [组件介绍](#组件介绍) + - [故事从 Vert.x 开始](#故事从-vertx-开始) + - [创建 Vertx 对象时指定配置项](#创建-vertx-对象时指定配置项) + - [创建集群模式的 Vert.x 对象](#创建集群模式的-vertx-对象) + - [是流式的吗？](#是流式的吗) + - [Don’t call us, we’ll call you](#dont-call-us-well-call-you) + - [不要阻塞我！](#不要阻塞我) + - [Reactor 模式和 Multi-Reactor 模式](#reactor-模式和-multi-reactor-模式) + - [黄金法则：不要阻塞Event Loop](#黄金法则不要阻塞event-loop) + - [运行阻塞式代码](#运行阻塞式代码) + - [异步协调](#异步协调) + - [并发合并](#并发合并) + - [顺序合并](#顺序合并) + - [Verticle](#verticle) + - [编写 Verticle](#编写-verticle) + - [Verticle 异步启动和停止](#verticle-异步启动和停止) + - [Verticle 种类](#verticle-种类) + - [Standard Verticle](#standard-verticle) + - [Worker Verticle](#worker-verticle) + - [Multi-threaded Worker Verticle](#multi-threaded-worker-verticle) + - [编程方式部署Verticle](#编程方式部署verticle) + - [Verticle名称到Factory的映射规则](#verticle名称到factory的映射规则) + - [如何定位Verticle Factory？](#如何定位verticle-factory) + - [等待部署完成](#等待部署完成) + - [撤销Verticle](#撤销verticle) + - [设置 Verticle 实例数](#设置-verticle-实例数) + - [向 Verticle 传入配置](#向-verticle-传入配置) + - [在 Verticle 中访问环境变量](#在-verticle-中访问环境变量) + - [Verticle 隔离组](#verticle-隔离组) + - [高可用性](#高可用性) + - [从命令行运行Verticle](#从命令行运行verticle) +- [运行JavaScript的Verticle](#运行javascript的verticle) +- [运行Ruby的Verticle](#运行ruby的verticle) +- [使用集群模式运行Groovy的Verticle](#使用集群模式运行groovy的verticle) + - [退出 Vert.x 环境](#退出-vertx-环境) + - [Context 对象](#context-对象) + - [执行周期性/延迟性操作](#执行周期性延迟性操作) + - [一次性计时器](#一次性计时器) + - [周期性计时器](#周期性计时器) + - [取消计时器](#取消计时器) + - [Verticle 中自动清除定时器](#verticle-中自动清除定时器) + - [Verticle Worker Pool](#verticle-worker-pool) + - [Event Bus](#event-bus) + - [基本概念](#基本概念) + - [寻址](#寻址) + - [处理器](#处理器) + - [发布/订阅消息](#发布订阅消息) + - [点对点模式/请求-响应模式](#点对点模式请求-响应模式) + - [尽力传输](#尽力传输) + - [消息类型](#消息类型) + - [Event Bus API](#event-bus-api) + - [获取Event Bus](#获取event-bus) + - [注册处理器](#注册处理器) + - [注销处理器](#注销处理器) + - [发布消息](#发布消息) + - [发送消息](#发送消息) + - [设置消息头](#设置消息头) + - [消息顺序](#消息顺序) + - [消息对象](#消息对象) + - [应答消息/发送回复](#应答消息发送回复) + - [带超时的发送](#带超时的发送) + - [发送失败](#发送失败) + - [消息编解码器](#消息编解码器) + - [集群模式的 Event Bus](#集群模式的-event-bus) + - [通过代码的方式启用集群模式](#通过代码的方式启用集群模式) + - [通过命令行启用集群模式](#通过命令行启用集群模式) + - [Verticle 中的自动清理](#verticle-中的自动清理) + - [配置 Event Bus](#配置-event-bus) + - [JSON](#json) + - [JSON 对象](#json-对象) + - [创建 JSON 对象](#创建-json-对象) + - [将键值对放入 JSON 对象](#将键值对放入-json-对象) + - [从 JSON 对象获取值](#从-json-对象获取值) + - [JSON 对象和 Java 对象间的映射](#json-对象和-java-对象间的映射) + - [将 JSON 对象编码成字符串](#将-json-对象编码成字符串) + - [JSON 数组](#json-数组) + - [创建 JSON 数组](#创建-json-数组) + - [将数组项添加到JSON数组](#将数组项添加到json数组) + - [从 JSON 数组中获取值](#从-json-数组中获取值) + - [将 JSON 数组编码成字符串](#将-json-数组编码成字符串) + - [Buffer](#buffer) + - [创建 Buffer](#创建-buffer) + - [向Buffer写入数据](#向buffer写入数据) + - [追加到Buffer](#追加到buffer) + - [随机访问写Buffer](#随机访问写buffer) + - [从Buffer中读取](#从buffer中读取) + - [使用无符号数](#使用无符号数) + - [Buffer长度](#buffer长度) + - [拷贝Buffer](#拷贝buffer) + - [裁剪Buffer](#裁剪buffer) + - [Buffer 重用](#buffer-重用) + - [编写 TCP 服务端和客户端](#编写-tcp-服务端和客户端) + - [创建 TCP 服务端](#创建-tcp-服务端) + - [配置 TCP 服务端](#配置-tcp-服务端) + - [启动服务端监听](#启动服务端监听) + - [监听随机端口](#监听随机端口) + - [接收传入连接的通知](#接收传入连接的通知) + - [从Socket读取数据](#从socket读取数据) + - [向Socket中写入数据](#向socket中写入数据) + - [关闭处理器](#关闭处理器) + - [处理异常](#处理异常) + - [Event Bus 写处理器](#event-bus-写处理器) + - [本地和远程地址](#本地和远程地址) + - [发送文件或 Classpath 中的资源](#发送文件或-classpath-中的资源) + - [流式的Socket](#流式的socket) + - [升级到 SSL/TLS 连接](#升级到-ssltls-连接) + - [关闭 TCP 服务端](#关闭-tcp-服务端) + - [Verticle中的自动清理](#verticle中的自动清理) + - [扩展 - 共享 TCP 服务端](#扩展-共享-tcp-服务端) + - [创建 TCP 客户端](#创建-tcp-客户端) + - [配置 TCP 客户端](#配置-tcp-客户端) + - [创建连接](#创建连接) + - [配置连接重试](#配置连接重试) + - [记录网络活动](#记录网络活动) + - [配置服务端和客户端以使用SSL/TLS](#配置服务端和客户端以使用ssltls) + - [在服务端启用SSL/TLS](#在服务端启用ssltls) + - [指定服务端的密钥/证书](#指定服务端的密钥证书) + - [指定服务器信任](#指定服务器信任) + - [客户端启用SSL/TLS](#客户端启用ssltls) + - [客户端受信配置](#客户端受信配置) + - [指定客户端的密钥/证书](#指定客户端的密钥证书) + - [用于测试和开发目的的自签名证书](#用于测试和开发目的的自签名证书) + - [待撤销证书颁发机构](#待撤销证书颁发机构) + - [配置密码套件](#配置密码套件) + - [配置TLS协议版本](#配置tls协议版本) + - [SSL引擎](#ssl引擎) + - [应用层协议协商](#应用层协议协商) + - [OpenSSL ALPN支持](#openssl-alpn支持) + - [Jetty-ALPN支持](#jetty-alpn支持) + - [客户端连接使用代理](#客户端连接使用代理) + - [编写 HTTP 服务端和客户端](#编写-http-服务端和客户端) + - [创建 HTTP 服务端](#创建-http-服务端) + - [配置 HTTP 服务端](#配置-http-服务端) + - [配置 HTTP/2 服务端](#配置-http2-服务端) + - [记录服务端网络活动](#记录服务端网络活动) + - [开启服务端监听](#开启服务端监听) + - [收到传入请求的通知](#收到传入请求的通知) + - [处理请求](#处理请求) + - [请求版本](#请求版本) + - [请求方法](#请求方法) + - [请求URI](#请求uri) + - [请求路径](#请求路径) + - [请求查询](#请求查询) + - [请求头部](#请求头部) + - [请求主机](#请求主机) + - [请求参数](#请求参数) + - [远程地址](#远程地址) + - [绝对URI](#绝对uri) + - [结束处理器](#结束处理器) + - [请求体中读取数据](#请求体中读取数据) + - [Pumping 请求](#pumping-请求) + - [处理 HTML 表单](#处理-html-表单) + - [处理文件上传](#处理文件上传) + - [处理压缩体](#处理压缩体) + - [接收自定义 HTTP/2 帧](#接收自定义-http2-帧) + - [非标准的 HTTP 方法](#非标准的-http-方法) + - [发回响应](#发回响应) + - [设置状态码和消息](#设置状态码和消息) + - [向 HTTP 响应写入数据](#向-http-响应写入数据) + - [完成 HTTP 响应](#完成-http-响应) + - [关闭底层连接](#关闭底层连接) + - [设置响应头](#设置响应头) + - [分块 HTTP 响应和附加尾部](#分块-http-响应和附加尾部) + - [直接从磁盘或 Classpath 读文件](#直接从磁盘或-classpath-读文件) + - [Pumping 响应](#pumping-响应) + - [写入 HTTP/2 帧](#写入-http2-帧) + - [流重置](#流重置) + - [服务器推送](#服务器推送) + - [HTTP 压缩](#http-压缩) + - [创建 HTTP 客户端](#创建-http-客户端) + - [记录客户端网络活动](#记录客户端网络活动) + - [发出请求](#发出请求) + - [无请求体的简单请求](#无请求体的简单请求) + - [发送通用请求](#发送通用请求) + - [写请求体](#写请求体) + - [写请求头](#写请求头) + - [非标准的HTTP 方法](#非标准的http-方法) + - [发送 HTTP 请求](#发送-http-请求) + - [分块 HTTP 请求](#分块-http-请求) + - [请求超时](#请求超时) + - [处理异常](#处理异常) + - [客户端请求中指定处理器](#客户端请求中指定处理器) + - [使用流式请求](#使用流式请求) + - [写 HTTP/2 帧](#写-http2-帧) + - [流重置](#流重置) + - [处理 HTTP 响应](#处理-http-响应) + - [使用流式响应](#使用流式响应) + - [响应头和尾](#响应头和尾) + - [读取请求体](#读取请求体) + - [响应完成处理器](#响应完成处理器) + - [从响应中读取Cookie](#从响应中读取cookie) + - [30x 重定向处理器](#30x-重定向处理器) + - [100-Continue 处理](#100-continue-处理) + - [客户端推送](#客户端推送) + - [接收自定义 HTTP/2 帧](#接收自定义-http2-帧) + - [客户端启用压缩](#客户端启用压缩) + - [HTTP/1.x Pooling 和 Keep alive](#http1x-pooling-和-keep-alive) + - [HTTP/1.1 Pipe-lining](#http11-pipe-lining) + - [HTTP/2 多路复用](#http2-多路复用) + - [HTTP 连接](#http-连接) + - [服务端连接](#服务端连接) + - [客户端连接](#客户端连接) + - [连接配置](#连接配置) + - [连接 Ping](#连接-ping) + - [连接关闭/GOAWAY](#连接关闭goaway) + - [连接关闭](#连接关闭) + - [HttpClient 使用说明](#httpclient-使用说明) + - [水平扩展 - 服务端共享](#水平扩展-服务端共享) + - [使用 HTTPS](#使用-https) + - [WebSocket](#websocket) + - [服务端 WebSocket](#服务端-websocket) + - [客户端 WebSocket](#客户端-websocket) + - [向 WebSocket 写入消息](#向-websocket-写入消息) + - [向 WebSocket 写入帧](#向-websocket-写入帧) + - [从 WebSocket 读取帧](#从-websocket-读取帧) + - [关闭 WebSocket](#关闭-websocket) + - [流式 WebSocket](#流式-websocket) + - [使用 HTTP/HTTPS 连接代理](#使用-httphttps-连接代理) + - [Verticle 中自动清理](#verticle-中自动清理) + - [使用 Vert.x 共享数据](#使用-vertx-共享数据) + - [本地共享Map](#本地共享map) + - [集群范围异步Map](#集群范围异步map) + - [将数据放入Map](#将数据放入map) + - [从Map读取数据](#从map读取数据) + - [其他Map操作](#其他map操作) + - [集群范围锁](#集群范围锁) + - [集群范围计时器](#集群范围计时器) + - [访问文件系统](#访问文件系统) + - [异步文件访问](#异步文件访问) + - [随机访问写](#随机访问写) + - [随机访问读](#随机访问读) + - [打开选项](#打开选项) + - [将数据刷新到底层存储](#将数据刷新到底层存储) + - [将 AsyncFile 作为 ReadStream 和 WriteStream](#将-asyncfile-作为-readstream-和-writestream) + - [从 Classpath 访问文件](#从-classpath-访问文件) + - [关闭 AsyncFile](#关闭-asyncfile) + - [数据报套接字（UDP）](#数据报套接字udp) + - [创建 DatagramSocket](#创建-datagramsocket) + - [发送数据报包](#发送数据报包) + - [接收数据报包](#接收数据报包) + - [多播](#多播) + - [发送多播数据包](#发送多播数据包) + - [接收多播数据包](#接收多播数据包) + - [取消订阅/离开多播组](#取消订阅离开多播组) + - [屏蔽多播](#屏蔽多播) + - [DatagramSocket 属性](#datagramsocket-属性) + - [DatagramSocket本地地址](#datagramsocket本地地址) + - [关闭DatagramSocket](#关闭datagramsocket) + - [DNS 客户端](#dns-客户端) + - [lookup](#lookup) + - [lookup4](#lookup4) + - [lookup6](#lookup6) + - [resolveA](#resolvea) + - [resolveAAAA](#resolveaaaa) + - [resolveCNAME](#resolvecname) + - [resolveMX](#resolvemx) + - [resolveTXT](#resolvetxt) + - [resolveNS](#resolvens) + - [resolveSRV](#resolvesrv) + - [resolvePTR](#resolveptr) + - [reverseLookup](#reverselookup) + - [错误处理](#错误处理) + - [流](#流) + - [ReadStream](#readstream) + - [WriteStream](#writestream) + - [泵](#泵) + - [记录解析器](#记录解析器) + - [线程安全](#线程安全) + - [Metrics SPI](#metrics-spi) + - [OSGi](#osgi) + - [vertx 命令行](#vertx-命令行) + - [运行 Verticle](#运行-verticle) + - [执行打包成 fat-jar 的Vert.x 应用](#执行打包成-fat-jar-的vertx-应用) + - [显示Vert.x的版本](#显示vertx的版本) + - [其他命令](#其他命令) +- [or](#or) + - [实时重部署](#实时重部署) + - [集群管理器](#集群管理器) + - [日志记录](#日志记录) + - [配置JUL日志记录](#配置jul日志记录) + - [使用另一个日志框架](#使用另一个日志框架) + - [应用中记录日志](#应用中记录日志) + - [Netty日志记录](#netty日志记录) + - [故障排除](#故障排除) + - [SLF4J启动警告](#slf4j启动警告) + - [对等连接重置](#对等连接重置) + - [主机名解析](#主机名解析) + - [故障转移](#故障转移) + - [服务器列表轮询](#服务器列表轮询) + - [主机映射](#主机映射) + - [搜索域名](#搜索域名) + - [高可用/故障转移](#高可用故障转移) + - [自动故障转移](#自动故障转移) + - [HA组](#ha组) + - [处理网络分区 - Quora](#处理网络分区-quora) + - [安全注意事项](#安全注意事项) + - [Web 应用](#web-应用) + - [集群模式 Event Bus 流量](#集群模式-event-bus-流量) + - [标准安全最佳实践](#标准安全最佳实践) + - [Vert.x 命令行接口API](#vertx-命令行接口api) + - [定义阶段](#定义阶段) + - [选项](#选项) + - [参数](#参数) + - [生成 usage 信息](#生成-usage-信息) + - [解析阶段](#解析阶段) + - [查询/审问阶段](#查询审问阶段) + - [有类型选项和参数](#有类型选项和参数) + - [使用注解](#使用注解) + - [Vert.x Launcher](#vertx-launcher) + - [扩展 Vert.x 启动器](#扩展-vertx-启动器) + - [在 fat-jar 中使用启动器](#在-fat-jar-中使用启动器) + - [启动器子类](#启动器子类) + - [启动器和退出代码](#启动器和退出代码) + - [配置 Vert.x 缓存](#配置-vertx-缓存) +- [或者](#或者) + - [结语](#结语) + + + ## 中英对照表 * Client：客户端 From 7dc68c6b566bec138c86111f4f0ff050ea8ac0b0 Mon Sep 17 00:00:00 2001 From: downgoon Date: Tue, 6 Jun 2017 20:40:51 +0800 Subject: [PATCH 2/4] remove atom-toc label and add gitbook-atoc tag in vertx core --- README.md | 2 +- book.json | 10 +- core/Core.md | 323 +-------------------------------------------------- 3 files changed, 10 insertions(+), 325 deletions(-) diff --git a/README.md b/README.md index f872ab0..0add1da 100644 --- a/README.md +++ b/README.md @@ -55,7 +55,7 @@ sudo npm install gitbook-cli -g 进入项目根目录，执行构建： ```bash -rm -rf docs && gitbook build ./ docs +rm -rf docs && gitbook install && gitbook build ./ docs ``` 构建之后将 `docs` 目录的所有更新提交。 diff --git a/book.json b/book.json index 5dff0c5..b834a52 100644 --- a/book.json +++ b/book.json @@ -30,7 +30,13 @@ "pageNumbers": false, "paperSize": "a4" }, - "plugins": [], + "plugins": ["atoc"], + "pluginsConfig": { + "atoc": { + "addClass": true, + "className": "atoc" + } + }, "title": "Vert.x 官方文档中文翻译", "variables": {} -} \ No newline at end of file +} diff --git a/core/Core.md b/core/Core.md index fd67559..5598864 100644 --- a/core/Core.md +++ b/core/Core.md @@ -1,327 +1,6 @@ # Vert.x Core 文档手册 - - -- [Vert.x Core 文档手册](#vertx-core-文档手册) - - [中英对照表](#中英对照表) - - [组件介绍](#组件介绍) - - [故事从 Vert.x 开始](#故事从-vertx-开始) - - [创建 Vertx 对象时指定配置项](#创建-vertx-对象时指定配置项) - - [创建集群模式的 Vert.x 对象](#创建集群模式的-vertx-对象) - - [是流式的吗？](#是流式的吗) - - [Don’t call us, we’ll call you](#dont-call-us-well-call-you) - - [不要阻塞我！](#不要阻塞我) - - [Reactor 模式和 Multi-Reactor 模式](#reactor-模式和-multi-reactor-模式) - - [黄金法则：不要阻塞Event Loop](#黄金法则不要阻塞event-loop) - - [运行阻塞式代码](#运行阻塞式代码) - - [异步协调](#异步协调) - - [并发合并](#并发合并) - - [顺序合并](#顺序合并) - - [Verticle](#verticle) - - [编写 Verticle](#编写-verticle) - - [Verticle 异步启动和停止](#verticle-异步启动和停止) - - [Verticle 种类](#verticle-种类) - - [Standard Verticle](#standard-verticle) - - [Worker Verticle](#worker-verticle) - - [Multi-threaded Worker Verticle](#multi-threaded-worker-verticle) - - [编程方式部署Verticle](#编程方式部署verticle) - - [Verticle名称到Factory的映射规则](#verticle名称到factory的映射规则) - - [如何定位Verticle Factory？](#如何定位verticle-factory) - - [等待部署完成](#等待部署完成) - - [撤销Verticle](#撤销verticle) - - [设置 Verticle 实例数](#设置-verticle-实例数) - - [向 Verticle 传入配置](#向-verticle-传入配置) - - [在 Verticle 中访问环境变量](#在-verticle-中访问环境变量) - - [Verticle 隔离组](#verticle-隔离组) - - [高可用性](#高可用性) - - [从命令行运行Verticle](#从命令行运行verticle) -- [运行JavaScript的Verticle](#运行javascript的verticle) -- [运行Ruby的Verticle](#运行ruby的verticle) -- [使用集群模式运行Groovy的Verticle](#使用集群模式运行groovy的verticle) - - [退出 Vert.x 环境](#退出-vertx-环境) - - [Context 对象](#context-对象) - - [执行周期性/延迟性操作](#执行周期性延迟性操作) - - [一次性计时器](#一次性计时器) - - [周期性计时器](#周期性计时器) - - [取消计时器](#取消计时器) - - [Verticle 中自动清除定时器](#verticle-中自动清除定时器) - - [Verticle Worker Pool](#verticle-worker-pool) - - [Event Bus](#event-bus) - - [基本概念](#基本概念) - - [寻址](#寻址) - - [处理器](#处理器) - - [发布/订阅消息](#发布订阅消息) - - [点对点模式/请求-响应模式](#点对点模式请求-响应模式) - - [尽力传输](#尽力传输) - - [消息类型](#消息类型) - - [Event Bus API](#event-bus-api) - - [获取Event Bus](#获取event-bus) - - [注册处理器](#注册处理器) - - [注销处理器](#注销处理器) - - [发布消息](#发布消息) - - [发送消息](#发送消息) - - [设置消息头](#设置消息头) - - [消息顺序](#消息顺序) - - [消息对象](#消息对象) - - [应答消息/发送回复](#应答消息发送回复) - - [带超时的发送](#带超时的发送) - - [发送失败](#发送失败) - - [消息编解码器](#消息编解码器) - - [集群模式的 Event Bus](#集群模式的-event-bus) - - [通过代码的方式启用集群模式](#通过代码的方式启用集群模式) - - [通过命令行启用集群模式](#通过命令行启用集群模式) - - [Verticle 中的自动清理](#verticle-中的自动清理) - - [配置 Event Bus](#配置-event-bus) - - [JSON](#json) - - [JSON 对象](#json-对象) - - [创建 JSON 对象](#创建-json-对象) - - [将键值对放入 JSON 对象](#将键值对放入-json-对象) - - [从 JSON 对象获取值](#从-json-对象获取值) - - [JSON 对象和 Java 对象间的映射](#json-对象和-java-对象间的映射) - - [将 JSON 对象编码成字符串](#将-json-对象编码成字符串) - - [JSON 数组](#json-数组) - - [创建 JSON 数组](#创建-json-数组) - - [将数组项添加到JSON数组](#将数组项添加到json数组) - - [从 JSON 数组中获取值](#从-json-数组中获取值) - - [将 JSON 数组编码成字符串](#将-json-数组编码成字符串) - - [Buffer](#buffer) - - [创建 Buffer](#创建-buffer) - - [向Buffer写入数据](#向buffer写入数据) - - [追加到Buffer](#追加到buffer) - - [随机访问写Buffer](#随机访问写buffer) - - [从Buffer中读取](#从buffer中读取) - - [使用无符号数](#使用无符号数) - - [Buffer长度](#buffer长度) - - [拷贝Buffer](#拷贝buffer) - - [裁剪Buffer](#裁剪buffer) - - [Buffer 重用](#buffer-重用) - - [编写 TCP 服务端和客户端](#编写-tcp-服务端和客户端) - - [创建 TCP 服务端](#创建-tcp-服务端) - - [配置 TCP 服务端](#配置-tcp-服务端) - - [启动服务端监听](#启动服务端监听) - - [监听随机端口](#监听随机端口) - - [接收传入连接的通知](#接收传入连接的通知) - - [从Socket读取数据](#从socket读取数据) - - [向Socket中写入数据](#向socket中写入数据) - - [关闭处理器](#关闭处理器) - - [处理异常](#处理异常) - - [Event Bus 写处理器](#event-bus-写处理器) - - [本地和远程地址](#本地和远程地址) - - [发送文件或 Classpath 中的资源](#发送文件或-classpath-中的资源) - - [流式的Socket](#流式的socket) - - [升级到 SSL/TLS 连接](#升级到-ssltls-连接) - - [关闭 TCP 服务端](#关闭-tcp-服务端) - - [Verticle中的自动清理](#verticle中的自动清理) - - [扩展 - 共享 TCP 服务端](#扩展-共享-tcp-服务端) - - [创建 TCP 客户端](#创建-tcp-客户端) - - [配置 TCP 客户端](#配置-tcp-客户端) - - [创建连接](#创建连接) - - [配置连接重试](#配置连接重试) - - [记录网络活动](#记录网络活动) - - [配置服务端和客户端以使用SSL/TLS](#配置服务端和客户端以使用ssltls) - - [在服务端启用SSL/TLS](#在服务端启用ssltls) - - [指定服务端的密钥/证书](#指定服务端的密钥证书) - - [指定服务器信任](#指定服务器信任) - - [客户端启用SSL/TLS](#客户端启用ssltls) - - [客户端受信配置](#客户端受信配置) - - [指定客户端的密钥/证书](#指定客户端的密钥证书) - - [用于测试和开发目的的自签名证书](#用于测试和开发目的的自签名证书) - - [待撤销证书颁发机构](#待撤销证书颁发机构) - - [配置密码套件](#配置密码套件) - - [配置TLS协议版本](#配置tls协议版本) - - [SSL引擎](#ssl引擎) - - [应用层协议协商](#应用层协议协商) - - [OpenSSL ALPN支持](#openssl-alpn支持) - - [Jetty-ALPN支持](#jetty-alpn支持) - - [客户端连接使用代理](#客户端连接使用代理) - - [编写 HTTP 服务端和客户端](#编写-http-服务端和客户端) - - [创建 HTTP 服务端](#创建-http-服务端) - - [配置 HTTP 服务端](#配置-http-服务端) - - [配置 HTTP/2 服务端](#配置-http2-服务端) - - [记录服务端网络活动](#记录服务端网络活动) - - [开启服务端监听](#开启服务端监听) - - [收到传入请求的通知](#收到传入请求的通知) - - [处理请求](#处理请求) - - [请求版本](#请求版本) - - [请求方法](#请求方法) - - [请求URI](#请求uri) - - [请求路径](#请求路径) - - [请求查询](#请求查询) - - [请求头部](#请求头部) - - [请求主机](#请求主机) - - [请求参数](#请求参数) - - [远程地址](#远程地址) - - [绝对URI](#绝对uri) - - [结束处理器](#结束处理器) - - [请求体中读取数据](#请求体中读取数据) - - [Pumping 请求](#pumping-请求) - - [处理 HTML 表单](#处理-html-表单) - - [处理文件上传](#处理文件上传) - - [处理压缩体](#处理压缩体) - - [接收自定义 HTTP/2 帧](#接收自定义-http2-帧) - - [非标准的 HTTP 方法](#非标准的-http-方法) - - [发回响应](#发回响应) - - [设置状态码和消息](#设置状态码和消息) - - [向 HTTP 响应写入数据](#向-http-响应写入数据) - - [完成 HTTP 响应](#完成-http-响应) - - [关闭底层连接](#关闭底层连接) - - [设置响应头](#设置响应头) - - [分块 HTTP 响应和附加尾部](#分块-http-响应和附加尾部) - - [直接从磁盘或 Classpath 读文件](#直接从磁盘或-classpath-读文件) - - [Pumping 响应](#pumping-响应) - - [写入 HTTP/2 帧](#写入-http2-帧) - - [流重置](#流重置) - - [服务器推送](#服务器推送) - - [HTTP 压缩](#http-压缩) - - [创建 HTTP 客户端](#创建-http-客户端) - - [记录客户端网络活动](#记录客户端网络活动) - - [发出请求](#发出请求) - - [无请求体的简单请求](#无请求体的简单请求) - - [发送通用请求](#发送通用请求) - - [写请求体](#写请求体) - - [写请求头](#写请求头) - - [非标准的HTTP 方法](#非标准的http-方法) - - [发送 HTTP 请求](#发送-http-请求) - - [分块 HTTP 请求](#分块-http-请求) - - [请求超时](#请求超时) - - [处理异常](#处理异常) - - [客户端请求中指定处理器](#客户端请求中指定处理器) - - [使用流式请求](#使用流式请求) - - [写 HTTP/2 帧](#写-http2-帧) - - [流重置](#流重置) - - [处理 HTTP 响应](#处理-http-响应) - - [使用流式响应](#使用流式响应) - - [响应头和尾](#响应头和尾) - - [读取请求体](#读取请求体) - - [响应完成处理器](#响应完成处理器) - - [从响应中读取Cookie](#从响应中读取cookie) - - [30x 重定向处理器](#30x-重定向处理器) - - [100-Continue 处理](#100-continue-处理) - - [客户端推送](#客户端推送) - - [接收自定义 HTTP/2 帧](#接收自定义-http2-帧) - - [客户端启用压缩](#客户端启用压缩) - - [HTTP/1.x Pooling 和 Keep alive](#http1x-pooling-和-keep-alive) - - [HTTP/1.1 Pipe-lining](#http11-pipe-lining) - - [HTTP/2 多路复用](#http2-多路复用) - - [HTTP 连接](#http-连接) - - [服务端连接](#服务端连接) - - [客户端连接](#客户端连接) - - [连接配置](#连接配置) - - [连接 Ping](#连接-ping) - - [连接关闭/GOAWAY](#连接关闭goaway) - - [连接关闭](#连接关闭) - - [HttpClient 使用说明](#httpclient-使用说明) - - [水平扩展 - 服务端共享](#水平扩展-服务端共享) - - [使用 HTTPS](#使用-https) - - [WebSocket](#websocket) - - [服务端 WebSocket](#服务端-websocket) - - [客户端 WebSocket](#客户端-websocket) - - [向 WebSocket 写入消息](#向-websocket-写入消息) - - [向 WebSocket 写入帧](#向-websocket-写入帧) - - [从 WebSocket 读取帧](#从-websocket-读取帧) - - [关闭 WebSocket](#关闭-websocket) - - [流式 WebSocket](#流式-websocket) - - [使用 HTTP/HTTPS 连接代理](#使用-httphttps-连接代理) - - [Verticle 中自动清理](#verticle-中自动清理) - - [使用 Vert.x 共享数据](#使用-vertx-共享数据) - - [本地共享Map](#本地共享map) - - [集群范围异步Map](#集群范围异步map) - - [将数据放入Map](#将数据放入map) - - [从Map读取数据](#从map读取数据) - - [其他Map操作](#其他map操作) - - [集群范围锁](#集群范围锁) - - [集群范围计时器](#集群范围计时器) - - [访问文件系统](#访问文件系统) - - [异步文件访问](#异步文件访问) - - [随机访问写](#随机访问写) - - [随机访问读](#随机访问读) - - [打开选项](#打开选项) - - [将数据刷新到底层存储](#将数据刷新到底层存储) - - [将 AsyncFile 作为 ReadStream 和 WriteStream](#将-asyncfile-作为-readstream-和-writestream) - - [从 Classpath 访问文件](#从-classpath-访问文件) - - [关闭 AsyncFile](#关闭-asyncfile) - - [数据报套接字（UDP）](#数据报套接字udp) - - [创建 DatagramSocket](#创建-datagramsocket) - - [发送数据报包](#发送数据报包) - - [接收数据报包](#接收数据报包) - - [多播](#多播) - - [发送多播数据包](#发送多播数据包) - - [接收多播数据包](#接收多播数据包) - - [取消订阅/离开多播组](#取消订阅离开多播组) - - [屏蔽多播](#屏蔽多播) - - [DatagramSocket 属性](#datagramsocket-属性) - - [DatagramSocket本地地址](#datagramsocket本地地址) - - [关闭DatagramSocket](#关闭datagramsocket) - - [DNS 客户端](#dns-客户端) - - [lookup](#lookup) - - [lookup4](#lookup4) - - [lookup6](#lookup6) - - [resolveA](#resolvea) - - [resolveAAAA](#resolveaaaa) - - [resolveCNAME](#resolvecname) - - [resolveMX](#resolvemx) - - [resolveTXT](#resolvetxt) - - [resolveNS](#resolvens) - - [resolveSRV](#resolvesrv) - - [resolvePTR](#resolveptr) - - [reverseLookup](#reverselookup) - - [错误处理](#错误处理) - - [流](#流) - - [ReadStream](#readstream) - - [WriteStream](#writestream) - - [泵](#泵) - - [记录解析器](#记录解析器) - - [线程安全](#线程安全) - - [Metrics SPI](#metrics-spi) - - [OSGi](#osgi) - - [vertx 命令行](#vertx-命令行) - - [运行 Verticle](#运行-verticle) - - [执行打包成 fat-jar 的Vert.x 应用](#执行打包成-fat-jar-的vertx-应用) - - [显示Vert.x的版本](#显示vertx的版本) - - [其他命令](#其他命令) -- [or](#or) - - [实时重部署](#实时重部署) - - [集群管理器](#集群管理器) - - [日志记录](#日志记录) - - [配置JUL日志记录](#配置jul日志记录) - - [使用另一个日志框架](#使用另一个日志框架) - - [应用中记录日志](#应用中记录日志) - - [Netty日志记录](#netty日志记录) - - [故障排除](#故障排除) - - [SLF4J启动警告](#slf4j启动警告) - - [对等连接重置](#对等连接重置) - - [主机名解析](#主机名解析) - - [故障转移](#故障转移) - - [服务器列表轮询](#服务器列表轮询) - - [主机映射](#主机映射) - - [搜索域名](#搜索域名) - - [高可用/故障转移](#高可用故障转移) - - [自动故障转移](#自动故障转移) - - [HA组](#ha组) - - [处理网络分区 - Quora](#处理网络分区-quora) - - [安全注意事项](#安全注意事项) - - [Web 应用](#web-应用) - - [集群模式 Event Bus 流量](#集群模式-event-bus-流量) - - [标准安全最佳实践](#标准安全最佳实践) - - [Vert.x 命令行接口API](#vertx-命令行接口api) - - [定义阶段](#定义阶段) - - [选项](#选项) - - [参数](#参数) - - [生成 usage 信息](#生成-usage-信息) - - [解析阶段](#解析阶段) - - [查询/审问阶段](#查询审问阶段) - - [有类型选项和参数](#有类型选项和参数) - - [使用注解](#使用注解) - - [Vert.x Launcher](#vertx-launcher) - - [扩展 Vert.x 启动器](#扩展-vertx-启动器) - - [在 fat-jar 中使用启动器](#在-fat-jar-中使用启动器) - - [启动器子类](#启动器子类) - - [启动器和退出代码](#启动器和退出代码) - - [配置 Vert.x 缓存](#配置-vertx-缓存) -- [或者](#或者) - - [结语](#结语) - - + ## 中英对照表 From 9cc3352bacf04d27169b2f93306927115a94cbff Mon Sep 17 00:00:00 2001 From: downgoon Date: Tue, 6 Jun 2017 20:42:36 +0800 Subject: [PATCH 3/4] rebuild gitbook --- docs/.gitignore | 16 - docs/PLAN.html | 1109 ---- docs/advanced/Advanced.md | 1 - docs/advanced/BridgeCommon.md | 1 - docs/advanced/Codegen.md | 1 - docs/advanced/Codetrans.md | 1 - docs/advanced/Distro.md | 1 - docs/advanced/Docgen.md | 1 - docs/advanced/WebSite.md | 1 - docs/auth/.htdigestAuth.md | 1 - docs/auth/Auth.html | 1062 ---- docs/auth/AuthCommon.html | 1144 ---- docs/auth/JDBCAuth.html | 1133 ---- docs/auth/JWTAuth.html | 1148 ---- docs/auth/MongoDBAuth.html | 1152 ---- docs/auth/Oauth2.html | 1306 ---- docs/auth/ShiroAuth.html | 1153 ---- docs/cloud/Cloud.html | 1059 ---- docs/cloud/OpenShift2DIYCartridge.md | 1 - docs/cloud/OpenShiftCartridge.html | 1059 ---- docs/cloud/OpenShiftUsingDIYCartridge.html | 1059 ---- docs/clustering/ApacheIgnite.html | 1154 ---- docs/clustering/ApacheZookeeper.html | 1180 ---- docs/clustering/Clustering.html | 1086 ---- docs/clustering/Hazelcast.html | 1254 ---- docs/clustering/Infinispan.html | 1328 ---- docs/clustering/JGroups.html | 1205 ---- docs/core/Core.html | 5361 ----------------- docs/data/Data.html | 1059 ---- docs/data/JDBCClient.html | 1221 ---- docs/data/MongoDBClient.html | 1780 ------ docs/data/MySQL&PostgreSQLClient.html | 1205 ---- docs/data/RedisClient.html | 1221 ---- docs/data/SQLCommon.html | 1343 ----- docs/devops/Devops.html | 1059 ---- docs/devops/Docker.html | 1059 ---- docs/devops/HealthCheck.md | 1 - docs/devops/MetricsUsingDropwizard.html | 1059 ---- docs/devops/MetricsUsingHawkular.html | 1059 ---- docs/devops/Shell.html | 1059 ---- docs/devops/StackManager.html | 1059 ---- docs/eventbusbridge/CamelBridge.html | 1053 ---- docs/eventbusbridge/TCPEventbusBridge.html | 1059 ---- .../gitbook/fonts/fontawesome/FontAwesome.otf | Bin 124988 -> 0 bytes .../fonts/fontawesome/fontawesome-webfont.eot | Bin 76518 -> 0 bytes .../fonts/fontawesome/fontawesome-webfont.svg | 685 --- .../fonts/fontawesome/fontawesome-webfont.ttf | Bin 152796 -> 0 bytes .../fontawesome/fontawesome-webfont.woff | Bin 90412 -> 0 bytes .../fontawesome/fontawesome-webfont.woff2 | Bin 71896 -> 0 bytes .../fontsettings.js | 240 - .../gitbook-plugin-fontsettings/website.css | 291 - .../gitbook-plugin-highlight/ebook.css | 135 - .../gitbook-plugin-highlight/website.css | 434 -- docs/gitbook/gitbook-plugin-lunr/lunr.min.js | 7 - .../gitbook-plugin-lunr/search-lunr.js | 59 - .../gitbook/gitbook-plugin-search/lunr.min.js | 7 - .../gitbook-plugin-search/search-engine.js | 50 - docs/gitbook/gitbook-plugin-search/search.css | 35 - docs/gitbook/gitbook-plugin-search/search.js | 213 - .../gitbook/gitbook-plugin-sharing/buttons.js | 90 - docs/gitbook/gitbook.js | 4 - .../apple-touch-icon-precomposed-152.png | Bin 4817 -> 0 bytes docs/gitbook/images/favicon.ico | Bin 4286 -> 0 bytes docs/gitbook/style.css | 9 - docs/gitbook/theme.js | 4 - docs/index.html | 1089 ---- docs/integration/AMQPBridge.md | 1 - docs/integration/ConsulClient .md | 1 - docs/integration/Integration.html | 1059 ---- docs/integration/JCAAdaptor.html | 1059 ---- docs/integration/KafkaClient.html | 1665 ----- docs/integration/MailClient.html | 1059 ---- docs/integration/RabbitMQClient.md | 1 - docs/integration/STOMPClient&Server.html | 1059 ---- docs/microservices/CircuitBreaker.html | 1278 ---- docs/microservices/Config.html | 1596 ----- docs/microservices/ServiceDiscovery.html | 1904 ------ docs/mqttserver/MQTTServer.md | 1 - docs/reactive/Reactive.html | 1060 ---- docs/reactive/Reactivestreams.html | 1124 ---- docs/reactive/Rx.html | 1470 ----- docs/reactive/Sync.html | 1150 ---- docs/search_index.json | 1 - docs/services/HTTPServiceFactory.html | 1059 ---- docs/services/MavenServiceFactory.html | 1059 ---- docs/services/ServiceFactories.html | 1142 ---- docs/services/ServiceProxies.html | 1460 ----- docs/services/Services.html | 1059 ---- docs/services/SockJSServiceProxies.html | 1059 ---- docs/services/gRPC.md | 1 - docs/start/FAQ.html | 1324 ---- docs/start/SimpleStart.html | 1192 ---- docs/start/Start.html | 1389 ----- docs/start/Start/comments-for-reader.md | 44 - docs/testing/Testing.html | 1059 ---- docs/web/Web.html | 2786 --------- docs/webclient/WebClient.html | 1544 ----- 97 files changed, 76290 deletions(-) delete mode 100644 docs/.gitignore delete mode 100644 docs/PLAN.html delete mode 100644 docs/advanced/Advanced.md delete mode 100644 docs/advanced/BridgeCommon.md delete mode 100644 docs/advanced/Codegen.md delete mode 100644 docs/advanced/Codetrans.md delete mode 100644 docs/advanced/Distro.md delete mode 100644 docs/advanced/Docgen.md delete mode 100644 docs/advanced/WebSite.md delete mode 100644 docs/auth/.htdigestAuth.md delete mode 100644 docs/auth/Auth.html delete mode 100644 docs/auth/AuthCommon.html delete mode 100644 docs/auth/JDBCAuth.html delete mode 100644 docs/auth/JWTAuth.html delete mode 100644 docs/auth/MongoDBAuth.html delete mode 100644 docs/auth/Oauth2.html delete mode 100644 docs/auth/ShiroAuth.html delete mode 100644 docs/cloud/Cloud.html delete mode 100644 docs/cloud/OpenShift2DIYCartridge.md delete mode 100644 docs/cloud/OpenShiftCartridge.html delete mode 100644 docs/cloud/OpenShiftUsingDIYCartridge.html delete mode 100644 docs/clustering/ApacheIgnite.html delete mode 100644 docs/clustering/ApacheZookeeper.html delete mode 100644 docs/clustering/Clustering.html delete mode 100644 docs/clustering/Hazelcast.html delete mode 100644 docs/clustering/Infinispan.html delete mode 100644 docs/clustering/JGroups.html delete mode 100644 docs/core/Core.html delete mode 100644 docs/data/Data.html delete mode 100644 docs/data/JDBCClient.html delete mode 100644 docs/data/MongoDBClient.html delete mode 100644 docs/data/MySQL&PostgreSQLClient.html delete mode 100644 docs/data/RedisClient.html delete mode 100644 docs/data/SQLCommon.html delete mode 100644 docs/devops/Devops.html delete mode 100644 docs/devops/Docker.html delete mode 100644 docs/devops/HealthCheck.md delete mode 100644 docs/devops/MetricsUsingDropwizard.html delete mode 100644 docs/devops/MetricsUsingHawkular.html delete mode 100644 docs/devops/Shell.html delete mode 100644 docs/devops/StackManager.html delete mode 100644 docs/eventbusbridge/CamelBridge.html delete mode 100644 docs/eventbusbridge/TCPEventbusBridge.html delete mode 100644 docs/gitbook/fonts/fontawesome/FontAwesome.otf delete mode 100644 docs/gitbook/fonts/fontawesome/fontawesome-webfont.eot delete mode 100644 docs/gitbook/fonts/fontawesome/fontawesome-webfont.svg delete mode 100644 docs/gitbook/fonts/fontawesome/fontawesome-webfont.ttf delete mode 100644 docs/gitbook/fonts/fontawesome/fontawesome-webfont.woff delete mode 100644 docs/gitbook/fonts/fontawesome/fontawesome-webfont.woff2 delete mode 100644 docs/gitbook/gitbook-plugin-fontsettings/fontsettings.js delete mode 100644 docs/gitbook/gitbook-plugin-fontsettings/website.css delete mode 100644 docs/gitbook/gitbook-plugin-highlight/ebook.css delete mode 100644 docs/gitbook/gitbook-plugin-highlight/website.css delete mode 100644 docs/gitbook/gitbook-plugin-lunr/lunr.min.js delete mode 100644 docs/gitbook/gitbook-plugin-lunr/search-lunr.js delete mode 100644 docs/gitbook/gitbook-plugin-search/lunr.min.js delete mode 100644 docs/gitbook/gitbook-plugin-search/search-engine.js delete mode 100644 docs/gitbook/gitbook-plugin-search/search.css delete mode 100644 docs/gitbook/gitbook-plugin-search/search.js delete mode 100644 docs/gitbook/gitbook-plugin-sharing/buttons.js delete mode 100644 docs/gitbook/gitbook.js delete mode 100644 docs/gitbook/images/apple-touch-icon-precomposed-152.png delete mode 100644 docs/gitbook/images/favicon.ico delete mode 100644 docs/gitbook/style.css delete mode 100644 docs/gitbook/theme.js delete mode 100644 docs/index.html delete mode 100644 docs/integration/AMQPBridge.md delete mode 100644 docs/integration/ConsulClient .md delete mode 100644 docs/integration/Integration.html delete mode 100644 docs/integration/JCAAdaptor.html delete mode 100644 docs/integration/KafkaClient.html delete mode 100644 docs/integration/MailClient.html delete mode 100644 docs/integration/RabbitMQClient.md delete mode 100644 docs/integration/STOMPClient&Server.html delete mode 100644 docs/microservices/CircuitBreaker.html delete mode 100644 docs/microservices/Config.html delete mode 100644 docs/microservices/ServiceDiscovery.html delete mode 100644 docs/mqttserver/MQTTServer.md delete mode 100644 docs/reactive/Reactive.html delete mode 100644 docs/reactive/Reactivestreams.html delete mode 100644 docs/reactive/Rx.html delete mode 100644 docs/reactive/Sync.html delete mode 100644 docs/search_index.json delete mode 100644 docs/services/HTTPServiceFactory.html delete mode 100644 docs/services/MavenServiceFactory.html delete mode 100644 docs/services/ServiceFactories.html delete mode 100644 docs/services/ServiceProxies.html delete mode 100644 docs/services/Services.html delete mode 100644 docs/services/SockJSServiceProxies.html delete mode 100644 docs/services/gRPC.md delete mode 100644 docs/start/FAQ.html delete mode 100644 docs/start/SimpleStart.html delete mode 100644 docs/start/Start.html delete mode 100644 docs/start/Start/comments-for-reader.md delete mode 100644 docs/testing/Testing.html delete mode 100644 docs/web/Web.html delete mode 100644 docs/webclient/WebClient.html diff --git a/docs/.gitignore b/docs/.gitignore deleted file mode 100644 index 4cb12d8..0000000 --- a/docs/.gitignore +++ /dev/null @@ -1,16 +0,0 @@ -# Node rules: -## Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files) -.grunt - -## Dependency directory -## Commenting this out is preferred by some people, see -## https://docs.npmjs.com/misc/faq#should-i-check-my-node_modules-folder-into-git -node_modules - -# Book build output -_book - -# eBook build output -*.epub -*.mobi -*.pdf diff --git a/docs/PLAN.html b/docs/PLAN.html deleted file mode 100644 index b900f99..0000000 --- a/docs/PLAN.html +++ /dev/null @@ -1,1109 +0,0 @@ - - - - - - - 翻译计划 · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
- - - - - - - - -
- -
- -
- - - - - - - - -
-
- -
-
- -
- -

Vert.x 官方文档翻译工作计划

-

当前进度

-

截至：2017-05-07

-

对应版本：Vert.x 3.4.1

-
    -
  • [x] Vert.x Core：已翻译校对完成
    • -
  • [x] Vert.x Web：已翻译校对完成
    • -
  • [x] Vert.x Web Client：已翻译校对完成
    • -
  • [x] Vert.x Data Access：已翻译校对完成
      -
    • [x] Vert.x Mongo Client：已翻译校对完成
      • -
    • [x] Vert.x JDBC Client：已翻译校对完成
      • -
    • [x] Vert.x Common SQL Interface：已翻译校对完成
      • -
    • [x] Vert.x Redis Client：已翻译校对完成
      • -
    • [x] Vert.x MySQL/PostgreSQL Client：已翻译校对完成
      • -
    -
    • -
  • [ ] Vert.x Integration
      -
    • [x] Vert.x Kafka Client：已翻译校对完成
      • -
    -
    • -
  • [x] Vert.x Microservices
      -
    • [x] Vert.x Circuit Breaker：已翻译校对完成
      • -
    • [x] Vert.x Service Discovery：已翻译校对完成
      • -
    • [x] Vert.x Config：已翻译校对完成
      • -
    -
    • -
  • [x] Vert.x Reactive：已翻译校对完成
    • -
  • [x] Vert.x Service Proxy：已重新翻译
    • -
  • [x] Vert.x Clustering：已翻译校对完成
    • -
  • [ ] Vert.x Testing
      -
    • [ ] Vert.x Unit：计划中
      • -
    -
    • -
  • [ ] Vert.x IoT：计划中
    • -
-

翻译计划

-

2017-06

-

待 Vert.x 3.4.2 发布后，更新相应的文档翻译。

-

2017-05

-
    -
  • Vert.x Unit：待认领
    • -
  • Vert.x IoT：lizhenxiang负责翻译，943470549@qq.com负责校对
    • -
  • Vert.x Clustering：boliza负责翻译，wuziqiang负责校对
    • -
-

本次计划预计五月下旬完成。

-

2017-03-28

-
    -
  • Core： silentbalanceyh负责翻译，chengenzhao、kkkoko、gy、hxl、Toyer、漓江校对
    • -
  • Web： gy负责翻译，chengenzhao校对
    • -
  • WebClient： chengenzhao负责翻译，zlf负责校对
    • -
  • Microservices： troopson@163.com，me.yan.xia@qq.com负责翻译和校对
    • -
  • Reactive： cet63负责翻译
    • -
  • IoT： lizhenxiang负责翻译，943470549@qq.com负责校对
    • -
  • data access： DaC1989负责翻译，kkkoko校对
    • -
  • Clustering： boliza负责翻译，wuziqiang负责校对
    • -
-

本次计划预计五月中旬完成。

- - -
- -
-
-
- -

results matching ""

-
    - -
    -
    - -

    No results matching ""

    - -
    -
    -
    - -
    -
    - -
    - - - - - - - - - - -
    - - -
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/advanced/Advanced.md b/docs/advanced/Advanced.md deleted file mode 100644 index 1d5415b..0000000 --- a/docs/advanced/Advanced.md +++ /dev/null @@ -1 +0,0 @@ -# Vert.x Advanced diff --git a/docs/advanced/BridgeCommon.md b/docs/advanced/BridgeCommon.md deleted file mode 100644 index bfc2149..0000000 --- a/docs/advanced/BridgeCommon.md +++ /dev/null @@ -1 +0,0 @@ -# Vert.x Bridge Common diff --git a/docs/advanced/Codegen.md b/docs/advanced/Codegen.md deleted file mode 100644 index 42d16e1..0000000 --- a/docs/advanced/Codegen.md +++ /dev/null @@ -1 +0,0 @@ -# Vert.x Codegen diff --git a/docs/advanced/Codetrans.md b/docs/advanced/Codetrans.md deleted file mode 100644 index e19a908..0000000 --- a/docs/advanced/Codetrans.md +++ /dev/null @@ -1 +0,0 @@ -# Vert.x Codetrans diff --git a/docs/advanced/Distro.md b/docs/advanced/Distro.md deleted file mode 100644 index 4494323..0000000 --- a/docs/advanced/Distro.md +++ /dev/null @@ -1 +0,0 @@ -# Vert.x Distro diff --git a/docs/advanced/Docgen.md b/docs/advanced/Docgen.md deleted file mode 100644 index cbf4726..0000000 --- a/docs/advanced/Docgen.md +++ /dev/null @@ -1 +0,0 @@ -# Vert.x Docgen diff --git a/docs/advanced/WebSite.md b/docs/advanced/WebSite.md deleted file mode 100644 index e094777..0000000 --- a/docs/advanced/WebSite.md +++ /dev/null @@ -1 +0,0 @@ -# Vert.x Web-site diff --git a/docs/auth/.htdigestAuth.md b/docs/auth/.htdigestAuth.md deleted file mode 100644 index 05c8de1..0000000 --- a/docs/auth/.htdigestAuth.md +++ /dev/null @@ -1 +0,0 @@ -# Vert.x .htdigest Auth \ No newline at end of file diff --git a/docs/auth/Auth.html b/docs/auth/Auth.html deleted file mode 100644 index 48eaad9..0000000 --- a/docs/auth/Auth.html +++ /dev/null @@ -1,1062 +0,0 @@ - - - - - - - Authentication and Authorisation · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    -
    - - - - - - - - -
    - -
    - -
    - - - - - - - - -
    -
    - -
    -
    - -
    - -

    Vert.x Authentication and Authorisation

    -

    Vert.x为您的应用程序提供了简单的认证API。我们还提供了一些开箱即用的实现

    -

    http://vertx.io/docs/
    Auth common：http://vertx.io/docs/vertx-auth-common/java/
    JDBC auth：http://vertx.io/docs/vertx-auth-jdbc/java/
    JWT auth：http://vertx.io/docs/vertx-auth-jwt/java/
    Shiro auth：http://vertx.io/docs/vertx-auth-shiro/java/
    MongoDB auth：http://vertx.io/docs/vertx-auth-mongo/java/
    OAuth 2：http://vertx.io/docs/vertx-auth-oauth2/java/

    -

    译者：虞浪，易世伟
    校对：钟子期，易世伟

    - - -
    - -
    -
    -
    - -

    results matching ""

    -
      - -
      -
      - -

      No results matching ""

      - -
      -
      -
      - -
      -
      - -
      - - - - - - - - - - - - - - -
      - - -
      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/auth/AuthCommon.html b/docs/auth/AuthCommon.html deleted file mode 100644 index c5e7c26..0000000 --- a/docs/auth/AuthCommon.html +++ /dev/null @@ -1,1144 +0,0 @@ - - - - - - - Auth Common · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      -
      - - - - - - - - -
      - -
      - -
      - - - - - - - - -
      -
      - -
      -
      - -
      - -

      Vert.x Auth Common

      - -

      基本术语

      -
        -
      • Authentication：认证
        • -
      • Authorisation：授权
        • -
      • Authority：权限
        • -
      • Permission：许可
        • -
      • Role：角色
        • -
      • User：用户
        • -
      • Token：令牌
        • -
      • Principal：凭证
        • -
      • Handler：处理器
        • -
      -
      - -

      Vert.X Auth项目提供了处理认证和授权的功能，它可以被vertx-web项目使用，若要在自己的项目中运用它，则需要在构建描述信息的dependencies节点中添加如下信息：

      -
        -

      • Maven（在pom.xml文件中）

        -
          <dependency>
-      <groupId>io.vertx</groupId>
-      <artifactId>vertx-auth-common</artifactId>
-      <version>3.2.1</version>
-  </dependency>
-
        • -

      • Gradle（在build.gradle文件中）

        -
          compile io.vertx:vertx-auth-common:3.2.1
-
        • -
      -

      基本概念

      -

      认证Authentication：用于验证用户的标识和身份。

      -

      授权Authorisation：用于验证用户是否拥有访问系统的许可。

      -

      权限Authority：它取决于一些特定的系统实现但对特定的模型不做任何要求；比如：许可/角色permissions/roles模型，可以使事情变得灵活。在一些实现中一个权限可以用来表述一个许可，如：有权限访问所有打印机、或特定打印机。在另外一些实现中则必须支持角色信息，通常使用一些角色信息对权限进行前缀role:命名/标识，如：role:admin。还有一些实现也许会包含更加复杂以及不同的模型来表述权限信息。

      -

      如果要了解期望的特定认证提供者Auth Provider，则可以按照文档中的内容实施。

      -

      认证

      -

      如果要对用户进行认证可使用Provider中的authenticate方法。

      -

      这个方法的第一个参数是一个JSON对象，它包含了认证用的信息，实际上这些信息取决于特定的实现；对于简单基于用户名/密码username/password的认证包含了如下信息：

      -
      {
-    “username": "tim",
-    "password": "mypassword"
-}
-

      对于一些基于JWT Token或OAuth Bearer Token的实现还会在认证信息中包含令牌Token信息。Vert.X中的认证是异步执行，在调用过程中，认证结果被传给结果处理器中的用户User对象里，异步调用结果包含了一个用户User的实例，这个实例表述了已经认证过的用户信息，并且包含了这些用户允许执行的合法操作。

      -

      这里是一个简单的基于用户名/密码username/password认证用户的代码实现：

      -
      JsonObject authInfo = new JsonObject().put("username", "tim").put("password", "mypassword");
-
-    authProvider.authenticate(authInfo, res -> {
-        if (res.succeeded()) {
-
-            User user = res.result();
-
-            System.out.println("User " + user.principal() + " is now authenticated");
-        } else {
-            res.cause().printStackTrace();
-        }
-});
-

      授权

      -

      一旦你拥有了一个用户User的实例过后，你就可以调用它的方法对这个用户进行授权。

      -

      检查一个用户是否拥有特定权限需要使用它的isAuhorised方法。

      -

      上边所有操作的结果都是通过处理器Handler异步调用提供的。

      -

      这里是一个对用户授权的例子：

      -
      user.isAuthorised("printers:printer1234", res -> {
-    if (res.succeeded()) {
-
-        boolean hasAuthority = res.result();
-
-        if (hasAuthority) {
-            System.out.println("User has the authority");
-        } else {
-            System.out.println("User does not have the authority");
-        }
-    } else {
-        res.cause().printStackTrace();
-    }
-});
-

      另外一个例子对基于角色模型的用户进行授权就是使用role:前缀，请注意，就像上边讨论的一样，权限字符串如何被解释完全取决于底层实现，这里Vert.X不对解释细节提供假设。

      -

      权限缓存

      -

      用户对象可以缓存任何权限，之后的调用会检查是否拥有同样的权限执行其操作，这个结果实际上调用了底层提供者Provider的方法。

      -

      为了清空内部缓存，则你可以使用clearCache方法。

      -

      用户凭证

      -

      对于已经认证过的用户，你可以调用principal方法获取用户的凭证信息，获取凭证信息的内容同样取决于底层实现。

      -

      创建自己的认证实现

      -

      如果你希望创建自己的认证提供者Auth Provider则需要创建一个类实现AuthProvider接口。

      -

      Vert.X提供了用户对象的抽象实现AbstractUser，你可以创建这个类的子类对自己的用户User对象提供自定义实现。这个抽象实现中包含了缓存逻辑，所以你在实现的时候不需要考虑自己处理缓存问题。

      -

      如果你希望在集群环境中使用你的User对象，则需要保证这个用户对象实现了ClusterSerializable接口。

      - - -
      - -
      -
      -
      - -

      results matching ""

      -
        - -
        -
        - -

        No results matching ""

        - -
        -
        -
        - -
        -
        - -
        - - - - - - - - - - - - - - -
        - - -
        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/auth/JDBCAuth.html b/docs/auth/JDBCAuth.html deleted file mode 100644 index ea3b75e..0000000 --- a/docs/auth/JDBCAuth.html +++ /dev/null @@ -1,1133 +0,0 @@ - - - - - - - JDBC Auth · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        -
        - - - - - - - - -
        - -
        - -
        - - - - - - - - -
        -
        - -
        -
        - -
        - -

        Vert.x JDBC Auth

        - -

        基本术语

        -
          -
        • Authentication：认证
          • -
        • Authorisation：授权
          • -
        • Authority：权限
          • -
        • Permission：许可
          • -
        • Role：角色
          • -
        • User：用户
          • -
        • Token：令牌
          • -
        • Principal：凭证
          • -
        • Handler：处理器
          • -
        -

        Vert.X中提供了一个使用JDBCClient的AuthProvider实现，它针对任何兼容JDBC的关系数据库执行认证和授权。若要在自己的项目中使用它，则需要在构建描述信息的dependencies节点中添加如下信息：

        -
          -

        • Maven（在pom.xml文件中）

          -
            <dependency>
-      <groupId>io.vertx</groupId>
-      <artifactId>vertx-auth-jdbc</artifactId>
-      <version>3.2.1</version>
-  </dependency>
-
          • -

        • Gradle（在build.gradle文件中）

          -
            compile io.vertx:vertx-auth-jdbc:3.2.1
-
          • -
        -

        如果要创建一个客户端实例，你首先需要一个JDBCClient的实例，要知道如何创建这个实例可按照文档中的内容实施。

        -

        一旦你创建了一个JDBCClient实例后，就可以按下边代码创建JDBCAuth实例：

        -
        JDBCClient jdbcClient = JDBCClient.createShared(vertx, jdbcClientConfig);
-
-JDBCAuth authProvider = JDBCAuth.create(jdbcClient);
-

        创建好上边的实例过后你就可以如使用任何AuthProvider执行认证和授权功能了。

        -

        Vert.X的默认标准配置（Out Of the Box）中包含了某些针对认证和授权的信息查询，如果你想要使用不同的数据库模式（Schema），这些查询内容可以通过下边几个方法进行更改：

        - -

        Vert.X默认实现中的密码在数据库中使用了SHA-512算法加密后进行存储，之后会连接对应的salt值，这个salt值和密码存储在同一个表里。

        -

        如果你想要重写这些行为，则可以重写setHashStrategy方法去修改Hash策略的设置。

        -

        ！WARNING

        -

        强烈建议在存储密码时使用哈希算法加密过后保存在数据库中，这个哈希值是在创建这一行记录时基于salt值计算的，应用中应该使用强壮的密码算法，在存储密码时绝对不要使用明文。

        -

        认证

        -

        如果要使用默认的认证实现，认证信息中用了username和password字段进行表述：

        -
        JsonObject authInfo = new JsonObject().put("username", "tim").put("password", "sausages");
-
-authProvider.authenticate(authInfo, res -> {
-    if (res.succeeded()) {
-        User user = res.result();
-    } else {
-        // Failed!
-    }
-});
-

        授权 - Permission/Role模型

        -

        尽管Vert.X Auth自身并不要求使用特定的许可模型（它本身只是使用了不透明的字符串），但默认的实现使用了比较熟悉的：用户/角色/许可模型，这样在应用里你可以使用一个或者多个角色，而一个角色也可以拥有一个或者多个许可。

        -

        如果要验证一个用户是否拥有特定的许可，则需要将许可信息传递到isAuthorised中：

        -
        user.isAuthorised("commit_code", res -> {
-    if (res.succeeded()) {
-        boolean hasPermission = res.result();
-    } else {
-        // Failed to
-    }
-});
-

        如果要验证一个用户是否属于特定角色，则可以使用前缀法给角色带上前缀表示：

        -
        user.isAuthorised("role:manager", res -> {
-    if (res.succeeded()) {
-        boolean hasRole = res.result();
-    } else {
-        // Failed to
-    }
-});
-

        Vert.X中的默认角色前缀使用了role:，这个值可通过setRolePrefix进行更改。

        - - -
        - -
        -
        -
        - -

        results matching ""

        -
          - -
          -
          - -

          No results matching ""

          - -
          -
          -
          - -
          -
          - -
          - - - - - - - - - - - - - - -
          - - -
          - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/auth/JWTAuth.html b/docs/auth/JWTAuth.html deleted file mode 100644 index 517860e..0000000 --- a/docs/auth/JWTAuth.html +++ /dev/null @@ -1,1148 +0,0 @@ - - - - - - - JWT Auth · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
          -
          - - - - - - - - -
          - -
          - -
          - - - - - - - - -
          -
          - -
          -
          - -
          - -

          JWT auth

          - -

          基本术语

          -
            -
          • Authentication ：认证
            • -
          • Authorisation：授权
            • -
          • Authenticity：真实性
            • -
          • Permission： 许可
            • -
          • Token： 令牌
            • -
          • Provider：提供者
            • -
          -

          使用JSON web tokens实现Auth。

          -

          The JWT auth Provider

          -

          这个组件包含了一个开箱即用的JWT实现。

          -

          要使用这个项目，将下面的依赖添加到构建描述符里的dependencies部分。

          -
            -

          • Maven（在你的pom.xml文件里）

            -
              <dependency>
-      <groupId>io.vertx</groupId>
-      <artifactId>vertx-auth-jwt</artifactId>
-      <version>3.2.1</version>
-  </dependency>
-
            • -

          • Gradle(在你的build.gradle文件里)

            -
              compile 'io.vertx:vertx-auth-jwt:3.2.1'
-
            • -
          -

          JSON Web 令牌是一种简单的方法来发送明文信息（通常是URL），其内容可以被验证为是可信的。像下面的这些场景JWT是非常适用的：

          -
            -
          • 在一个单一的报名场景中，你想要有一个隔离的认证服务用可被信任的方式发送用户信息
            • -
          • 无状态的Server API，非常适用于简单的页面应用
            • -
          • 等等
            • -
          -

          在决定使用JWT之前，需要重点注意的是JWT并不加密payload，它仅对payload签名。你不应该使用JWT发送任何私密信息，相反你应该发送是不是私密的但要被验证的信息。举个例子，使用JWT发送一个签名过的用户id来表明这个用户已经登录了的做法非常对的。相反发送一个用户的密码的做法是非常非常错误的。

          -

          JWT主要的优点有：

          -
            -
          • 它可以让你验证令牌的真实性
            • -
          • 它有一个JSON结构，可以包含任何你想要的变量和大量的数据
            • -
          • 它完全是无状态的
            • -
          -

          你可以使用JWTAuth来创建一个提供者的实例，并指定一个JSON对象的配置。这是创建一个JWT auth提供者的示例代码：

          -
          JsonObject config = new JsonObject().put("keyStore", new JsonObject()
-    .put("path", keystore.jceks)
-    .put("type", "jceks")
-    .put("password", "secret"));
-
-AuthProvider provider = JWTAuth.create(vertx, config);
-

          JWT用法的典型流程是，在您的应用程序有一个终点颁发令牌，这个终点应在SSL模式下运行，终点这通过用户名和密码验证完请求用户之后，表示你将这样做生成令牌：

          -
          JsonObjetc config = new JsonObject().put("keyStore", new JsonObject()
-    .put("path", "keystore.jceks")
-    .put("type", "jceks")
-    .put("password", "secret"));
-
-JWTAuth provider = JWTAuth.create(vertx, config);
-
-// 在验证的终点上，一旦你通过它的用户名/密码验证了用户的id
-if ("paulo".equal(username) && "super_secret".equals(password)) {
-    String token = provider.generateToken(new JsonObject().put("sub", "paulo"), new JWTOptions());
-    // 这时任何请求受保护的资源你应该传入这个字符串到http头授权部分，像这样：
-    // 授权：Bearer <token>
-}
-

          TODO展示了使用JWT的验证和授权的例子并解释了如何通过传入到授权的许可字符映射到JW令牌中的声明。

          -

          THE JWT keystore file

          -

          auth提供者需要在类路径或文件系统上加载一个keystore文件，keystore文件要么有一个mac要么有一个Signature用于签名和验证生成的令牌，。

          -

          默认的情况下，实践将会查找这些别名，然而并不是所有的算法都需要存在。作为一个好的实践HS256应该存在：

          -
          `HS256`:: HMAC using SHA-256 hash algorithm
-`HS384`:: HMAC using SHA-384 hash algorithm
-`HS512`:: HMAC using SHA-512 hash algorithm
-`RS256`:: RSASSA using SHA-256 hash algorithm
-`RS384`:: RSASSA using SHA-384 hash algorithm
-`RS512`:: RSASSA using SHA-512 hash algorithm
-`ES256`:: ECDSA using P-256 curve and SHA-256 hash algorithm
-`ES384`:: ECDSA using P-384 curve and SHA-384 hash algorithm
-`ES512`:: ECDSA using P-521 curve and SHA-512 hash algorithm
-

          当keystore没有被提供，执行将会回滚到一个不安全的模式同时签名并不会被验证，如果payload被外部的方法签名或加密后的情况下这是非常有用的。

          -

          生成一个新的Keystore文件

          -

          生成keystore文件唯一需要的工具是keytool，运行的时候，你可以指定你需要使用的算法：

          -
          keytool -genseckey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg HMacSHA256 -keysize 2048 -alias HS256 -keypass secret
-keytool -genseckey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg HMacSHA384 -keysize 2048 -alias HS384 -keypass secret
-keytool -genseckey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg HMacSHA512 -keysize 2048 -alias HS512 -keypass secret
-keytool -genkey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg RSA -keysize 2048 -alias RS256 -keypass secret -sigalg SHA256withRSA -dname "CN=,OU=,O=,L=,ST=,C=" -validity 360
-keytool -genkey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg RSA -keysize 2048 -alias RS384 -keypass secret -sigalg SHA384withRSA -dname "CN=,OU=,O=,L=,ST=,C=" -validity 360
-keytool -genkey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg RSA -keysize 2048 -alias RS512 -keypass secret -sigalg SHA512withRSA -dname "CN=,OU=,O=,L=,ST=,C=" -validity 360
-keytool -genkeypair -keystore keystore.jceks -storetype jceks -storepass secret -keyalg EC -keysize 256 -alias ES256 -keypass secret -sigalg SHA256withECDSA -dname "CN=,OU=,O=,L=,ST=,C=" -validity 360
-keytool -genkeypair -keystore keystore.jceks -storetype jceks -storepass secret -keyalg EC -keysize 256 -alias ES384 -keypass secret -sigalg SHA384withECDSA -dname "CN=,OU=,O=,L=,ST=,C=" -validity 360
-keytool -genkeypair -keystore keystore.jceks -storetype jceks -storepass secret -keyalg EC -keysize 256 -alias ES512 -keypass secret -sigalg SHA512withECDSA -dname "CN=,OU=,O=,L=,ST=,C=" -validity 360
-

          Julien VietTim FoxPaulo Lopes

          -
          translated by weiyiysw
          - - -
          - -
          -
          -
          - -

          results matching ""

          -
            - -
            -
            - -

            No results matching ""

            - -
            -
            -
            - -
            -
            - -
            - - - - - - - - - - - - - - -
            - - -
            - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/auth/MongoDBAuth.html b/docs/auth/MongoDBAuth.html deleted file mode 100644 index 2ce37d4..0000000 --- a/docs/auth/MongoDBAuth.html +++ /dev/null @@ -1,1152 +0,0 @@ - - - - - - - MongoDB Auth · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
            -
            - - - - - - - - -
            - -
            - -
            - - - - - - - - -
            -
            - -
            -
            - -
            - -

            Vert.x MongoDB Auth

            - -

            基本术语

            -
              -
            • Authentication：认证
              • -
            • Authorisation：授权
              • -
            • Authority：权限
              • -
            • Permission：许可
              • -
            • Role：角色
              • -
            • User：用户
              • -
            • Token：令牌
              • -
            • Principal：凭证
              • -
            • Handler：处理器
              • -
            • Collection：集合，MongoDB专用（概念稍同Database的Table）
              • -
            • Document：文档，MongoDB专用（概念稍同Database中Row）
              • -
            -

            Vert.X中提供了一个AuthProvider的实现，它可以让你使用MongoClient针对MongoDb数据库执行认证和授权。若要在自己的项目中使用它，则需要在构建描述信息的dependencies节点中添加如下信息：

            -
              -

            • Maven（在pom.xml文件中）

              -
                <dependency>
-      <groupId>io.vertx</groupId>
-      <artifactId>vertx-auth-mongo</artifactId>
-      <version>3.2.1</version>
-  </dependency>
-
              • -

            • Gradle（在build.gradle文件中）

              -
                compile io.vertx:vertx-auth-mongo:3.2.1
-
              • -
            -

            如果要创建一个客户端实例，你首先需要一个MongoClient的实例，要知道如何创建这个实例可按照文档中的内容实施。

            -

            一旦你创建了一个MongoClient实例后，就可以按照下边的代码创建MongoAuth实例：

            -
            MongoClient client = MongoClient.createShared(vertx, mongoClientConfig);
-JsonObject authProperties = new JsonObject();
-MongoAuth authProvider = MongoAuth.create(client, authProperties);
-

            创建好上边的实例过后，你就可以使用任何AuthProvider针对MongoDB执行认证和授权功能了。

            -

            Vert.X的默认标准配置（Out Of the Box）中包含了"user"集合（Collection），用户名字段使用"username"进行存储和读取。

            -

            为了避免在"user"集合中出现重复的用户名，应该在"user"集合中给"username"添加唯一索引（Unique Index），你可以在MongoDB服务器中运行下边的片段来完成此操作：

            -
            db.user.createIndex( { username: 1 }, { unique: true } )
-

            MongoDB的特性是先查询username字段中的值是否已经存在，然后会插入一个Document，并不能作为一个原子性操作，基于这个原因你需要添加上边的唯一索引，使用了这个索引过后你的代码会尝试先插入一行数据，如果出现了重复记录则会失败。

            -

            根据你自己的需要，你同样可以使用下边的方法改变MongoDB中使用的默认集合（Collection）和列（Column）名称等信息：

            - -

            Vert.X默认实现中的密码在数据库中使用了SHA-512算法加密后进行存储，之后会连接对应的salt值，这个salt值和密码存储在同一个表里。你可以调用setSaltField方法来改变存储salt值的字段名称，它的默认值是"salt"，你同样可以使用setSaltStyle来改变一些行为。通过调用getHashStrategy方法还可以读取Hash策略设置。

            -

            MongoDB中可以设置下边几种SALT的值（参考下边WARNING）：

            -
              -
            • NO_SALT：密码就不会执行加密以明文的方式存储。
              • -
            • COLUMN：Vert.X会为每个用户创建一个"salt“值，并且存储在用户表定义的列中；
              • -
            • EXTERNAL：Vert.X仅仅将密码最终加密结果存储在数据库中，"salt“值可以在外部使用，并且可以调用setExternalSalt方法进行设置。
              • -
            -

            如果你想要重写上述行为，则你可以调用setHashStrategy方法设置新的Hash策略，并且提供变更过的Hash策略及配置信息。

            -

            ！WARNING

            -

            强烈建议在设置“salt"值时候使用EXTERNAL选项。NO_SALT选项仅仅推荐在开发阶段中使用，不仅仅如此，COLUMN方式也不推荐，因为它会导致salt和密码都存储在了同一个地方！

            -

            认证

            -

            如果认证使用了默认的MongoDB实现，认证信息中用了username和password字段：

            -
            JsonObject authInfo = new JsonObject()
-    .put("username", "tim")
-    .put("password", "sausages");
-authProvider.authenticate(authInfo, res -> {
-    if (res.succeeded()) {
-        User user = res.result();
-    } else {
-        // Failed!
-    }
-});
-

            如果想要替换上边的username和password两个默认字段名，你可以使用下边两个方法：

            - -

            授权 - Permission/Role模型

            -

            尽管Vert.X自身并不要求使用特定的许可模型（它本身只是使用了不透明的字符串），但MongoDB认证中的实现使用了比较熟悉的：用户/角色/许可模型，这样在应用里你可以使用一个或者多个角色，而一个角色也可以拥有一个或者多个许可。

            -

            如果要验证一个用户是否拥有特定的许可，则要将许可信息传递到isAuthorised中：

            -
            user.isAuthorised("commit_code", res -> {
-    if (res.succeeded()) {
-        boolean hasPermission = res.result();
-    } else {
-        // Failed to
-    }
-});
-

            如果要验证一个用户是否属于特定角色，则可以使用MongoDB认证前缀（MongoAuth.ROLE_PREFIX）法给角色带上前缀表示：

            -
            user.isAuthorised(MongoAuth.ROLE_PREFIX + "manager", res -> {
-    if (res.succeeded()) {
-        boolean hasRole = res.result();
-    } else {
-        // Failed to
-    }
-});
-
            - -
            - -
            -
            -
            - -

            results matching ""

            -
              - -
              -
              - -

              No results matching ""

              - -
              -
              -
              - -
              -
              - -
              - - - - - - - - - - - - - - -
              - - -
              - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/auth/Oauth2.html b/docs/auth/Oauth2.html deleted file mode 100644 index c3d9007..0000000 --- a/docs/auth/Oauth2.html +++ /dev/null @@ -1,1306 +0,0 @@ - - - - - - - OAuth 2 · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
              -
              - - - - - - - - -
              - -
              - -
              - - - - - - - - -
              -
              - -
              -
              - -
              - -

              Vert.x OAuth 2

              - -

              基本术语

              -
                -
              • Authentication：认证
                • -
              • Authorisation：授权
                • -
              • Authority：权限
                • -
              • Permission：许可
                • -
              • Role：角色
                • -
              • User：用户
                • -
              • Token：令牌
                • -
              • Principal：凭证
                • -
              • Handler：处理器
                • -
              • Credential：证书
                • -
              • Token：令牌
                • -
              -

              Vert.X的这个组件包含了标准的OAuth2的实现。若要在自己的项目中使用它，则需要在构建描述信息的dependencies节点中添加如下信息：

              -
                -

              • Maven（在pom.xml文件中）

                -
                  <dependency>
-      <groupId>io.vertx</groupId>
-      <artifactId>vertx-auth-oauth2</artifactId>
-      <version>3.2.1</version>
-  </dependency>
-
                • -

              • Gradle（在build.gradle文件中）

                -
                  compile io.vertx:vertx-auth-oauth2:3.2.1
-
                • -
              -

              如果用户以第三方应用的方式访问想要的资源，OAuth2可以对这些用户进行授权，任何时候可以根据用户想要都有可能启用或禁用它的访问权限。

              -

              Vert.X中的OAuth2支持下边三种流程：

              -
                -
              • Authorization Code：授权码流程（对服务器和App可持久化存储信息）
                • -
              • Password Credentials：密码证书流程（之前的流程无法使用或开发阶段使用）
                • -
              • Client Credentials：客户端证书流程（客户端可仅仅可凭借客户端整数申请访问令牌【Access Token】）
                • -
              -

              授权码——Authorization Code Flow

              -

              授权码授权类型可以用来获取访问令牌（Access Token）和刷新令牌（Refresh Token），对安全性要求高的客户端（Confidential Client）是很不错的（Optimized）一种方式。作为一个基于重定向的流程，客户端必须能和资源拥有者的用户代理交互（通常是浏览器），同时要能接受从授权服务器（Authorization Server）通过重定向发送过来的请求。

              -

              更多：OAuth2 Section 4.1

              -

              密码证书——Password Credentials Flow

              -

              资源拥有者密码证书授权类型比较适合于这样一种情况：当资源拥有者和客户端之间有可信任的关系时使用，如设备操作系统、或高特权应用。授权服务器应该在很特殊的情况时启用这种授权类型，并且仅仅当其他应用都不可见时允许使用这种类型。

              -

              这种类型对于客户端要获取资源拥有者证书（用户名和密码，通常使用交互式表单）是合适的。它用于从已经存在的直接使用认证模式的如Basic或Digest的客户端向OAuth2认证方式迁移的时候，它会将证书直接转换成OAuth2中的访问令牌。

              -

              更多：OAuth2 Section 4.3

              -

              客户端证书——Client Credentials Flow

              -

              当客户端想要申请访问控制之下受保护的资源时，或者其他资源拥有者先前被授权服务器托管时（这种方式超出了本文范畴），客户端仅仅可以使用客户端证书（或者其他表示认证含义的信息）申请访问令牌。

              -

              客户端证书类型必须用于且仅用于机密客户端。

              -

              更多：OAuth2 Section 4.4

              -

              初探

              -

              下边是基于GitHub中使用Vert.X的OAuth2 Provider的认证示例实现代码：

              -
              OAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.AUTH_CODE, new JsonObject()
-    .put("clientID", "YOUR_CLIENT_ID")
-    .put("clientSecret", "YOUR_CLIENT_SECRET")
-    .put("site", "https://github.com/login")
-    .put("tokenPath", "/oauth/access_token")
-    .put("authorizationPath", "/oauth/authorize")
-);
-
-// when there is a need to access a protected resource or call a protected method,
-// call the authZ url for a challenge
-
-String authorization_uri = oauth2.authorizeURL(new JsonObject()
-    .put("redirect_uri", "http://localhost:8080/callback")
-    .put("scope", "notifications")
-    .put("state", "3(#0/!~"));
-
-// when working with web application use the above string as a redirect url
-
-// in this case GitHub will call you back in the callback uri one should now complete the handshake as:
-
-
-String code = "xxxxxxxxxxxxxxxxxxxxxxxx"; // the code is provided as a url parameter by github callback call
-
-oauth2.getToken(new JsonObject().put("code", code).put("redirect_uri", "http://localhost:8080/callback"), res -> {
-    if (res.failed()) {
-        // error, the code provided is not valid
-    } else {
-        // save the token and continue...
-    }
-});
-

              授权码流程

              -

              授权码流程主要包含两部分内容：

              -
                -
              1. 第一步，你的应用客户端向用户申请允许访问它们的数据，如果用户审批后，OAuth2服务器发送给客户端一个授权码；
                2. -
              2. 第二步，客户端将这个授权码和客户端密钥放到POST请求中发送给授权服务器（Authority Server）得到访问令牌；
                3. -
              -

              示例代码：

              -
              JsonObject credentials = new JsonObject()
-    .put("clientID", "<client-id>")
-    .put("clientSecret", "<client-secret>")
-    .put("site", "https://api.oauth.com");
-
-// Initialize the OAuth2 Library
-OAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.AUTH_CODE, credentials);
-
-// Authorization oauth2 URI
-String authorization_uri = oauth2.authorizeURL(new JsonObject()
-    .put("redirect_uri", "http://localhost:8080/callback")
-    .put("scope", "<scope>")
-    .put("state", "<state>"));
-
-// Redirect example using Vert.x
-response.putHeader("Location", authorization_uri)
-    .setStatusCode(302)
-    .end();
-
-JsonObject tokenConfig = new JsonObject()
-    .put("code", "<code>")
-    .put("redirect_uri", "http://localhost:3000/callback");
-
-// Callbacks
-// Save the access token
-oauth2.getToken(tokenConfig, res -> {
-    if (res.failed()) {
-        System.err.println("Access Token Error: " + res.cause().getMessage());
-    } else {
-        // Get the access token object (the authorization code is given from the previous step).
-        AccessToken token = res.result();
-    }
-});
-

              密码证书流程

              -

              资源拥有者密码证书授权类型比较适合于这样一种情况：当资源拥有者和客户端之间有可信任的关系时使用，如设备操作系统、或高特权应用。授权服务器应该在很特殊的情况时启用这种授权类型，并且仅仅当其他应用都不可见时允许使用这种类型。

              -
              OAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.PASSWORD);
-
-JsonObject tokenConfig = new JsonObject()
-    .put("username", "username")
-    .put("password", "password");
-
-// Callbacks
-// Save the access token
-oauth2.getToken(tokenConfig, res -> {
-    if (res.failed()) {
-        System.err.println("Access Token Error: " + res.cause().getMessage());
-    } else {
-        // Get the access token object (the authorization code is given from the previous step).
-        AccessToken token = res.result();
-
-        oauth2.api(HttpMethod.GET, "/users", new JsonObject().put("access_token", token.principal().getString("access_token")), res2 -> {
-            // the user object should be returned here...
-        });
-    }
-});
-

              客户端证书流程

              -

              这种类型对于客户端要获取资源拥有者证书是合适的。

              -
              JsonObject credentials = new JsonObject()
-    .put("clientID", "<client-id>")
-    .put("clientSecret", "<client-secret>")
-    .put("site", "https://api.oauth.com");
-
-// Initialize the OAuth2 Library
-OAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.CLIENT, credentials);
-
-JsonObject tokenConfig = new JsonObject();
-
-// Callbacks
-// Save the access token
-oauth2.getToken(tokenConfig, res -> {
-    if (res.failed()) {
-        System.err.println("Access Token Error: " + res.cause().getMessage());
-    } else {
-        // Get the access token object (the authorization code is given from the previous step).
-        AccessToken token = res.result();
-    }
-});
-

              访问令牌对象

              -

              当一个令牌过期后你需要刷新令牌，OAuth2提供了访问令牌类AccessToken，它包含了很多实用的方法可以在令牌过期过后对令牌进行刷新。

              -
              if (token.expired()) {
-    // Callbacks
-    token.refresh(res -> {
-        if (res.succeeded()) {
-            // success
-        } else {
-            // error handling...
-        }
-    });
-}
-

              当你使用令牌访问完成过后想要注销，你可以撤销（Revoke）访问令牌和刷新令牌。

              -
              token.revoke("access_token", res -> {
-    // Session ended. But the refresh_token is still valid.
-
-    // Revoke the refresh_token
-    token.revoke("refresh_token", res1 -> {
-        System.out.println("token revoked.");
-    });
-});
-

              其他通用OAuth2的Provider配置示例

              -

              Google

              -
              JsonObject credentials = new JsonObject()
-    .put("clientID", "CLIENT_ID")
-    .put("clientSecret", "CLIENT_SECRET")
-    .put("site", "https://accounts.google.com")
-    .put("tokenPath", "https://www.googleapis.com/oauth2/v3/token")
-    .put("authorizationPath", "/o/oauth2/auth");
-
-// Initialize the OAuth2 Library
-OAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.CLIENT, credentials);
-

              GitHub

              -
              JsonObject credentials = new JsonObject()
-    .put("clientID", "CLIENT_ID")
-    .put("clientSecret", "CLIENT_SECRET")
-    .put("site", "https://github.com/login")
-    .put("tokenPath", "/oauth/access_token")
-    .put("authorizationPath", "/oauth/authorize");
-
-// Initialize the OAuth2 Library
-OAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.CLIENT, credentials);
-

              Linkedin

              -
              JsonObject credentials = new JsonObject()
-    .put("clientID", "CLIENT_ID")
-    .put("clientSecret", "CLIENT_SECRET")
-    .put("site", "https://www.linkedin.com")
-    .put("authorizationPath", "/uas/oauth2/authorization")
-    .put("tokenPath", "/uas/oauth2/accessToken");
-
-// Initialize the OAuth2 Library
-OAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.CLIENT, credentials);
-

              Twitter

              -
              JsonObject credentials = new JsonObject()
-    .put("clientID", "CLIENT_ID")
-    .put("clientSecret", "CLIENT_SECRET")
-    .put("site", "https://api.twitter.com")
-    .put("authorizationPath", "/oauth/authorize")
-    .put("tokenPath", "/oauth/access_token");
-
-// Initialize the OAuth2 Library
-OAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.CLIENT, credentials);
-

              Facebook

              -
              JsonObject credentials = new JsonObject()
-    .put("clientID", "CLIENT_ID")
-    .put("clientSecret", "CLIENT_SECRET")
-    .put("site", "https://www.facebook.com")
-    .put("authorizationPath", "/dialog/oauth")
-    .put("tokenPath", "https://graph.facebook.com/oauth/access_token");
-
-
-// Initialize the OAuth2 Library
-OAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.CLIENT, credentials);
-

              JBoss Keycloak

              -
              JsonObject credentials = new JsonObject()
-    .put("clientID", "CLIENT_ID")
-    .put("clientSecret", "CLIENT_SECRET")
-    .put("site", "https://www.your-keycloak-server.com")
-    .put("authorizationPath", "/realms/" + realm + "/protocol/openid-connect/auth")
-    .put("tokenPath", "/realms/" + realm + "/protocol/openid-connect/token");
-
-// Initialize the OAuth2 Library
-OAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.CLIENT, credentials);
-
              - -
              - -
              -
              -
              - -

              results matching ""

              -
                - -
                -
                - -

                No results matching ""

                - -
                -
                -
                - -
                -
                - -
                - - - - - - - - - - - - - - -
                - - -
                - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/auth/ShiroAuth.html b/docs/auth/ShiroAuth.html deleted file mode 100644 index 8aec6ec..0000000 --- a/docs/auth/ShiroAuth.html +++ /dev/null @@ -1,1153 +0,0 @@ - - - - - - - Shiro Auth · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                -
                - - - - - - - - -
                - -
                - -
                - - - - - - - - -
                -
                - -
                -
                - -
                - -

                Vert.x Shiro Auth

                -

                Apache Shiro Auth提供者实现

                -

                基本术语

                -
                  -
                • provider：提供者
                  • -
                • authentication：验证
                  • -
                • permissions：权限
                  • -
                -

                这是一个使用Apache Shiro的auth提供者的实现。

                -

                要使用这个项目，将下面的依赖添加到构建描述符里的dependencies部分。

                -
                  -

                • Maven（在pom.xml文件里）

                  -
                    <dependency>
-      <groupId>io.vertx</groupId>
-      <artifactId>vertx-auth-shiro</artifactId>
-      <version>3.2.1</version>
-  </dependency>
-
                  • -

                • Gradle(在build.gradle文件里)

                  -
                    compile 'io.vertx:vertx-auth-shiro:3.2.1'
-
                  • -
                -

                我们使用Shiro提供基于身份认证属性和LDAP开箱即用的支持，你也可以使用插件，在任何其他的期望用户名和密码作为凭据的Shiro Realm里。

                -

                使用ShiroAuth创建提供者的实例。使用ShiroAuthRealmType指定Shiro auth提供者的类型，并且也可以指定一个JSON对象的配置。

                -

                这是通过指定类型创建Shiro auth提供者的示例：

                -
                JsonObject config = new JsonObject().put("properties_path", "classpath:test-auth.properties");
-AuthProvider provider = ShiroAuth.create(vertx, ShiroAuthRealmType.PROPERTIES, config);
-

                验证

                -

                当使用这种实现作为认证时，它需要在认证信息里获取username和password：

                -
                JsonObject authInfo = new JsonObject().put("username", "tim").put("password", "sausages");
-authProvider.authenticate(authInfo, res -> {
-    if (res.succeeded()) {
-        User user = res.result();
-    } else {
-        // Failed!
-    }
-});
-

                授权-权限-角色模型

                -

                尽管Vert.x auth本身并没有授权任何特定的许可（它们仅是不透明的字符串）模型，这个的实现和 用户/角色/权限 模型类似，一个用户可以有0到多个角色，一个角色可以有0到多个权限。

                -

                要验证一个用户是否有一个特定的权限，只需要简单的将权限传入到isAuthorised像接下来这样做：

                -
                user.isAuthorised("newsletter:edit:13", res -> {
-    if (res.succeeded()) {
-        boolean hasPermission = res.result();
-    } else {
-        // Failed to
-    }
-});
-

                要验证一个用户是否有一个特定的角色，你需要在参数前面加上角色前缀。

                -
                user.isAuthorised("role:manager", res -> {
-    if (res.succeeded()) {
-        boolean hasRole = res.result();
-    } else {
-        // Failed to
-    }
-});
-

                默认的角色前缀是role:。你可以设置setRolePrefix改变默认的。

                -

                The Shiro properties auth provider

                -

                这个auth提供者的实现是使用Apache Shiro从一个配置文件里获取 用户/角色/权限 信息。

                -

                注意，角色在API里并不是直接可用的，因为这个事实，vertx-auth尽可能的尝试轻便。然而，可以通过使用前缀role:或者通过setRolePrefix指定你想要的前缀在一个角色上执行断言。

                -

                默认的情况下，这个实现将会在类路径里查找一个名为vertx-users.properties的文件。如果你想要改变这个，你可以使用properties_path配置元素来定义属性文件的路径，默认的值是classpath:vertx-users.properties。

                -

                如果这个值得前缀是classpath:，将会在类路径查找那个名字的属性文件。如果这个值的前缀是file:，将在文件系统上指定一个具体的文件。如果这个值得前缀是url:，将会指定一个具体的URL来加载这个属性文件。

                -

                这个属性文件应该遵从下面的结构：

                -

                每一行应该要么包含一个用户的用户名、密码和角色，要么包含角色的权限。

                -

                一个用户的行应该是这样的结构： -user.{username}={password},{roleName1},{roleName2},...,{roleNameN}

                -

                一个角色行应该是这样的结构： -role.{roleName}={permissionName1},{permissionName2},...,{permissionNameN}

                -

                这是示例：

                -
                user.tim = mypassword,administrator,developer
-user.bob = hispassword,developer
-user.joe = anotherpassword,manager
-role.administrator = *
-role.manager = play_golf,say_buzzwords
-role.developer = do_actual_work
-

                当描述一个角色使用通配符*时，说明这个角色拥有所有的权限。

                -

                The Shiro LDAP auth Provider

                -

                LDAP auth realm从一个LDAP服务器上获取 用户/角色/权限 信息。

                -

                接下来的这些配置属性是用来配置一个LDAP realm：

                -
                  -
                • ldap-user-dn-template：这是用来决定实际的查找使用当通过一个特定的id来查找一个用户的时候。一个例子是uid={0},ou=users,dc=foo,dc=com-这个元素{0}是创建实际的查找时替换成用户的id。这个设置是强制的。
                  • -
                • ldap_url：这个url是设置LDAP服务器。这个url必须以ldap://开头，端口也必须要指定。这是一个示例ldap://myldapserver.mycompany.com:10389
                  • -
                • ldap-authentication-mechanism：TODO
                  • -
                • ldap-context-factory-class-name：TODO
                  • -
                • ldap-pooling-enabled：TODO
                  • -
                • ldap-referral：TODO
                  • -
                • ldap-system-username：TODO
                  • -
                • ldap-system-password：TODO
                  • -
                -

                使用另一个Shiro Realm

                -

                使用一个预先创建的Apache Shiro Realm对象创建一个auth提供者的示例是可以的。

                -

                像下面这样做的：

                -
                AuthProvider provider = ShiroAuth.create(vertx, realm);
-

                这个实现当前假定了在基本的验证中使用了用户名和密码。

                -

                Julien VietTim Fox

                -
                translated by weiyiysw
                - - -
                - -
                -
                -
                - -

                results matching ""

                -
                  - -
                  -
                  - -

                  No results matching ""

                  - -
                  -
                  -
                  - -
                  -
                  - -
                  - - - - - - - - - - - - - - -
                  - - -
                  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/cloud/Cloud.html b/docs/cloud/Cloud.html deleted file mode 100644 index 4c4c20a..0000000 --- a/docs/cloud/Cloud.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - Cloud · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                  -
                  - - - - - - - - -
                  - -
                  - -
                  - - - - - - - - -
                  -
                  - -
                  -
                  - -
                  - -

                  Vert.x Cloud

                  - - -
                  - -
                  -
                  -
                  - -

                  results matching ""

                  -
                    - -
                    -
                    - -

                    No results matching ""

                    - -
                    -
                    -
                    - -
                    -
                    - -
                    - - - - - - - - - - - - - - -
                    - - -
                    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/cloud/OpenShift2DIYCartridge.md b/docs/cloud/OpenShift2DIYCartridge.md deleted file mode 100644 index 07e46c5..0000000 --- a/docs/cloud/OpenShift2DIYCartridge.md +++ /dev/null @@ -1 +0,0 @@ -# Vert.x OpenShift 2 - DIY Cartridge diff --git a/docs/cloud/OpenShiftCartridge.html b/docs/cloud/OpenShiftCartridge.html deleted file mode 100644 index 2ddbf2f..0000000 --- a/docs/cloud/OpenShiftCartridge.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - OpenShift Cartridge · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                    -
                    - - - - - - - - -
                    - -
                    - -
                    - - - - - - - - -
                    -
                    - -
                    -
                    - -
                    - -

                    Vert.x OpenShift Cartridge

                    - - -
                    - -
                    -
                    -
                    - -

                    results matching ""

                    -
                      - -
                      -
                      - -

                      No results matching ""

                      - -
                      -
                      -
                      - -
                      -
                      - -
                      - - - - - - - - - - - - - - -
                      - - -
                      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/cloud/OpenShiftUsingDIYCartridge.html b/docs/cloud/OpenShiftUsingDIYCartridge.html deleted file mode 100644 index 4dbdf99..0000000 --- a/docs/cloud/OpenShiftUsingDIYCartridge.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - OpenShift Using DIY Cartridge · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                      -
                      - - - - - - - - -
                      - -
                      - -
                      - - - - - - - - -
                      -
                      - -
                      -
                      - -
                      - -

                      Vert.x OpenShift Using DIY Cartridge

                      - - -
                      - -
                      -
                      -
                      - -

                      results matching ""

                      -
                        - -
                        -
                        - -

                        No results matching ""

                        - -
                        -
                        -
                        - -
                        -
                        - -
                        - - - - - - - - - - - - - - -
                        - - -
                        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/clustering/ApacheIgnite.html b/docs/clustering/ApacheIgnite.html deleted file mode 100644 index 24eae31..0000000 --- a/docs/clustering/ApacheIgnite.html +++ /dev/null @@ -1,1154 +0,0 @@ - - - - - - - Apache Ignite · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                        -
                        - - - - - - - - -
                        - -
                        - -
                        - - - - - - - - -
                        -
                        - -
                        -
                        - -
                        - -

                        Ignite Cluster Manager

                        -
                        -

                        翻译：Ranger Tsao，校对 宋子豪、赵亮

                        -
                        -

                        IgniteClusterManager 是基于 Apache Ignite 实现。由于 Vert.x 集群管理的可插拔性，也可轻易切换至其它的集群管理器。

                        -

                        Vert.x 集群管理器包含以下几个功能：

                        -
                          -
                        1. 发现并管理集群中的节点
                          2. -
                        2. 管理集群端的主题订阅清单（这样就可以轻松得知集群中的那些节点订阅了那些 EventBus 地址）
                          3. -
                        3. 分布式 Map 支持
                          4. -
                        4. 分布式锁
                          5. -
                        5. 分布式计数器
                          6. -
                        -

                        注意事项 -Vert.x 集群器并不处理节点之间的通信，在 Vert.x 中节点中的通信是直接由 TCP 链接处理的。

                        -

                        使用 Ignite cluster manager

                        -

                        Vert.x 能够从 classpath 路径的 jar 自动检测并使用出 ClusterManager 的实现。不过需要确保在 classpath 没有其他的 ClusterManager 实现。

                        -

                        另外 Vert.x 可以通过设置 -Dvertx.clusterManagerFactory=io.vertx.spi.cluster.ignite.IgniteClusterManager 来使用指定的 集群管理器实现。

                        -

                        通过命令行使用

                        -

                        确保 vertx-ignite-3.4.1.jar 在 Vert.x 的安装路径中的 lib 目录下。

                        -

                        通过 Maven 或 Gradle 构建工具使用

                        -
                          -
                        • Maven(pom.xml)
                          • -
                        -
                        <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-ignite</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                        -
                          -
                        • Gradle(gradle.xml)
                          • -
                        -
                        compile 'io.vertx:vertx-ignite:3.4.1'
-
                        -

                        编程形式调用

                        -

                        通过编码的形式，设置集群管理器实现，例子：

                        -
                        ClusterManager clusterManager = new IgniteClusterManager();//创建 Ignite 集群管理器
-
-VertxOptions options = new VertxOptions().setClusterManager(clusterManager);//设置集群管理器实现
-Vertx.clusteredVertx(options, res -> {
-  if (res.succeeded()) {
-    Vertx vertx = res.result();
-  } else {
-    // failed!
-  }
-});
-
                        -

                        配置 Ignite cluster manager

                        -

                        使用配置文件

                        -

                        在 vertx-ignite jar 中内嵌了一个默认配置文件 default-ignite.xml。 -如果需要覆盖此配置文件，需要在 classpath 路径中添加 ignite.xml

                        -

                        default-ignite.xml 与 ignite.xml 必须是一个 Apache Ignite 配置文件，在 Apache Ignite 的官方中文文档中，可以找到具体的配置描述。

                        -

                        编程配置

                        -
                        IgniteConfiguration cfg = new IgniteConfiguration();
-// 配置 Ignite ，此处省略配置代码
-
-ClusterManager clusterManager = new IgniteClusterManager(cfg);
-
-VertxOptions options = new VertxOptions().setClusterManager(clusterManager);
-Vertx.clusteredVertx(options, res -> {
-  if (res.succeeded()) {
-    Vertx vertx = res.result();
-  } else {
-    // failed!
-  }
-});
-
                        -

                        自动发现及网络传输配置

                        -

                        在默认配置中使用 TcpDiscoveryMulticastIpFinder 实现，这网络发现实现，需要开启组播。如果组播被禁用，可以采用 TcpDiscoveryVmIpFinder 替代，前提是在 ignite.xml 事先配置好 IP 地址列表。具体 Ignite 集群配置，可以参考文档 Apache Ignite。

                        -

                        故障排除

                        -

                        组播未正常开启

                        -

                        MacOS 默认禁用组播。Google一下启用组播。

                        -

                        使用错误的网络接口

                        -

                        如果机器上有多个网络接口（也有可能是在运行 VPN 的情况下），那么 Ignite 很有可能是使用了错误的网络接口。

                        -

                        为了确保 Ignite 使用正确的网络接口，在配置文件中将 IgniteConfiguration 设置为指定IP地址。 例如：

                        -
                        <bean class="org.apache.ignite.configuration.IgniteConfiguration">
-  <property name="localHost" value="192.168.1.20"/>
-</bean>
-
                        -

                        当运行集群模式时，需要确保 Vert.x 使用正确的网络接口。当通过命令行模式时，可以设置 cluster-host 参数：

                        -
                        vertx run myverticle.js -cluster -cluster-host your-ip-address
-
                        -

                        其中 your-ip-address 必须与 Ignite 中的配置保持一致。

                        -

                        当通过编程模式使用 Vert.x 时，可以调用方法 setClusterHost 来设置参数

                        -

                        使用VPN

                        -

                        VPN 软件通常通过创建不支持组播的虚拟网络接口来进行工作。在 VPN 环境中，如果 Ignite 与 Vert.x 不正确配置的话，VPN 接口将被选择，而不是正确的接口。

                        -

                        所以，如果你的软件运行在 VPN 环境中，参考上述章节，设置正确的网络接口。

                        -

                        组播被禁用

                        -

                        在一些情况下，运行环境中，无法开启组播。在这种情况下，需要配置合适的 IP finder。TCP sockets 发现器 TcpDiscoveryVmIpFinder ，或者 Amazon S3 发现器 TcpDiscoveryS3IpFinder 。

                        -

                        具体 Ignite 集群配置，可以参考文档 Apache Ignite。

                        -

                        开启日志

                        -

                        在排除故障时，开启 Ignite 日志，将会给予很大的帮助。在 classpath 中添加 vertx-default-jul-logging.properties 文件（默认的JUL记录时），这是一个标准 java.util.loging（JUL） 配置文件。具体配置如下：

                        -
                        org.apache.ignite.level=INFO
-java.util.logging.ConsoleHandler.level=INFO
-java.util.logging.FileHandler.level=INFO
-
                        - -
                        - -
                        -
                        -
                        - -

                        results matching ""

                        -
                          - -
                          -
                          - -

                          No results matching ""

                          - -
                          -
                          -
                          - -
                          -
                          - -
                          - - - - - - - - - - - - - - -
                          - - -
                          - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/clustering/ApacheZookeeper.html b/docs/clustering/ApacheZookeeper.html deleted file mode 100644 index b2b0214..0000000 --- a/docs/clustering/ApacheZookeeper.html +++ /dev/null @@ -1,1180 +0,0 @@ - - - - - - - Apache Zookeeper · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                          -
                          - - - - - - - - -
                          - -
                          - -
                          - - - - - - - - -
                          -
                          - -
                          -
                          - -
                          - -

                          Zookeeper Cluster Manager

                          -
                          -

                          请注意，当前版本还处于预览版，请慎重在生产环境中使用 -翻译：Ranger Tsao，校对 宋子豪、赵亮

                          -
                          -

                          ZookeeperClusterManager 是基于 Apache Zookeeper 实现。由于 Vert.x 集群管理的可插拔性，也可轻易切换至其它的集群管理器。

                          -

                          ZookeeperClusterManager 在组件 vertx-zookeeper 中，通过构建工具可以轻松引入：

                          -
                            -
                          • Maven(pom.xml)
                            • -
                          -
                          <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-zookeeper</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                          -
                            -
                          • Gradle(gradle.xml)
                            • -
                          -
                          compile 'io.vertx:vertx-zookeeper:3.4.1'
-
                          -

                          Vert.x 集群管理器包含以下几个功能：

                          -
                            -
                          1. 发现并管理集群中的节点
                            2. -
                          2. 管理集群端的主题订阅清单（这样就可以轻松得知集群中的那些节点订阅了那些 EventBus 地址）
                            3. -
                          3. 分布式 Map 支持
                            4. -
                          4. 分布式锁
                            5. -
                          5. 分布式计数器
                            6. -
                          -

                          注意事项 -Vert.x 集群器并不处理节点之间的通信，在 Vert.x 中节点中的通信是直接由 TCP 链接处理的。

                          -

                          工作原理

                          -

                          ZookeeperClusterManager 使用 Apache Curator 框架而不是原生Zookeeper 客户端，因此需要依赖 guava 、 slf4j 、 zookeeper 等其他第三方 jar 包。

                          -

                          由于 Zookeeper 采用字典树来存储数据，便可以以 root 路径作为命名空间，在默认的 zookeeper.json 中定义默认的根路径是 io.vertx，同时还有 5 个 子路径用来存储用于管理 Vert.x 集群的相关信息。所有的路径中，只有跟路径可以自定义配置。

                          -

                          各路径作用为：

                          -
                            -
                          • /io.vertx/cluster/nodes/ 对应 Vert.x 节点信息
                            • -
                          • /io.vertx/asyncMap/$name/ 存储通过接口 io.vertx.core.shareddata.AsyncMap 创建的 AsyncMap 记录
                            • -
                          • /io.vertx/asyncMultiMap/$name/ 存储通过接口 io.vertx.core.spi.cluster.AsyncMultiMap 创建的 AsyncMultiMap 记录
                            • -
                          • /io.vertx/locks/ 存储分布式锁
                            • -
                          • /io.vertx/counters/ 存储分布式计数器
                            • -
                          -

                          使用 Zookeeper cluster manager

                          -

                          Vert.x 能够从 classpath 路径的 jar 自动检测并使用出 ClusterManager 的实现。不过需要确保在 classpath 没有其他的 ClusterManager 实现。

                          -

                          通过命令行使用

                          -

                          确保 vertx-zookeeper-3.4.1.jar 在 Vert.x 的安装路径中的 lib 目录下。

                          -

                          通过 Maven 或 Gradle 构建工具使用

                          -
                            -
                          • Maven(pom.xml)
                            • -
                          -
                          <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-zookeeper</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                          -
                            -
                          • Gradle(gradle.xml)
                            • -
                          -
                          compile 'io.vertx:vertx-zookeeper:3.4.1'
-
                          -

                          编程形式调用

                          -

                          通过编码的形式，设置集群管理器实现，例子：

                          -
                          ClusterManager mgr = new ZookeeperClusterManager();//创建 ZookeeperClusterManager
-VertxOptions options = new VertxOptions().setClusterManager(mgr);// 设置集群管理器
-Vertx.clusteredVertx(options, res -> {
-  if (res.succeeded()) {
-    Vertx vertx = res.result();
-  } else {
-    // failed!
-  }
-});
-
                          -

                          配置 Zookeeper cluster manager

                          -

                          通常情况下，ZookeeperClusterManager 使用 jar 包中内嵌的 default-zookeeper.json 设置相应的配置。

                          -

                          如果要覆盖此配置，可以在 classpath 中添加一个 zookeeper.json 文件。如果想在 fat jar 中内嵌 zookeeper.json ，此文件必须在 fat jar 的根目录中。如果此文件是一个外部文件，则必须将其添加至 classpath 中。举个例子：

                          -
                          # zookeeper.json 在当前路径中
-java -jar ... -cp . -cluster
-vertx run MyVerticle -cp . -cluster
-
-# zookeeper.json 在 conf 目录中
-java -jar ... -cp conf -cluster
-
                          -

                          还有一种方式来覆盖默认的配置文件，那就是利用系统配置 vertx.zookeeper.config 来实现：

                          -
                          # 指定一个外部文件为自定义配置文件
-java -Dvertx.zookeeper.config=./config/my-zookeeper-conf.json -jar ... -cluster
-
-# 从 classpath 中加载一个文件为自定义配置文件
-java -Dvertx.zookeeper.config=classpath:my/package/config/my-cluster-config.json -jar ... -cluster
-
                          -

                          如果系统变量 vertx.zookeeper.config 值不为空时，将覆盖 classpath 中所有的 zookeeper.json 文件，但是如果加载 vertx.zookeeper.config 失败时，系统将选取 classpath 任意一个 zookeeper.json ，甚至直接使用默认配置。

                          -

                          在配置文件 default-zookeeper.json 中已经通过注释的形式，详细说明每个配置项的作用。

                          -

                          同其他集群管理器，亦可通过编程的形式来进行配置，举例：

                          -
                          JsonObject zkConfig = new JsonObject();
-// 设置相关配置项
-zkConfig.put("zookeeperHosts", "127.0.0.1");// zk host 地址
-zkConfig.put("rootPath", "io.vertx");// 根路径
-zkConfig.put("retry", new JsonObject() // 重试策略
-    .put("initialSleepTime", 3000)
-    .put("maxTimes", 3));
-
-ClusterManager mgr = new ZookeeperClusterManager(zkConfig);
-VertxOptions options = new VertxOptions().setClusterManager(mgr);
-
-Vertx.clusteredVertx(options, res -> {
-  if (res.succeeded()) {
-    Vertx vertx = res.result();
-  } else {
-    // failed!
-  }
-});
-
                          -
                          -

                          注意：通过系统变量 vertx.zookeeper.hosts 也可以达到配置 zookeeper hosts 的目的。

                          -
                          -

                          开启日志

                          -

                          在排除故障时，开启 Zookeeper 日志，将会给予很大的帮助。在 classpath 中添加 vertx-default-jul-logging.properties 文件（默认的JUL记录时），这是一个标准 java.util.loging（JUL） 配置文件。具体配置如下：

                          -
                          org.apache.ignite.level=INFO
-java.util.logging.ConsoleHandler.level=INFO
-java.util.logging.FileHandler.level=INFO
-

                          Zookeeper 版本

                          -

                          Vert.x 使用 2.1.1 版本的 Curator ，其使用 3.4.8 版本的 Zookeeper，因此不支持 3.5.x 中的最新特性。

                          - - -
                          - -
                          -
                          -
                          - -

                          results matching ""

                          -
                            - -
                            -
                            - -

                            No results matching ""

                            - -
                            -
                            -
                            - -
                            -
                            - -
                            - - - - - - - - - - - - - - -
                            - - -
                            - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/clustering/Clustering.html b/docs/clustering/Clustering.html deleted file mode 100644 index 115b197..0000000 --- a/docs/clustering/Clustering.html +++ /dev/null @@ -1,1086 +0,0 @@ - - - - - - - Clustering · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                            -
                            - - - - - - - - -
                            - -
                            - -
                            - - - - - - - - -
                            -
                            - -
                            -
                            - -
                            - -

                            Vert.x Clustering

                            -

                            在 Vert.x 中，集群化与高可用均是开箱即用的。Vert.x 通过可插拔的集群管理器（cluster manager）来实现集群管理。在 Vert.x 中，采用 Hazelcast 作为默认的集群管理器。

                            -

                            集群管理器

                            -

                            集群管理器的介绍见 Vert.x Core 文档手册中的相关章节。

                            -

                            集群管理器实现

                            -

                            目前 Vert.x 提供了四种集群管理器实现：

                            - - - -
                            - -
                            -
                            -
                            - -

                            results matching ""

                            -
                              - -
                              -
                              - -

                              No results matching ""

                              - -
                              -
                              -
                              - -
                              -
                              - -
                              - - - - - - - - - - - - - - -
                              - - -
                              - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/clustering/Hazelcast.html b/docs/clustering/Hazelcast.html deleted file mode 100644 index c7ad53a..0000000 --- a/docs/clustering/Hazelcast.html +++ /dev/null @@ -1,1254 +0,0 @@ - - - - - - - Hazelcast · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                              -
                              - - - - - - - - -
                              - -
                              - -
                              - - - - - - - - -
                              -
                              - -
                              -
                              - -
                              - -

                              Hazelcast Cluster Manager

                              -
                              -

                              翻译：Ranger Tsao，校对 宋子豪、赵亮

                              -
                              -

                              HazelcastClusterManager 是基于 Hazelcast 实现 ,是Vert.x 中集群管理器中的默认实现。由于 Vert.x 集群管理的可插拔性，也可轻易切换至其它的集群管理器。

                              -
                                -
                              • Maven(pom.xml)
                                • -
                              -
                              <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-hazelcast</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                              -
                                -
                              • Gradle(build.gradle)
                                • -
                              -
                              compile 'io.vertx:vertx-hazelcast:3.4.1'
-
                              -

                              Vert.x 集群管理器包含一下几个功能：

                              -
                                -
                              1. 发现并管理集群中的节点
                                2. -
                              2. 管理集群端的主题订阅清单（这样就可以轻松得知集群中的那些节点订阅了那些 EventBus 地址）
                                3. -
                              3. 分布式 Map 支持
                                4. -
                              4. 分布式锁
                                5. -
                              5. 分布式计数器
                                6. -
                              -

                              注意事项 -Vert.x 集群器并不处理节点之间的通信，在 Vert.x 中节点中的通信是直接由 TCP 链接处理的。

                              -

                              使用 Hazelcast cluster manager

                              -

                              如果通过命令行来使用 Vert.x，对应集群管理器 jar 包( vertx-hazelcast-${version} )应该在 Vert.x 中安装包中。

                              -

                              如果在 Maven 或者 Gradle 工程中使用 Vert.x ，只需要在工程依赖中加上相应的 ClusterManager 实现依赖：io.vertx:vertx-hazelcast:${version}。

                              -

                              如果 vertx-hazelcast-${version} 在 classpath 中，Vert.x将自动检测到，并将其作为集群管理。需要注意的是，要确保 Vert.x 的 classpath 中没有其它的 ClusterManager 实现 jar 包。

                              -

                              当然在内嵌 Vert.x 时，通过编程的方式创建 Vert.x 集群模式实例，调用 setClusterManager 方法显式指定集群管理器。

                              -
                              ClusterManager mgr = new HazelcastClusterManager();//创建ClusterManger对象
-
-VertxOptions options = new VertxOptions().setClusterManager(mgr);//设置到Vertx启动参数中
-
-Vertx.clusteredVertx(options, res -> {
-  if (res.succeeded()) {
-    Vertx vertx = res.result();
-  } else {
-    // failed!
-  }
-});
-
                              -

                              配置 Hazelcast cluster manager

                              -

                              通常情况下，集群管理器的相关配置是由打包的jar中的默认配置文件 default-cluster.xml 决定的。

                              -
                              -

                              default-cluster.xml 还是下面需要提到的 cluster.xml 必须是一个 Hazelcast 配置文件，在 Hazelcast 的官方网站，可以找到具体的配置描述。

                              -
                              -

                              如果要覆盖此配置，可以在 classpath 中添加一个 cluster.xml 文件。如果想在 fat jar 中内嵌 cluster.xml ，此文件必须在 fat jar 的根目录中。如果此文件是一个外部文件，则必须将其添加至 classpath 中。举个例子：

                              -
                              # cluster.xml 在当前路径中
-java -jar ... -cp . -cluster
-vertx run MyVerticle -cp . -cluster
-
-# cluster.xml 在 conf 目录中
-java -jar ... -cp conf -cluster
-
                              -

                              还有一种方式来覆盖默认的配置文件，那就是利用系统配置 vertx.hazelcast.config 来实现：

                              -
                              # 指定一个外部文件为自定义配置文件
-java -Dvertx.hazelcast.config=./config/my-cluster-config.xml -jar ... -cluster
-
-# 从 classpath 中加载一个文件为自定义配置文件
-java -Dvertx.hazelcast.config=classpath:my/package/config/my-cluster-config.xml -jar ... -cluster
-
                              -

                              如果 vertx.hazelcast.config 值不为空时，将覆盖 classpath 中所有的 cluster.xml 文件，但是如果加载 vertx.hazelcast.config 失败时，系统将选取 classpath 任意一个 cluster.xml ，甚至直接使用默认配置。

                              -
                              -

                              注意：Vert.x 并不支持 -Dhazelcast.config 设置方式，请不要使用。

                              -
                              -

                              同时也可以通过编程的形式达到配置的目的：

                              -
                              Config hazelcastConfig = new Config(); //创建hazelcast配置
-
-// 设置相关的hazlcast配置，在这里省略掉，不再赘述
-
-ClusterManager mgr = new HazelcastClusterManager(hazelcastConfig);
-
-VertxOptions options = new VertxOptions().setClusterManager(mgr);
-
-Vertx.clusteredVertx(options, res -> {
-  if (res.succeeded()) {
-    Vertx vertx = res.result();
-  } else {
-    // failed!
-  }
-});
-
                              -

                              Hazelcast支持多种不同的传输协议，包括组播和TCP。默认配置中采用组播传输协议，因此您必须在网络上启用组播才能使其工作。

                              -

                              具体详细配置，请参阅 Hazelcast 文档。

                              -

                              使用已存在的 Hazelcast 集群

                              -

                              可以在集群管理器通过设置 HazelcastInstance 来复用现有集群：

                              -
                              HazelcastInstance instance = HazelcastClient.newHazelcastClient(
-  new ClientConfig()
-    .setGroupConfig(new GroupConfig("groupname","password")
-    .setNetworkConfig(new ClientNetworkConfig().addAddress("hosts")))); //创建HazelcastClient
-ClusterManager mgr = new HazelcastClusterManager(hazelcastInstance);
-VertxOptions options = new VertxOptions().setClusterManager(mgr);
-Vertx.clusteredVertx(options, res -> {
-  if (res.succeeded()) {
-    Vertx vertx = res.result();
-  } else {
-    // failed!
-  }
-});
-
                              -

                              在这种情况下，Vert.x不是 Hazelcast 群集的所有者，所以不要关闭 Vert.x 时关闭 Hazlecast 集群。

                              -

                              请注意，自定义 Hazelcast 实例需要配置：

                              -
                              <properties>
-  <property name="hazelcast.shutdownhook.enabled">false</property>
-</properties>
-<multimap name="__vertx.subs">
-  <backup-count>1</backup-count>
-</multimap>
-<map name="__vertx.haInfo">
-  <time-to-live-seconds>0</time-to-live-seconds>
-  <max-idle-seconds>0</max-idle-seconds>
-  <eviction-policy>NONE</eviction-policy>
-  <max-size policy="PER_NODE">0</max-size>
-  <eviction-percentage>25</eviction-percentage>
-  <merge-policy>com.hazelcast.map.merge.LatestUpdateMapMergePolicy</merge-policy>
-</map>
-<semaphore name="__vertx.*">
-  <initial-permits>1</initial-permits>
-</semaphore>
-
                              -

                              重要提醒

                              -
                                -
                              • 当 Vert.x 集群使用 HA（高可用或故障转移）时，请不要使用 Hazelcast 客户端，因为他们不会通知他们何时离开集群，同时有可能丢失数据，还有可能将集群置于不一致的状态。更多情况请翻阅 Issue 24
                                • -
                              • 同时要确保 Hazelcast 集群 先于 Vert.x 集群启动，后于 Vert.x 集群关闭。同时需要禁用 shutdownhook。参考上述的 xml 配置，或者通过 系统变量来实现。
                                • -
                              -

                              使用 Hazelcast async methods

                              -

                              Hazelcast 中的 IMap 、 IAtomicLong 接口(数据结构) 均有异步调用方法，其返回值为 ICompletableFuture<V>，这与 Vert.x 的线程模型完美契合。但是即使这些接口已经存在一段时间，却没有通过 HazelcastInstance 公共 API 暴露。

                              -

                              默认情况下，HazelcastClusterManager 使用公共 API。当在程序启动时，设置选项-Dvertx.hazelcast.async-api=true ，将代表系统在与 Hazelcast 集群通讯交互时，将采用 Hazelcast async API 。这意味着，Counter 计数操作、AsyncMap的 get put remove 操作都将通过 Vert.x EventLoop 线程来执行，而不是通过 Woker 线程的 vertx.executeBlocking 执行。

                              -

                              故障排除

                              -

                              如果默认的组播配置不能正常运行，通常有以下原因：

                              -

                              机器禁用组播

                              -

                              MacOS 默认禁用组播。Google一下启用组播。

                              -

                              使用错误的网络接口

                              -

                              如果机器上有多个网络接口（也有可能是在运行 VPN 的情况下），那么 Hazelcast 很有可能是使用了错误的网络接口。

                              -

                              为了确保 Hazelcast 使用正确的网络接口，在配置文件中将 interface 设置为指定IP地址，同时确保 enabled 属性设置为 true 。 例如：

                              -
                              <interfaces enabled="true">
-  <interface>192.168.1.20</interface>
-</interfaces>
-
                              -

                              当运行集群模式时，需要确保 Vert.x 使用正确的网络接口。当通过命令行模式时，可以设置 cluster-host 参数：

                              -
                              vertx run myverticle.js -cluster -cluster-host your-ip-address
-
                              -

                              其中 your-ip-address 必须与 Hazelcast 中的配置保持一致。

                              -

                              当通过编程模式使用 Vert.x 时，可以调用方法 setClusterHost 来设置参数

                              -

                              使用VPN

                              -

                              VPN 软件通常通过创建不支持组播的虚拟网络接口来进行工作。在 VPN 环境中，如果 Hazelcast 与 Vert.x 不正确配置的话，VPN 接口将被选择，而不是正确的接口。

                              -

                              所以，如果你的软件运行在 VPN 环境中，参考上述章节，设置正确的网络接口。

                              -

                              组播不可用

                              -

                              在某些情况下，因为特殊的运行环境，可能无法使用组播。在这种情况下，应该配置其他网络传输，例如在 TCP 上使用 TCP 套接字，在亚马逊云上使用 EC2 。

                              -

                              有关 Hazelcast 更多传输方式，以及如何配置它们，请咨询 Hazelcast 文档。

                              -

                              开启日志

                              -

                              在排除故障时，开启 Hazelcast 日志，将会给予很大的帮助。在 classpath 中添加 vertx-default-jul-logging.properties 文件（默认的JUL记录时），这是一个标准 java.util.loging（JUL） 配置文件。具体配置如下：

                              -
                              com.hazelcast.level=INFO
-java.util.logging.ConsoleHandler.level=INFO
-java.util.logging.FileHandler.level=INFO
-

                              Hazelcast 日志配置

                              -

                              Hazelcast 的日志默认采用 JDK 实现（参考 JUL）。如果想切换至其他日志库，通过设置 azelcast.logging.type 即可达到目的。

                              -
                              -Dhazelcast.logging.type=slf4j
-
                              -

                              详细文档请参考 hazelcast documentation。

                              -

                              使用其他 Hazelcast 版本

                              -

                              当前的 Vert.x HazelcastClusterManager 使用的 Hazelcast 版本为 3.6.3 。如果开发者想使用其他版本的 Hazelcast，需要做以下工作：

                              -
                                -
                              • 将目标版本的 Hazelcast 依赖添加至 classpath 中
                                • -
                              • 如果是 fat jar 的形式，在构建工具中使用正确的版本
                                • -
                              -

                              参考代码如下：

                              -
                                -
                              • Maven(pom.xml)
                                • -
                              -
                              <dependency>
-  <groupId>com.hazelcast</groupId>
-  <artifactId>hazelcast</artifactId>
-  <version>ENTER_YOUR_VERSION_HERE</version>
-</dependency>
-<dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-hazelcast</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                              -
                                -
                              • Gradle(build.gradle)
                                • -
                              -
                              dependencies {
- compile ("io.vertx:vertx-hazelcast:3.4.1"){
-   exclude group: 'com.hazelcast', module: 'hazelcast'
- }
- compile "com.hazelcast:hazelcast:ENTER_YOUR_VERSION_HERE"
-}
-
                              - - -
                              - -
                              -
                              -
                              - -

                              results matching ""

                              -
                                - -
                                -
                                - -

                                No results matching ""

                                - -
                                -
                                -
                                - -
                                -
                                - -
                                - - - - - - - - - - - - - - -
                                - - -
                                - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/clustering/Infinispan.html b/docs/clustering/Infinispan.html deleted file mode 100644 index a53e9cf..0000000 --- a/docs/clustering/Infinispan.html +++ /dev/null @@ -1,1328 +0,0 @@ - - - - - - - Infinispan · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                -
                                - - - - - - - - -
                                - -
                                - -
                                - - - - - - - - -
                                -
                                - -
                                -
                                - -
                                - -

                                Infinispan Cluster Manager

                                -
                                -

                                请注意，当前版本还处于预览版，请慎重在生产环境中使用 -翻译：Ranger Tsao，校对 宋子豪、赵亮

                                -
                                -

                                InfinispanClusterManager 是基于 Infinispan 实现。由于 Vert.x 集群管理的可插拔性，也可轻易切换至其它的集群管理器。

                                -

                                InfinispanClusterManager 在组件 vertx-infinispan 中，通过构建工具可以轻松引入：

                                -
                                  -
                                • Maven(pom.xml)
                                  • -
                                -
                                <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-infinispan</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                -
                                  -
                                • Gradle(gradle.xml)
                                  • -
                                -
                                compile 'io.vertx:vertx-infinispan:3.4.1'
-
                                -

                                Vert.x 集群管理器包含以下几个功能：

                                -
                                  -
                                1. 发现并管理集群中的节点
                                  2. -
                                2. 管理集群端的主题订阅清单（这样就可以轻松得知集群中的那些节点订阅了那些 EventBus 地址）
                                  3. -
                                3. 分布式 Map 支持
                                  4. -
                                4. 分布式锁
                                  5. -
                                5. 分布式计数器
                                  6. -
                                -

                                注意事项 -Vert.x 集群器并不处理节点之间的通信，在 Vert.x 中节点中的通信是直接由 TCP 链接处理的。

                                -

                                使用 Infinispan cluster manager

                                -

                                Vert.x 能够从 classpath 路径的 jar 自动检测并使用出 ClusterManager 的实现。不过需要确保在 classpath 没有其他的 ClusterManager 实现。

                                -

                                通过命令行使用

                                -

                                确保 vertx-infinispan-3.4.1.jar 在 Vert.x 的安装路径中的 lib 目录下。

                                -

                                通过 Maven 或 Gradle 构建工具使用

                                -
                                  -
                                • Maven(pom.xml)
                                  • -
                                -
                                <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-infinispan</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                -
                                  -
                                • Gradle(gradle.xml)
                                  • -
                                -
                                compile 'io.vertx:vertx-infinispan:3.4.1'
-
                                -

                                编程形式调用

                                -

                                通过编码的形式，设置集群管理器实现，例子：

                                -
                                ClusterManager mgr = new InfinispanClusterManager();//创建 InfinispanClusterManager
-VertxOptions options = new VertxOptions().setClusterManager(mgr);// 设置集群管理器
-Vertx.clusteredVertx(options, res -> {
-  if (res.succeeded()) {
-    Vertx vertx = res.result();
-  } else {
-    // failed!
-  }
-});
-
                                -

                                配置 Infinispan cluster manager

                                -

                                通常情况下，InfinispanClusterManager 使用 jar 包中内嵌的两个文件来配置自身属性：

                                -
                                  -
                                1. jgroup.xml
                                  2. -
                                2. infinispan.xml
                                  3. -
                                -

                                如果要覆盖其中任意一个配置文件，可以在 classpath 中添加对应的文件。如果想在 fat jar 中内嵌相应的配置文件 ，此文件必须在 fat jar 的根目录中。如果此文件是一个外部文件，则必须将其添加至 classpath 中。举个例子：

                                -
                                # infinispan.xml 在当前路径中
-java -jar ... -cp . -cluster
-vertx run MyVerticle -cp . -cluster
-
-# infinispan.xml 在 conf 目录中
-java -jar ... -cp conf -cluster
-
                                -

                                还有一种方式来覆盖默认的配置文件，那就是利用系统配置 vertx.infinispan.config 来实现：

                                -
                                # 指定一个外部文件为自定义配置文件
-java -Dvertx.infinispan.config=./config/my-infinispan.xml -jar ... -cluster
-
-# 从 classpath 中加载一个文件为自定义配置文件
-java -Dvertx.infinispan.config=my/package/config/my-infinispan.xml -jar ... -cluster
-
                                -

                                如果系统变量 vertx.infinispan.config 值不为空时，将覆盖 classpath 中所有的 infinispan.xml 文件，但是如果加载 vertx.infinispan.config 失败时，系统将选取 classpath 任意一个 infinispan.xml ，甚至直接使用默认配置。

                                -

                                jgroup.xml 与 infinispan.xml 分别是 JGroups 、 Infinispan 配置文件。在对应的官方可以网站可以详细的配置攻略。

                                -

                                同其他集群管理器，亦可通过编程的形式来进行配置，举例：

                                -
                                ClusterManager mgr = new InfinispanClusterManager("custom-infinispan.xml");//加载自定义配置文件
-
-VertxOptions options = new VertxOptions().setClusterManager(mgr);
-
-Vertx.clusteredVertx(options, res -> {
-  if (res.succeeded()) {
-    Vertx vertx = res.result();
-  } else {
-    // failed!
-  }
-});
-
                                -

                                使用已有 Infinispan Cache Manager

                                -

                                开发者可以通过 DefaultCacheManager 来复用已经存在的 cache manager。

                                -
                                ClusterManager mgr = new InfinispanClusterManager(cacheManager);
-VertxOptions options = new VertxOptions().setClusterManager(mgr);
-Vertx.clusteredVertx(options, res -> {
-  if (res.succeeded()) {
-    Vertx vertx = res.result();
-  } else {
-    // failed!
-  }
-});
-
                                -

                                在这种情况下，Vert.x 并不是 cache manager 的所有者，因此不能在关闭 Vert.x 时，停止 Infinispan 。

                                -

                                需要注意的是，需要通过如下配置来自定义 Infinispan 实例：

                                -
                                <cache-container default-cache="__vertx.distributed.cache">
-
-  <replicated-cache name="__vertx.subs">
-    <expiration interval="-1"/>
-  </replicated-cache>
-
-  <replicated-cache name="__vertx.haInfo">
-    <expiration interval="-1"/>
-  </replicated-cache>
-
-  <distributed-cache name="__vertx.distributed.cache">
-    <expiration interval="-1"/>
-  </distributed-cache>
-
-</cache-container>
-
                                -

                                适配 Openshift 3

                                -

                                为了使 Vert.x 集群能够正常运行在 Openshift 3，需要在配置以及依赖上做一些改动。

                                -

                                首先，添加 JGroups KUBE_PING 协议依赖：

                                -
                                <dependency>
-  <groupId>org.jgroups.kubernetes</groupId>
-  <artifactId>kubernetes</artifactId>
-  <version>0.9.0</version>
-  <exclusions>
-    <exclusion>                                          (1)
-      <artifactId>undertow-core</artifactId>
-      <groupId>io.undertow</groupId>
-    </exclusion>
-  </exclusions>
-</dependency>
-
                                -
                                -
                                  -
                                1. 去掉 undertow-core 依赖, 确保 KUBE_PING 能够在 JDK Http server 正常运行
                                  2. -
                                -
                                -

                                然后覆盖默认的 JGroups 配置，确保 KUBE_PING 成为其发现协议，代码如下：

                                -
                                <config xmlns="urn:org:jgroups"
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:schemaLocation="urn:org:jgroups http://www.jgroups.org/schema/JGroups-3.6.xsd">
-
-  <TCP bind_addr="${jgroups.tcp.address:match-interface:eth.*}"
-       bind_port="${jgroups.tcp.port:7800}"
-       enable_diagnostics="false"
-       thread_naming_pattern="pl"
-       send_buf_size="640k"
-       sock_conn_timeout="300"
-       bundler_type="transfer-queue"
-
-       thread_pool.min_threads="${jgroups.thread_pool.min_threads:2}"
-       thread_pool.max_threads="${jgroups.thread_pool.max_threads:30}"
-       thread_pool.keep_alive_time="60000"
-       thread_pool.queue_enabled="false"
-
-       internal_thread_pool.min_threads="${jgroups.internal_thread_pool.min_threads:5}"
-       internal_thread_pool.max_threads="${jgroups.internal_thread_pool.max_threads:20}"
-       internal_thread_pool.keep_alive_time="60000"
-       internal_thread_pool.queue_enabled="true"
-       internal_thread_pool.queue_max_size="500"
-
-       oob_thread_pool.min_threads="${jgroups.oob_thread_pool.min_threads:20}"
-       oob_thread_pool.max_threads="${jgroups.oob_thread_pool.max_threads:200}"
-       oob_thread_pool.keep_alive_time="60000"
-       oob_thread_pool.queue_enabled="false"
-  />
-  <kubernetes.KUBE_PING
-  />
-  <MERGE3 min_interval="10000"
-            max_interval="30000"
-  />
-  <FD_SOCK/>
-  <FD_ALL timeout="60000"
-           interval="15000"
-           timeout_check_interval="5000"
-  />
-  <VERIFY_SUSPECT timeout="5000"/>
-  <pbcast.NAKACK2 use_mcast_xmit="false"
-                  xmit_interval="1000"
-                  xmit_table_num_rows="50"
-                  xmit_table_msgs_per_row="1024"
-                  xmit_table_max_compaction_time="30000"
-                  max_msg_batch_size="100"
-                  resend_last_seqno="true"
-  />
-  <UNICAST3 xmit_interval="500"
-             xmit_table_num_rows="50"
-             xmit_table_msgs_per_row="1024"
-             xmit_table_max_compaction_time="30000"
-             max_msg_batch_size="100"
-             conn_expiry_timeout="0"
-  />
-  <pbcast.STABLE stability_delay="500"
-                 desired_avg_gossip="5000"
-                 max_bytes="1M"
-  />
-  <pbcast.GMS print_local_addr="false"
-              join_timeout="${jgroups.join_timeout:5000}"
-  />
-  <MFC max_credits="2m"
-        min_threshold="0.40"
-  />
-  <FRAG3/>
-</config>
-
                                -

                                KUBE_PING 默认监听 8080 端口, 因此在构建容器镜像时，需要显式声明：

                                -
                                EXPOSE 8888
-
                                -

                                同样需要设置项目命名空间作为发现范围：

                                -
                                ENV OPENSHIFT_KUBE_PING_NAMESPACE my-openshift3-project
-
                                -

                                然后，通过设置系统变量，确保 JVM 采用 IPv4

                                -
                                -Djava.net.preferIPv4Stack=true
-
                                -

                                最后, 所有的设置需要一个服务账号：

                                -
                                oc policy add-role-to-user view system:serviceaccount:$(oc project -q):default -n $(oc project -q)
-
                                -

                                有关更多配置详情，请参考 Kubernetes discovery protocol for JGroups 。

                                -

                                适配 Docker Compose

                                -

                                确认 JVM 在启动时 设置了下面两项配置：

                                -
                                -Djava.net.preferIPv4Stack=true -Djgroups.tcp.address=NON_LOOPBACK
-

                                通过上述两项系统配置，JGroups 才能正确的挑选出 Docker 创建的虚拟网络接口。

                                -

                                故障排除

                                -

                                组播未正常开启

                                -

                                MacOS 默认禁用组播。Google一下启用组播。

                                -

                                使用错误的网络接口

                                -

                                如果机器上有多个网络接口（也有可能是在运行 VPN 的情况下），那么 JGroups 很有可能是使用了错误的网络接口。

                                -

                                为了确保 JGroups 使用正确的网络接口，在配置文件中将 bind_addr 设置为指定IP地址。 例如：

                                -
                                <TCP bind_addr="192.168.1.20" />
-<MPING bind_addr="192.168.1.20" />
-
                                -

                                另外，如果需要修改打包好的 jgoups.xml 文件，可以通过设置 jgroups.tcp.address 系统变量来达到目的

                                -
                                -Djgroups.tcp.address=192.168.1.20
-
                                -

                                当运行集群模式时，需要确保 Vert.x 使用正确的网络接口。当通过命令行模式时，可以设置 cluster-host 参数：

                                -
                                vertx run myverticle.js -cluster -cluster-host your-ip-address
-
                                -

                                其中 your-ip-address 必须与 JGroup 中的配置保持一致。

                                -

                                当通过编程模式使用 Vert.x 时，可以调用方法 setClusterHost 来设置参数

                                -

                                使用VPN

                                -

                                VPN软件通常通过创建不支持多播虚拟网络接口来进行工作。如果有一个 VPN 运行，如果 JGroups与 Vert.x 不正确配置的话，VPN接口将被选择，而不是正确的接口。

                                -

                                所以，如果你运行在 VPN 环境中，参考上述章节，设置正确的网络接口。

                                -

                                组播被禁用

                                -

                                在某些情况下，因为特殊的运行环境，可能无法使用组播。在这种情况下，应该配置其他网络传输协议，例如在 TCP 上使用 TCPPING ，在亚马逊云上使用 S3_PING 。

                                -

                                有关 JGroups 更多传输方式，以及如何配置它们，请咨询 JGroups文档 。

                                -

                                IPv6 错误

                                -

                                如果在 IPv6 地址配置有难点，请强制使用 IPv4:

                                -
                                -Djava.net.preferIPv4Stack=true
-
                                -

                                Infinispan 日志配置

                                -

                                Infinispan 依赖与 JBoss Logging 。JBoss Logging 是一个与多种日志框架的桥接器。

                                -

                                JBoss Logging 能够自动检测使用 classpath 中 JARS 中的日志框架实现。

                                -

                                如果在 classpath 有多种日志框架，可以通过设置系统变量 org.jboss.logging.provider 来指定具体的实现，例子：

                                -
                                -Dorg.jboss.logging.provider=log4j2
-
                                -

                                更多配置信息请参考 JBoss Logging

                                -

                                JGroups 日志配置

                                -

                                JGroups 默认采用 JDK Logging 实现。同时也支持 log4j 与 log4j2 ，如果相应的 jar 包 在 classpath 中。

                                -

                                如果想查阅更详细的信息，或实现自己的日志后端，请参考 JGroups 日志文档

                                - - -
                                - -
                                -
                                -
                                - -

                                results matching ""

                                -
                                  - -
                                  -
                                  - -

                                  No results matching ""

                                  - -
                                  -
                                  -
                                  - -
                                  -
                                  - -
                                  - - - - - - - - - - - - - - -
                                  - - -
                                  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/clustering/JGroups.html b/docs/clustering/JGroups.html deleted file mode 100644 index 8255cae..0000000 --- a/docs/clustering/JGroups.html +++ /dev/null @@ -1,1205 +0,0 @@ - - - - - - - JGroups · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                  -
                                  - - - - - - - - -
                                  - -
                                  - -
                                  - - - - - - - - -
                                  -
                                  - -
                                  -
                                  - -
                                  - -
                                  -

                                  从 Vert.x 3.4.0 开始，Vert.x 已经弃用 JGoups 实现，已经由 [infinispan]|(/clustering/Infinispan.md) 。不建议在生产或测试环境中使用

                                  -
                                  -

                                  JGroups Cluster Manager

                                  -

                                  在构建工具中添加依赖即可：

                                  -
                                    -
                                  • Maven(pom.xml)
                                    • -
                                  -
                                  <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-jgroups</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                  -
                                    -
                                  • Gradle(build.gradle)
                                    • -
                                  -
                                  compile 'io.vertx:vertx-jgroups:3.4.1'
-

                                  如果通过命令行来使用Vert.x，jar包vertx-jgroups-3.4.1.jar，应该在Vert.x中安装包中。同时也要将jgroups 的jar加到lib目录中。

                                  -

                                  如果 vertx-jgroups-3.4.1.jar 在 classpath 中，Vert.x将自动检测到，并将其作为集群管理。需要注意的是，要确保Vert.x的 classpath 中没有其它的 ClusterManager 实现 jar 包。也可以通过设置启动参数: -Dvertx.clusterManagerFactory=io.vertx.spi.cluster.jgroups.JGroupsClusterManager ,来指定集群管理器。

                                  -

                                  同 [hazlcast]|(/clustering/Hazelcast.md)，也可以通过编程的方式来实现：

                                  -
                                  ClusterManager mgr = new JGroupsClusterManager();
-VertxOptions options = new VertxOptions().setClusterManager(mgr);
-Vertx.clusteredVertx(options, res -> {
-  if (res.succeeded()) {
-    Vertx vertx = res.result();
-  } else {
-    // failed!
-  }
-});
-
                                  -

                                  配置

                                  -

                                  JGroups 的配置文件 default-jgroups.xml 如下：

                                  -
                                  <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-xmlns="urn:org:jgroups"
-xsi:schemaLocation="urn:org:jgroups http://www.jgroups.org/schema/jgroups.xsd">
-
-<UDP
-  mcast_port="${jgroups.udp.mcast_port:45588}"
-  ip_ttl="0"
-  tos="8"
-  ucast_recv_buf_size="5M"
-  ucast_send_buf_size="5M"
-  mcast_recv_buf_size="5M"
-  mcast_send_buf_size="5M"
-  max_bundle_size="64K"
-  max_bundle_timeout="30"
-  enable_diagnostics="true"
-  thread_naming_pattern="cl"
-
-  timer_type="new3"
-  timer.min_threads="4"
-  timer.max_threads="10"
-  timer.keep_alive_time="3000"
-  timer.queue_max_size="500"
-
-  thread_pool.enabled="true"
-  thread_pool.min_threads="2"
-  thread_pool.max_threads="8"
-  thread_pool.keep_alive_time="5000"
-  thread_pool.queue_enabled="true"
-  thread_pool.queue_max_size="100000"
-  thread_pool.rejection_policy="discard"
-
-  oob_thread_pool.enabled="true"
-  oob_thread_pool.min_threads="1"
-  oob_thread_pool.max_threads="8"
-  oob_thread_pool.keep_alive_time="5000"
-  oob_thread_pool.queue_enabled="false"
-  oob_thread_pool.queue_max_size="100"
-  oob_thread_pool.rejection_policy="discard"/>
-
-<PING/>
-<MERGE3 max_interval="30000" min_interval="10000"/>
-<FD_SOCK/>
-<FD_ALL/>
-<VERIFY_SUSPECT timeout="1500"/>
-<BARRIER/>
-<pbcast.NAKACK2 xmit_interval="500"
-  xmit_table_num_rows="100"
-  xmit_table_msgs_per_row="2000"
-  xmit_table_max_compaction_time="30000"
-  max_msg_batch_size="500"
-  use_mcast_xmit="true"
-  discard_delivered_msgs="true"/>
-
-<UNICAST3 xmit_table_num_rows="100" xmit_table_msgs_per_row="1000"
-  xmit_table_max_compaction_time="30000" max_msg_batch_size="500"/>
-
-<pbcast.STABLE stability_delay="1000" desired_avg_gossip="50000"
-  max_bytes="8m"/>
-
-<pbcast.GMS print_local_addr="true" join_timeout="2000"
-  view_bundling="true"/>
-<UFC max_credits="2M"min_threshold="0.4"/>
-<MFC max_credits="2M" min_threshold="0.4"/>
-<FRAG2 frag_size="60K"/>
-<pbcast.STATE_TRANSFER/>
-
-<COUNTER/>
-<CENTRAL_LOCK use_thread_id_for_lock_owner="false"/>
-</config>
-
                                  -

                                  default-jgroups.xml 内嵌在对应jar包中。

                                  -

                                  如果要覆盖此配置，可以在 classpath 中添加一个 jgroups.xml 文件。此配置文件必须是一个 JGroups 配置文件，在 JGroups 的官方网站中，可以找到具体的配置描述。

                                  -

                                  JGroups支持多种传播方式，包括多播与TCP。默认配置时多播方式，所以需要确保网络是否启用多播。

                                  -

                                  故障排除

                                  -

                                  如果默认的多播配置不能正常运行，通常有以下原因：

                                  -

                                  机器禁用多播

                                  -

                                  当使用UDP时，IP多播是必需的，在一些系统中，多播路由需要被添加到路由表中，否则，缺省路由将被使用，请注意，有些系统并不适用路由表中的IP组播路由，只为单播路由

                                  -

                                  Mac系统例子：

                                  -
                                  # Adds a multicast route for 224.0.0.1-231.255.255.254
-sudo route add -net 224.0.0.0/5 127.0.0.1
-
-# Adds a multicast route for 232.0.0.1-239.255.255.254
-sudo route add -net 232.0.0.0/5 192.168.1.3
-

                                  错误配置的IPV6

                                  -

                                  默认情况下，JVM 使用 IPv6，但路由表配置不正确，或使用 IPv4 解决方法：查看 IPv6 路由或强制使用 IPv4 （-Djava.net.preferIPv4Stack=TRUE）。有关这方面更多的细节可在https://developer.jboss.org/wiki/IPv6。

                                  -

                                  使用错误的网络接口

                                  -

                                  如果机器上上有多个网络接口（也有可能是在运行VPN的情况下），那么JGroups很有可能是使用了错误的网络接口。

                                  -

                                  配置参数 jgroups.bind_addr 用来确定绑定的网络接口, 例如：jgroups.bind_addr=192.168.1.5。

                                  -

                                  下面这些配置参数同样有效：

                                  -
                                    -
                                  • global:挑选一个可用的全局地址。如果不能，使用 site_local 地址。
                                    • -
                                  • site_local:挑选一个本地（非路由）的IP地址，例如从192.168.0.0或10.0.0.0地址
                                    • -
                                  • link_local:挑选一个链接本地IP地址从169.254.1.0到169.254.254.255
                                    • -
                                  • non_loopback:挑选任何非回送地址
                                    • -
                                  • loopback:挑选一个环回地址，例如127.0.0.1
                                    • -
                                  • match-interface:挑选任何匹配网络接口名的地址，例如匹配接口：ETH\ *
                                    • -
                                  • match-host:挑选任何符合域名规则的地址，例如：linux.*
                                    • -
                                  • match-address:挑选任务符合IP地址规则的地址，例如：192.168.*
                                    • -
                                  -

                                  当运行集群模式时，需要确保Vert.x使用正确的网络接口。当通过命令行模式时，可以设置cluster-host参数：

                                  -
                                  vertx run myverticle.js -cluster -cluster-host your-ip-address
-

                                  其中 your-ip-address 必须与 JGroups 中的配置保持一致。

                                  -

                                  当通过编程模式使用 Vert.x 时，可以调用方法 setClusterHost 来设置参数

                                  -

                                  使用VPN

                                  -

                                  VPN软件通常通过创建不支持多播虚拟网络接口来进行工作。如果有一个 VPN 运行，如果 JGroups与 Vert.x 不正确配置的话，VPN接口将被选择，而不是正确的接口。

                                  -

                                  所以，如果你运行在 VPN 环境中，参考上述章节，设置正确的网络接口。

                                  -

                                  多播不可用

                                  -

                                  在某些情况下，因为特殊的运行环境，可能无法使用多播。在这种情况下，应该配置其他网络传输，例如在 TCP 上使用 TCP 套接字，在亚马逊云上使用 EC2。

                                  -

                                  有关 JGroups 更多传输方式，以及如何配置它们，请咨询JGroups文档。

                                  -

                                  开启日志

                                  -

                                  在排除故障时，开启JGroups日志，将会给予很大的帮助。在 classpath 中添加 vertx-default-jul-logging.properties 文件（默认的JUL记录时），这是一个标准 java.util.loging（JUL）配置文件。具体配置如下：

                                  -
                                  org.jgroups.level=INFO
-java.util.logging.ConsoleHandler.level=INFO
-java.util.logging.FileHandler.level=INFO
-
                                  - -
                                  - -
                                  -
                                  -
                                  - -

                                  results matching ""

                                  -
                                    - -
                                    -
                                    - -

                                    No results matching ""

                                    - -
                                    -
                                    -
                                    - -
                                    -
                                    - -
                                    - - - - - - - - - - - - - - -
                                    - - -
                                    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/core/Core.html b/docs/core/Core.html deleted file mode 100644 index 945138b..0000000 --- a/docs/core/Core.html +++ /dev/null @@ -1,5361 +0,0 @@ - - - - - - - Core · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                    -
                                    - - - - - - - - -
                                    - -
                                    - -
                                    - - - - - - - - -
                                    -
                                    - -
                                    -
                                    - -
                                    - -

                                    Vert.x Core 文档手册

                                    -

                                    中英对照表

                                    -
                                      -
                                    • Client：客户端
                                      • -
                                    • Server：服务器
                                      • -
                                    • Primitive：基本（描述类型）
                                      • -
                                    • Writing：编写（有些地方译为开发）
                                      • -
                                    • Fluent：流式的
                                      • -
                                    • Reactor：反应器，Multi-Reactor即多反应器
                                      • -
                                    • Options：配置项，作为参数时候翻译成选项
                                      • -
                                    • Context：上下文环境
                                      • -
                                    • Undeploy：撤销（反部署，对应部署）
                                      • -
                                    • Unregister：注销（反注册，对应注册）
                                      • -
                                    • Destroyed：销毁
                                      • -
                                    • Handler/Handle：处理器/处理，有些特定处理器未翻译，如Completion Handler等。
                                      • -
                                    • Block：阻塞
                                      • -
                                    • Out of Box：标准环境（开箱即用）
                                      • -
                                    • Timer：计时器
                                      • -
                                    • Event Loop Pool：事件轮询线程池，大部分地方未翻译
                                      • -
                                    • Worker Pool：工作者线程池，大部分地方未翻译
                                      • -
                                    • Sender：发送者
                                      • -
                                    • Consumer：消费者
                                      • -
                                    • Receiver/Recipient：接收者
                                      • -
                                    • Entry：条目（一条key=value的键值对）
                                      • -
                                    • Map：动词翻译成 “映射”，名词为数据结构未翻译
                                      • -
                                    • Logging：动词翻译成 “记录”，名词翻译成日志器
                                      • -
                                    • Trust Store：受信存储
                                      • -
                                    • Frame：帧
                                      • -
                                    • Event Bus：事件总线
                                      • -
                                    • Buffer：缓冲区（一些地方使用的 Vert.x 中的 Buffer 类则不翻译）
                                      • -
                                    • Chunk：块（HTTP 数据块，分块传输、分块模式中会用到）
                                      • -
                                    • Pump：泵（平滑流式数据读入内存的机制，防止一次性将大量数据读入内存导致内存溢出）
                                      • -
                                    • Header：请求/响应头
                                      • -
                                    • Body：请求/响应体（有些地方翻译成请求/响应正文）
                                      • -
                                    • Pipe：管道
                                      • -
                                    • Round-Robin：轮询
                                      • -
                                    • Application-Layer Protocol Negotiation：ALPN，应用层协议协商
                                      • -
                                    • Wire：报文
                                      • -
                                    • Flush：刷新（指将缓冲区中已有的数据一次性压入，用这种方式清空缓冲区，传统上翻译成刷新）
                                      • -
                                    • Cipher Suite：密码套件
                                      • -
                                    • Datagram：数据报
                                      • -
                                    • Socket：套接字（有些地方未翻译，直接用的 Socket）
                                      • -
                                    • Multicast：多播（组播）
                                      • -
                                    • Concurrent Composition：并发合并
                                      • -
                                    • High Availability：高可用性
                                      • -
                                    • Multiplexing：多路复用
                                      • -
                                    • Fail-Over：故障转移
                                      • -
                                    • Hops：跳数（一台路由器/主机到另外一台路由器/主机所经过的路由器的数量，经过路由转发次数越多，跳数越大）
                                      • -
                                    • Launcher：启动器
                                      • -
                                    -
                                    -

                                    请注意：Vert.x 和 Vertx 的区别：文中所有 Vert.x 概念使用标准单词 Vert.x，而 Vertx 通常表示Java中的类 io.vertx.core.Vertx。

                                    -
                                    -

                                    组件介绍

                                    -

                                    Vert.x 的核心 Java API 被我们称为 Vert.x Core。

                                    -

                                    Vert.x Core 提供了下列功能:

                                    -
                                      -
                                    • 编写 TCP 客户端和服务端
                                      • -
                                    • 编写支持 WebSocket 的 HTTP 客户端和服务端
                                      • -
                                    • 事件总线
                                      • -
                                    • 共享数据 —— 本地的Map和分布式集群Map
                                      • -
                                    • 周期性、延迟性动作
                                      • -
                                    • 部署和撤销 Verticle 实例
                                      • -
                                    • 数据报套接字
                                      • -
                                    • DNS客户端
                                      • -
                                    • 文件系统访问
                                      • -
                                    • 高可用性
                                      • -
                                    • 集群
                                      • -
                                    -

                                    Vert.x Core中的功能相当底层 —— 您在此不会找到诸如数据库访问、授权或高层Web应用的功能。您可以在Vert.x ext （扩展包）（译者注：Vert.x的扩展包是Vert.x的子项目集合，类似Web、Web Client、Data Access等）中找到这些功能。

                                    -

                                    Vert.x Core 小而轻，您可以只使用您需要的部分。它可整体嵌入现存应用中。我们并不会强迫您用特定的方式构造您的应用。

                                    -

                                    您亦可在其它Vert.x支持的语言中使用Vert.x Core。很酷的是：我们并不强迫您在书写诸如 JavaScript 或 Ruby 时直接调用 Java API，毕竟不同的语言有不同的代码风格，若强行让 Ruby 开发人员遵循 Java 的代码风格会很怪异，所以我们根据 Java API 自动生成了适应不同语言代码风格的 API。

                                    -

                                    如果您在使用 Maven 或 Gradle（译者注：两种常用的项目构建工具），将以下依赖项添加到您的项目描述文件的 dependencies 节点中以使用 Vert.x Core 的API：

                                    -
                                      -
                                    • Maven（您的 pom.xml 中）
                                      • -
                                    -
                                    <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-core</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                    -
                                      -
                                    • Gradle（您的 build.gradle 中）
                                      • -
                                    -
                                    dependencies {
-    compile 'io.vertx:vertx-core:3.4.1'
-}
-
                                    -

                                    接下来讨论 Vert.x Core 中不同的概念和特性。

                                    -

                                    故事从 Vert.x 开始

                                    -
                                    -

                                    请注意：本文大部分内容专用于 Java 语言——若有需要可以切换到语言特定部分（手册中）。

                                    -
                                    -

                                    除非您拿到 Vertx 对象，否则在Vert.x领域中您做不了太多的事情。它是 Vert.x 的控制中心，也是您做几乎一切事情的基础，包括创建客户端和服务器、获取事件总线的引用、设置定时器等等。

                                    -

                                    那么如何获取它的实例呢？

                                    -

                                    如果您用嵌入方式使用Vert.x，可通过以下代码创建实例：

                                    -
                                    Vertx vertx = Vertx.vertx();
-
                                    -

                                    如果您使用 Verticle，在 Verticle 中会有一个内置的 vertx 对象，您可直接使用该内置对象，无需重新创建。

                                    -
                                    -

                                    请注意：大部分应用将只会需要一个Vert.x实例，但如果您有需要也可创建多个Vert.x实例，如：隔离的事件总线或不同组的客户端和服务器。

                                    -
                                    -

                                    创建 Vertx 对象时指定配置项

                                    -

                                    如果缺省的配置不适合您，可在创建 Vertx 对象的同时指定配置项：

                                    -
                                    Vertx vertx = Vertx.vertx(new VertxOptions().setWorkerPoolSize(40));
-
                                    -

                                    VertxOptions对象有很多配置，包括集群、高可用、池大小等。在Javadoc中描述了所有配置的细节。

                                    -

                                    创建集群模式的 Vert.x 对象

                                    -

                                    如果您想创建一个集群模式的 Vertx 对象（参考 Event Bus 章节了解更多事件总线集群细节），那么通常情况下您将需要使用另一种异步的方式来创建 Vertx 对象。

                                    -

                                    这是因为让不同的 Vert.x 实例组成一个集群需要一些时间（也许是几秒钟）。在这段时间内，我们不想去阻塞调用线程，所以我们将结果异步返回给您。

                                    -
                                    -

                                    译者注：这里给个示例：

                                    -
                                    // 注意要添加对应的集群管理器依赖，详情见集群管理器章节
-VertxOptions options = new VertxOptions();
-Vertx.clusteredVertx(options, res -> {
-  if (res.succeeded()) {
-    Vertx vertx = res.result(); // 获取到了集群模式下的 Vertx 对象
-    // 做一些其他的事情
-  } else {
-    // 获取失败，可能是集群管理器出现了问题
-  }
-});
-
                                    -
                                    -

                                    是流式的吗？

                                    -

                                    您也许注意到前边的例子里使用了一个流式（Fluent）的API。

                                    -

                                    一个流式的API表示将多个方法的调用链在一起。例如：

                                    -
                                    request.response().putHeader("Content-Type", "text/plain").write("some text").end();
-
                                    -

                                    这是贯穿 Vert.x API 中的一个通用模式，所以请适应这种代码风格。

                                    -

                                    这样的链式调用会让您的代码更为简洁。当然，如果您不喜欢流式风格，我们不强制您用这种方式书写代码。如果您更倾向于用以下方式编码，您可以忽略它：

                                    -
                                    HttpServerResponse response = request.response();
-response.putHeader("Content-Type", "text/plain");
-response.write("some text");
-response.end();
-
                                    -

                                    Don’t call us, we’ll call you

                                    -

                                    Vert.x 的 API 大部分都是事件驱动的。这意味着当您感兴趣的事情发生时，它会以事件的形式发送给您。

                                    -

                                    以下是一些事件的例子：

                                    -
                                      -
                                    • 触发一个计时器
                                      • -
                                    • Socket 收到了一些数据
                                      • -
                                    • 从磁盘中读取了一些数据
                                      • -
                                    • 发生了一个异常
                                      • -
                                    • HTTP 服务器收到了一个请求
                                      • -
                                    -

                                    您提供处理器给Vert.x API来处理事件。例如每隔一秒发送一个事件的计时器：

                                    -
                                    vertx.setPeriodic(1000, id -> {
-  // This handler will get called every second
-  // 这个处理器将会每隔一秒被调用一次
-  System.out.println("timer fired!");
-});
-
                                    -

                                    又或者收到一个HTTP请求：

                                    -
                                    server.requestHandler(request -> {
-  // This handler will be called every time an HTTP request is received at the server
-  // 服务器每次收到一个HTTP请求时这个处理器将被调用
-  request.response().end("hello world!");
-});
-
                                    -

                                    稍后当Vert.x有一个事件要传给您的处理器时，它会 异步地 调用这个处理器。

                                    -

                                    由此引入了下面一些Vert.x中的重要概念。

                                    -

                                    不要阻塞我！

                                    -

                                    除了很少的特例（如以 "Sync" 结尾的某些文件系统操作），Vert.x中的所有API都不会阻塞调用线程。

                                    -

                                    如果可以立即提供结果，它将立即返回，否则您需要提供一个处理器（Handler）来接收稍后回调的事件。

                                    -

                                    因为Vert.x API不会阻塞线程，所以通过Vert.x您可以只使用少量的线程来处理大量的并发。

                                    -

                                    当使用传统的阻塞式API做以下操作时，调用线程可能会被阻塞：

                                    -
                                      -
                                    • 从 Socket 中读取数据
                                      • -
                                    • 写数据到磁盘
                                      • -
                                    • 发送消息给接收者并等待回复
                                      • -
                                    • 其他很多情况
                                      • -
                                    -

                                    在上述所有情况下，当您的线程在等待处理结果时它不能做任何事，此时这些线程并无实际用处。这意味着如果您使用阻塞式API处理大量并发，您需要大量线程来防止应用程序逐步停止运转。所需的内存（例如它们的栈）和上下文切换都是线程的开销。这意味着，阻塞式的方式对于现代应用程序所需要的并发级别来说是难于扩展的。

                                    -

                                    Reactor 模式和 Multi-Reactor 模式

                                    -

                                    我们前边提过 Vert.x 的 API 都是事件驱动的，当有事件时 Vert.x 会将事件传给处理器来处理。

                                    -

                                    在多数情况下，Vert.x使用被称为 Event Loop 的线程来调用您的处理器。

                                    -

                                    由于Vert.x或应用程序的代码块中没有阻塞，Event Loop 可以在事件到达时快速地分发到不同的处理器中。

                                    -

                                    由于没有阻塞，Event Loop 可在短时间内分发大量的事件。例如，一个单独的 Event Loop 可以非常迅速地处理数千个 HTTP 请求。

                                    -

                                    我们称之为 Reactor 模式（译者注：Reactor Pattern 翻译成了反应器模式）。

                                    -

                                    您之前也许听说过它，例如 Node.js 实现了这种模式。

                                    -

                                    在一个标准的反应器实现中，有 一个独立的 Event Loop 会循环执行，处理所有到达的事件并传递给处理器处理。

                                    -

                                    单一线程的问题在于它在任意时刻只能运行在一个核上。如果您希望单线程反应器应用（如您的 Node.js 应用）扩展到多核服务器上，则需要启动并且管理多个不同的进程。

                                    -

                                    Vert.x的工作方式有所不同。每个 Vertx 实例维护的是 多个Event Loop 线程。默认情况下，我们会根据机器上可用的核数量来设置 Event Loop 的数量，您亦可自行设置。

                                    -

                                    这意味着 Vertx 进程能够在您的服务器上扩展，与 Node.js 不同。

                                    -

                                    我们将这种模式称为 Multi-Reactor 模式（多反应器模式），区别于单线程的 Reactor 模式（反应器模式）。

                                    -
                                    -

                                    请注意：即使一个 Vertx 实例维护了多个 Event Loop，任何一个特定的处理器永远不会被并发执行。大部分情况下（除了 Worker Verticle 以外）它们总是在同一个 Event Loop 线程中被调用。

                                    -
                                    -

                                    黄金法则：不要阻塞Event Loop

                                    -

                                    尽管我们已经知道，Vert.x 的 API 都是非阻塞式的并且不会阻塞 Event Loop，但是这并不能帮您避免在您自己的处理器中阻塞 Event Loop 的情况发生。

                                    -

                                    如果这样做，该 Event Loop 在被阻塞时就不能做任何事情。如果您阻塞了 Vertx 实例中的所有 Event Loop，那么您的应用就会完全停止！

                                    -

                                    所以不要这样做！这是一个警告!

                                    -

                                    这些阻塞做法包括：

                                    -
                                      -
                                    • Thead.sleep()
                                      • -
                                    • 等待一个锁
                                      • -
                                    • 等待一个互斥信号或监视器（例如同步的代码块）
                                      • -
                                    • 执行一个长时间数据库操作并等待其结果
                                      • -
                                    • 执行一个复杂的计算，占用了可感知的时长
                                      • -
                                    • 在循环语句中长时间逗留
                                      • -
                                    -

                                    如果上述任何一种情况停止了 Event Loop 并占用了 显著执行时间，那您应该去罚站（译者注：原文此处为 Naughy Step，英国父母会在家里选择一个角落作为小孩罚站或静坐的地方，被称为 naughty corner 或 naughty step），等待下一步的指示。

                                    -

                                    所以，什么是 显著执行时间？

                                    -

                                    您要等多久？它取决于您的应用程序和所需的并发数量。

                                    -

                                    如果您只有单个 Event Loop，而且您希望每秒处理10000个 HTTP 请求，很明显的是每一个请求处理时间不可以超过0.1毫秒，所以您不能阻塞任何过多（大于0.1毫秒）的时间。

                                    -

                                    这个数学题并不难，将留给读者作为练习。

                                    -

                                    如果您的应用程序没有响应，可能这是一个迹象，表明您在某个地方阻塞了Event Loop。为了帮助您诊断类似问题，若 Vert.x 检测到 Event Loop 有一段时间没有响应，将会自动记录这种警告。若您在日志中看到类似警告，那么您需要检查您的代码。比如：

                                    -
                                    Thread vertx-eventloop-thread-3 has been blocked for 20458 ms
-

                                    Vert.x 还将提供堆栈跟踪，以精确定位发生阻塞的位置。

                                    -

                                    如果想关闭这些警告或更改设置，您可以在创建 Vertx 对象之前在 VertxOptions 中完成此操作。

                                    -

                                    运行阻塞式代码

                                    -

                                    在一个完美的世界中，不存在战争和饥饿，所有的API都将使用异步方式编写，兔兔和小羊羔将会在阳光明媚的绿色草地上手牵手地跳舞。

                                    -

                                    但是……真实世界并非如此（您最近看新闻了吧？）

                                    -

                                    事实是，很多，也非所有的库，特别是在JVM生态系统中有很多同步API，这些API中许多方法都是阻塞式的。一个很好的例子就是 JDBC API，它本质上是同步的，无论多么努力地去尝试，Vert.x都不能像魔法小精灵撒尘变法一样将它转换成异步API。

                                    -

                                    我们不会将所有的内容重写成异步方式，所以我们为您提供一种在 Vert.x 应用中安全调用"传统"阻塞API的方法。

                                    -

                                    如之前讨论，您不能在 Event Loop 中直接调用阻塞式操作，因为这样做会阻止 Event Loop 执行其他有用的任务。那您该怎么做？

                                    -

                                    可以通过调用 executeBlocking 方法来指定阻塞式代码的执行以及阻塞式代码执行后处理结果的异步回调。

                                    -
                                    vertx.executeBlocking(future -> {
-  // 调用一些需要耗费显著执行时间返回结果的阻塞式API
-  String result = someAPI.blockingMethod("hello");
-  future.complete(result);
-}, res -> {
-  System.out.println("The result is: " + res.result());
-});
-
                                    -

                                    默认情况下，如果 executeBlocking 在同一个上下文环境中（如：同一个 Verticle 实例）被调用了多次，那么这些不同的 executeBlocking 代码块会 顺序执行（一个接一个）。

                                    -

                                    若您不需要关心您调用 executeBlocking 的顺序，可以将 ordered 参数的值设为 false。这样任何 executeBlocking 都会在 Worker Pool 中并行执行。

                                    -

                                    另外一种运行阻塞式代码的方法是使用 Worker Verticle。

                                    -

                                    一个 Worker Verticle 始终会使用 Worker Pool 中的某个线程来执行。

                                    -

                                    默认的阻塞式代码会在 Vert.x 的 Worker Pool 中执行，通过 setWorkerPoolSize 配置。

                                    -

                                    可以为不同的用途创建不同的池：

                                    -
                                    WorkerExecutor executor = vertx.createSharedWorkerExecutor("my-worker-pool");
-executor.executeBlocking(future -> {
-  // 调用一些需要耗费显著执行时间返回结果的阻塞式API
-  String result = someAPI.blockingMethod("hello");
-  future.complete(result);
-}, res -> {
-  System.out.println("The result is: " + res.result());
-});
-
                                    -

                                    Worker Executor 在不需要的时候必须被关闭：

                                    -
                                    executor.close();
-
                                    -

                                    当使用同一个名字创建了许多 worker 时，它们将共享同一个 pool。当所有的 worker executor 调用了 close 方法被关闭过后，对应的 worker pool 会被销毁。

                                    -

                                    如果 Worker Executor 在 Verticle 中创建，那么 Verticle 实例销毁的同时 Vert.x 将会自动关闭这个 Worker Executor。

                                    -

                                    Worker Executor 可以在创建的时候配置：

                                    -
                                    int poolSize = 10;
-
-// 2分钟
-long maxExecuteTime = 120000;
-
-WorkerExecutor executor = vertx.createSharedWorkerExecutor("my-worker-pool", poolSize, maxExecuteTime);
-
                                    -
                                    -

                                    请注意：这个配置信息在 worker pool 创建的时候设置。

                                    -
                                    -

                                    异步协调

                                    -

                                    Vert.x 中的 Future 可以用来协调多个异步操作的结果。它支持并发组合（并行执行多个异步调用）和顺序组合（依次执行异步调用）。

                                    -
                                    -

                                    译者注：Vert.x 中的 Future 即异步开发模式中的 Future/Promise 模式的实现。

                                    -
                                    -

                                    并发合并

                                    -

                                    CompositeFuture.all 方法接受多个 Future 对象作为参数（最多6个，或者传入 List）。当所有的 Future 都成功完成，该方法将返回一个 成功的 Future；当任一个 Future 执行失败，则返回一个 失败的 Future：

                                    -
                                    Future<HttpServer> httpServerFuture = Future.future();
-httpServer.listen(httpServerFuture.completer());
-
-Future<NetServer> netServerFuture = Future.future();
-netServer.listen(netServerFuture.completer());
-
-CompositeFuture.all(httpServerFuture, netServerFuture).setHandler(ar -> {
-  if (ar.succeeded()) {
-    // 所有服务器启动完成
-  } else {
-    // 有一个服务器启动失败
-  }
-});
-
                                    -

                                    所有被合并的 Future 中的操作同时运行。当组合的处理操作完成时，该方法返回的 Future 上绑定的处理器（Handler）会被调用。当一个操作失败（其中的某一个 Future 的状态被标记成失败），则返回的 Future 会被标记为失败。当所有的操作都成功时，返回的 Future 将会成功完成。

                                    -

                                    您可以传入一个 Future 列表（可能为空）：

                                    -
                                    CompositeFuture.all(Arrays.asList(future1, future2, future3));
-
                                    -

                                    不同于 all 方法的合并会等待所有的 Future 成功执行（或任一失败），any 方法的合并会等待第一个成功执行的Future。CompositeFuture.any 方法接受多个 Future 作为参数（最多6个，或传入 List）。当任意一个 Future 成功得到结果，则该 Future 成功；当所有的 Future 都执行失败，则该 Future 失败。

                                    -
                                    CompositeFuture.any(future1, future2).setHandler(ar -> {
-  if (ar.succeeded()) {
-    // 至少一个成功
-  } else {
-    // 所有的都失败
-  }
-});
-
                                    -

                                    它也可使用 Future 列表传参：

                                    -
                                    CompositeFuture.any(Arrays.asList(f1, f2, f3));
-
                                    -

                                    join 方法的合并会等待所有的 Future 完成，无论成败。CompositeFuture.join 方法接受多个 Future 作为参数（最多6个），并将结果归并成一个 Future 。当全部 Future 成功执行完成，得到的 Future 是成功状态的；当至少一个 Future 执行失败时，得到的 Future 是失败状态的。

                                    -
                                    CompositeFuture.join(future1, future2, future3).setHandler(ar -> {
-  if (ar.succeeded()) {
-    // 所有都成功
-  } else {
-    // 至少一个失败
-  }
-});
-
                                    -

                                    它也可使用 Future 列表传参：

                                    -
                                    CompositeFuture.join(Arrays.asList(future1, future2, future3));
-
                                    -

                                    顺序合并

                                    -

                                    和 all 以及 any 实现的并发组合不同，compose 方法作用于顺序组合 Future。

                                    -
                                    FileSystem fs = vertx.fileSystem();
-Future<Void> startFuture = Future.future();
-
-Future<Void> fut1 = Future.future();
-fs.createFile("/foo", fut1.completer());
-
-fut1.compose(v -> {
-  // fut1中文件创建完成后执行
-  Future<Void> fut2 = Future.future();
-  fs.writeFile("/foo", Buffer.buffer(), fut2.completer());
-  return fut2;
-}).compose(v -> {
-  // fut2文件写入完成后执行
-  fs.move("/foo", "/bar", startFuture.completer());
-},
-  // 如果任何一步失败，将startFuture标记成failed
-  startFuture);
-
                                    -

                                    这里例子中，有三个操作被串起来了：

                                    -
                                      -
                                    1. 一个文件被创建（fut1）
                                      2. -
                                    2. 一些东西被写入到文件（fut2）
                                      3. -
                                    3. 文件被移走（startFuture）
                                      4. -
                                    -

                                    如果这三个步骤全部成功，则最终的 Future（startFuture）会是成功的；其中任何一步失败，则最终 Future 就是失败的。

                                    -

                                    例子中使用了：

                                    -
                                      -
                                    • compose(mapper)：当前 Future 完成时，执行相关代码，并返回 Future。当返回的 Future 完成时，组合完成。
                                      • -
                                    • compose(handler, next)：当前 Future 完成时，执行相关代码，并完成下一个 Future 的处理。
                                      • -
                                    -

                                    对于第二个例子，处理器需要完成 next future，以此来汇报处理成功或者失败。

                                    -

                                    您可以使用 completer 方法来串起一个带操作结果的或失败的 Future ，它可使您避免用传统方式编写代码：如果成功则完成 Future，否则就标记为失败。（译者注：3.4.0 以后不需要再使用 completer 方法）

                                    -

                                    Verticle

                                    -

                                    Vert.x 通过开箱即用的方式提供了一个简单便捷的、可扩展的、类似 Actor Model 的部署和并发模型机制。您可以用此模型机制来保管您自己的代码组件。

                                    -

                                    这个模型是可选的，如果您不想这样做，Vert.x 不会强迫您用这种方式创建您的应用程序。

                                    -

                                    这个模型不能说是严格的 Actor 模式的实现，但它确实有相似之处，特别是在并发、扩展性和部署等方面。

                                    -

                                    要使用该模型，您需要将您的代码组织成一系列的 Verticle。

                                    -

                                    Verticle 是由 Vert.x 部署和运行的代码块。默认情况一个 Vert.x 实例维护了N（默认情况下N = CPU核数 x 2）个 Event Loop 线程。Verticle 实例可使用任意 Vert.x 支持的编程语言编写，而且一个简单的应用程序也可以包含多种语言编写的 Verticle。

                                    -

                                    您可以将 Verticle 想成 Actor Model 中的 Actor。

                                    -

                                    一个应用程序通常是由在同一个 Vert.x 实例中同时运行的许多 Verticle 实例组合而成。不同的 Verticle 实例通过向 Event Bus 上发送消息来相互通信。

                                    -

                                    编写 Verticle

                                    -

                                    Verticle 的实现类必须实现 Verticle 接口。

                                    -

                                    如果您喜欢的话，可以直接实现该接口，但是通常直接从抽象类 AbstractVerticle 继承更简单。

                                    -

                                    这儿有一个例子：

                                    -
                                    public class MyVerticle extends AbstractVerticle {
-
-  // Called when verticle is deployed
-  // Verticle部署时调用
-  public void start() {
-  }
-
-  // Optional - called when verticle is undeployed
-  // 可选 - Verticle撤销时调用
-  public void stop() {
-  }
-
-}
-
                                    -

                                    通常您需要像上边例子一样重写 start 方法。

                                    -

                                    当 Vert.x 部署 Verticle 时，它的 start 方法将被调用，这个方法执行完成后 Verticle 就变成已启动状态。

                                    -

                                    您同样可以重写 stop 方法，当Vert.x 撤销一个 Verticle 时它会被调用，这个方法执行完成后 Verticle 就变成已停止状态了。

                                    -

                                    Verticle 异步启动和停止

                                    -

                                    有些时候您的 Verticle 启动会耗费一些时间，您想要在这个过程做一些事，并且您做的这些事并不想等到Verticle部署完成过后再发生。如：您想在 start 方法中部署其他的 Verticle。

                                    -

                                    您不能在您的 start 方法中阻塞等待其他的 Verticle 部署完成，这样做会破坏 黄金法则。

                                    -

                                    所以您要怎么做？

                                    -

                                    您可以实现 异步版本 的 start 方法来做这个事。这个版本的方法会以一个 Future 作参数被调用。方法执行完时，Verticle 实例并没有部署好（状态不是 deployed）。稍后，您完成了所有您需要做的事（如：启动其他Verticle），您就可以调用 Future 的 complete（或 fail ）方法来标记启动完成或失败了。

                                    -

                                    这儿有一个例子：

                                    -
                                    public class MyVerticle extends AbstractVerticle {
-
-  public void start(Future<Void> startFuture) {
-    // 现在部署其他的一些verticle
-    vertx.deployVerticle("com.foo.OtherVerticle", res -> {
-      if (res.succeeded()) {
-        startFuture.complete();
-      } else {
-        startFuture.fail(res.cause());
-      }
-    });
-  }
-}
-
                                    -

                                    同样的，这儿也有一个异步版本的 stop 方法，如果您想做一些耗时的 Verticle 清理工作，您可以使用它。

                                    -
                                    public class MyVerticle extends AbstractVerticle {
-
-  public void start() {
-    // 做一些事
-  }
-
-  public void stop(Future<Void> stopFuture) {
-    obj.doSomethingThatTakesTime(res -> {
-      if (res.succeeded()) {
-        stopFuture.complete();
-      } else {
-        stopFuture.fail();
-      }
-    });
-  }
-}
-
                                    -
                                    -

                                    请注意：您不需要在一个 Verticle 的 stop 方法中手工去撤销启动时部署的子 Verticle，当父 Verticle 在撤销时 Vert.x 会自动撤销任何子 Verticle。

                                    -
                                    -

                                    Verticle 种类

                                    -

                                    这儿有三种不同类型的 Verticle：

                                    -
                                      -
                                    • Stardand Verticle：这是最常用的一类 Verticle —— 它们永远运行在 Event Loop 线程上。稍后的章节我们会讨论更多。
                                      • -
                                    • Worker Verticle：这类 Verticle 会运行在 Worker Pool 中的线程上。一个实例绝对不会被多个线程同时执行。
                                      • -
                                    • Multi-Threaded Worker Verticle：这类 Verticle 也会运行在 Worker Pool 中的线程上。一个实例可以由多个线程同时执行（译者注：因此需要开发者自己确保线程安全）。
                                      • -
                                    -

                                    Standard Verticle

                                    -

                                    当 Standard Verticle 被创建时，它会被分派给一个 Event Loop 线程，并在这个 Event Loop 中执行它的 start 方法。当您在一个 Event Loop 上调用了 Core API 中的方法并传入了处理器时，Vert.x 将保证用与调用该方法时相同的 Event Loop 来执行这些处理器。

                                    -

                                    这意味着我们可以保证您的 Verticle 实例中 所有的代码都是在相同Event Loop中执行（只要您不创建自己的线程并调用它！）

                                    -

                                    同样意味着您可以将您的应用中的所有代码用单线程方式编写，让 Vert.x 去考虑线程和扩展问题。您不用再考虑 synchronized 和 volatile 的问题，也可以避免传统的多线程应用经常会遇到的竞态条件和死锁的问题。

                                    -

                                    Worker Verticle

                                    -

                                    Worker Verticle 和 Standard Verticle 很像，但它并不是由一个 Event Loop 来执行，而是由Vert.x中的 Worker Pool 中的线程执行。

                                    -

                                    Worker Verticle 被设计来调用阻塞式代码，它不会阻塞任何 Event Loop。

                                    -

                                    如果您不想使用 Worker Verticle 来运行阻塞式代码，您还可以在一个Event Loop中直接使用 内联阻塞式代码。

                                    -

                                    若您想要将 Verticle 部署成一个 Worker Verticle，您可以通过 setWorker 方法来设置：

                                    -
                                    DeploymentOptions options = new DeploymentOptions().setWorker(true);
-vertx.deployVerticle("com.mycompany.MyOrderProcessorVerticle", options);
-
                                    -

                                    Worker Verticle 实例绝对不会在 Vert.x 中被多个线程同时执行，但它可以在不同时间由不同线程执行。

                                    -

                                    Multi-threaded Worker Verticle

                                    -

                                    一个 Multi-threaded Worker Verticle 近似于普通的 Worker Verticle，但是它可以由不同的线程同时执行。

                                    -
                                    -

                                    警告：Multi-threaded Worker Verticle 是一个高级功能，大部分应用程序不会需要它。由于这些 Verticle 是并发的，您必须小心地使用标准的Java多线程技术来保持 Verticle 的状态一致性。

                                    -
                                    -

                                    编程方式部署Verticle

                                    -

                                    您可以指定一个 Verticle 名称或传入您已经创建好的 Verticle 实例，使用任意一个 deployVerticle 方法来部署Verticle。

                                    -
                                    -

                                    请注意：通过 Verticle 实例 来部署 Verticle 仅限Java语言。

                                    -
                                    -
                                    Verticle myVerticle = new MyVerticle();
-vertx.deployVerticle(myVerticle);
-
                                    -

                                    您同样可以指定 Verticle 的 名称 来部署它。

                                    -

                                    这个 Verticle 的名称会用于查找实例化 Verticle 的特定 VerticleFactory。

                                    -

                                    不同的 Verticle Factory 可用于实例化不同语言的 Verticle，也可用于其他目的，例如加载服务、运行时从Maven中获取Verticle实例等。

                                    -

                                    这允许您部署用任何使用Vert.x支持的语言编写的Verticle实例。

                                    -

                                    这儿有一个部署不同类型 Verticle 的例子：

                                    -
                                    vertx.deployVerticle("com.mycompany.MyOrderProcessorVerticle");
-
-// 部署JavaScript的Verticle
-vertx.deployVerticle("verticles/myverticle.js");
-
-// 部署Ruby的Verticle
-vertx.deployVerticle("verticles/my_verticle.rb");
-
                                    -

                                    Verticle名称到Factory的映射规则

                                    -

                                    当使用名称部署Verticle时，会通过名称来选择一个用于实例化 Verticle 的 Verticle Factory。

                                    -

                                    Verticle 名称可以有一个前缀 —— 使用字符串紧跟着一个冒号，它用于查找存在的Factory，参考例子。

                                    -
                                    js:foo.js // 使用JavaScript的Factory
-groovy:com.mycompany.SomeGroovyCompiledVerticle // 用Groovy的Factory
-service:com.mycompany:myorderservice // 用Service的Factory
-

                                    如果不指定前缀，Vert.x将根据提供名字后缀来查找对应Factory，如：

                                    -
                                    foo.js // 将使用JavaScript的Factory
-SomeScript.groovy // 将使用Groovy的Factory
-

                                    若前缀后缀都没指定，Vert.x将假定这个名字是一个Java 全限定类名（FQCN）然后尝试实例化它。

                                    -

                                    如何定位Verticle Factory？

                                    -

                                    大部分Verticle Factory会从 classpath 中加载，并在 Vert.x 启动时注册。

                                    -

                                    您同样可以使用编程的方式去注册或注销Verticle Factory：通过 registerVerticleFactory 方法和 unregisterVerticleFactory 方法。

                                    -

                                    等待部署完成

                                    -

                                    Verticle的部署是异步方式，可能在 deploy 方法调用返回后一段时间才会完成部署。

                                    -

                                    如果您想要在部署完成时被通知则可以指定一个完成处理器：

                                    -
                                    vertx.deployVerticle("com.mycompany.MyOrderProcessorVerticle", res -> {
-  if (res.succeeded()) {
-    System.out.println("Deployment id is: " + res.result());
-  } else {
-    System.out.println("Deployment failed!");
-  }
-});
-
                                    -

                                    如果部署成功，这个完成处理器的结果中将会包含部署ID的字符串。这个部署 ID可以在之后您想要撤销它时使用。

                                    -

                                    撤销Verticle

                                    -

                                    我们可以通过 undeploy 方法来撤销部署好的 Verticle。

                                    -

                                    撤销操作也是异步的，因此若您想要在撤销完成过后收到通知则可以指定另一个完成处理器：

                                    -
                                    vertx.undeploy(deploymentID, res -> {
-  if (res.succeeded()) {
-    System.out.println("Undeployed ok");
-  } else {
-    System.out.println("Undeploy failed!");
-  }
-});
-
                                    -

                                    设置 Verticle 实例数

                                    -

                                    当使用名称部署一个 Verticle 时，您可以指定您想要部署的 Verticle 实例的数量。

                                    -
                                    DeploymentOptions options = new DeploymentOptions().setInstances(16);
-vertx.deployVerticle("com.mycompany.MyOrderProcessorVerticle", options);
-
                                    -

                                    这个功能对于跨多核扩展时很有用。例如，您有一个实现了Web服务器的Verticle需要部署在多核的机器上，您可以部署多个实例来利用所有的核。

                                    -

                                    向 Verticle 传入配置

                                    -

                                    可在部署时传给 Verticle 一个 JSON 格式的配置

                                    -
                                    JsonObject config = new JsonObject().put("name", "tim").put("directory", "/blah");
-DeploymentOptions options = new DeploymentOptions().setConfig(config);
-vertx.deployVerticle("com.mycompany.MyOrderProcessorVerticle", options);
-
                                    -

                                    传入之后，这个配置可以通过 Context 对象或使用 config 方法访问。

                                    -

                                    这个配置会以 JSON 对象（JsonObject）的形式返回，因此您可以用下边代码读取数据：

                                    -
                                    System.out.println("Configuration: " + config().getString("name"));
-
                                    -

                                    在 Verticle 中访问环境变量

                                    -

                                    环境变量和系统属性可以直接通过 Java API 访问：

                                    -
                                    System.getProperty("prop");
-System.getenv("HOME");
-
                                    -

                                    Verticle 隔离组

                                    -

                                    默认情况，当Vert.x部署Verticle时它会调用当前类加载器来加载类，而不会创建一个新的。大多数情况下，这是最简单、最清晰和最干净。

                                    -

                                    但是在某些情况下，您可能需要部署一个Verticle，它包含的类要与应用程序中其他类隔离开来。比如您想要在一个Vert.x实例中部署两个同名不同版本的Verticle，或者不同的Verticle使用了同一个jar包的不同版本。

                                    -

                                    当使用隔离组时，您需要用 setIsolatedClassed 方法来提供一个您想隔离的类名列表。列表项可以是一个Java 限定类全名，如 com.mycompany.myproject.engine.MyClass；也可以是包含通配符的可匹配某个包或子包的任何类，例如 com.mycompany.myproject.* 将会匹配所有 com.mycompany.myproject 包或任意子包中的任意类名。

                                    -

                                    请注意仅仅只有匹配的类会被隔离，其他任意类会被当前类加载器加载。

                                    -

                                    若您想要加载的类和资源不存在于主类路径（main classpath），您可使用 setExtraClasspath 方法将额外的类路径添加到这里。

                                    -
                                    -

                                    警告：谨慎使用此功能，类加载器可能会导致您的应用难于调试，变得一团乱麻（can of worms）。

                                    -
                                    -

                                    以下是使用隔离组隔离 Verticle 的部署例子：

                                    -
                                    DeploymentOptions options = new DeploymentOptions().setIsolationGroup("mygroup");
-options.setIsolatedClasses(Arrays.asList("com.mycompany.myverticle.*",
-                   "com.mycompany.somepkg.SomeClass", "org.somelibrary.*"));
-vertx.deployVerticle("com.mycompany.myverticle.VerticleClass", options);
-
                                    -

                                    高可用性

                                    -

                                    Verticle可以启用高可用方式（HA）部署。在这种方式下，当其中一个部署在 Vert.x 实例中的 Verticle 突然挂掉，这个 Verticle 可以在集群环境中的另一个 Vert.x 实例中重新部署。

                                    -

                                    若要启用高可用方式运行一个 Verticle，仅需要追加 -ha 参数：

                                    -
                                    vertx run my-verticle.js -ha
-

                                    当启用高可用方式时，不需要追加 -cluster 参数。

                                    -

                                    关于高可用的功能和配置的更多细节可参考 高可用和故障转移 章节。

                                    -

                                    从命令行运行Verticle

                                    -

                                    您可以在 Maven 或 Gradle 项目中以正常方式添加 Vert.x Core 为依赖，在项目中直接使用 Vert.x。

                                    -

                                    但是，您也可以从命令行直接运行 Vert.x 的 Verticle。

                                    -

                                    为此，您需要下载并安装 Vert.x 的发行版，并且将安装的 bin 目录添加到您的 PATH 环境变量中，还要确保您的 PATH 中设置了Java 8的JDK环境。

                                    -
                                    -

                                    请注意：JDK需要支持Java代码的运行时编译（on the fly compilation）。

                                    -
                                    -

                                    现在您可以使用 vertx run 命令运行Verticle了，这儿是一些例子：

                                    -
                                    # 运行JavaScript的Verticle
-vertx run my_verticle.js
-
-# 运行Ruby的Verticle
-vertx run a_n_other_verticle.rb
-
-# 使用集群模式运行Groovy的Verticle
-vertx run FooVerticle.groovy -cluster
-

                                    您甚至可以不必编译 Java 源代码，直接运行它：

                                    -
                                    vertx run SomeJavaSourceFile.java
-

                                    Vert.x 将在运行它之前对 Java 源代码文件执行运行时编译，这对于快速原型制作和演示很有用。不需要设置 Maven 或 Gradle 就能跑起来！

                                    -

                                    欲了解有关在命令行执行 vertx 可用的各种选项完整信息，可以直接在命令行键入 vertx 查看帮助。

                                    -

                                    退出 Vert.x 环境

                                    -

                                    Vert.x 实例维护的线程不是守护线程，因此它们会阻止JVM退出。

                                    -

                                    如果您通过嵌入式的方式使用 Vert.x 并且完成了操作，您可以调用 close 方法关闭它。这将关闭所有内部线程池并关闭其他资源，允许JVM退出。

                                    -

                                    Context 对象

                                    -

                                    当 Vert.x 传递一个事件给处理器或者调用 Verticle 的 start 或 stop 方法时，它会关联一个 Context 对象来执行。通常来说这个 Context 会是一个 Event Loop Context，它绑定到了一个特定的 Event Loop 线程上。所以在该 Context 上执行的操作总是在同一个 Event Loop 线程中。对于运行内联的阻塞代码的 Worker Verticle 来说，会关联一个 Worker Context，并且所有的操作运都会运行在 Worker 线程池的线程上。

                                    -
                                    -

                                    译者注：每个 Verticle 在部署的时候都会被分配一个 Context（根据配置不同，可以是Event Loop Context 或者 Worker Context），之后此 Verticle 上所有的普通代码都会在此 Context 上执行（即对应的 Event Loop 或Worker 线程）。一个 Context 对应一个 Event Loop 线程（或 Worker 线程），但一个 Event Loop 可能对应多个 Context。

                                    -
                                    -

                                    您可以通过 getOrCreateContext 方法获取 Context 实例：

                                    -
                                    Context context = vertx.getOrCreateContext();
-
                                    -

                                    若已经有一个 Context 和当前线程关联，那么它直接重用这个 Context 对象，如果没有则创建一个新的。您可以检查获取的 Context 的类型：

                                    -
                                    Context context = vertx.getOrCreateContext();
-if (context.isEventLoopContext()) {
-  System.out.println("Context attached to Event Loop");
-} else if (context.isWorkerContext()) {
-  System.out.println("Context attached to Worker Thread");
-} else if (context.isMultiThreadedWorkerContext()) {
-  System.out.println("Context attached to Worker Thread - multi threaded worker");
-} else if (! Context.isOnVertxThread()) {
-  System.out.println("Context not attached to a thread managed by vert.x");
-}
-
                                    -

                                    当您获取了这个 Context 对象，您就可以在 Context 中异步执行代码了。换句话说，您提交的任务将会在同一个 Context 中运行：

                                    -
                                    vertx.getOrCreateContext().runOnContext(v -> {
-  System.out.println("This will be executed asynchronously in the same context");
-});
-
                                    -

                                    当在同一个 Context 中运行了多个处理函数时，可能需要在它们之间共享数据。 Context 对象提供了存储和读取共享数据的方法。举例来说，它允许您将数据传递到 runOnContext 方法运行的某些操作中：

                                    -
                                    final Context context = vertx.getOrCreateContext();
-context.put("data", "hello");
-context.runOnContext((v) -> {
-  String hello = context.get("data");
-});
-
                                    -

                                    您还可以通过 config 方法访问 Verticle 的配置信息。查看 向 Verticle 传入配置 章节了解更多配置信息。

                                    -

                                    执行周期性/延迟性操作

                                    -

                                    在 Vert.x 中，想要延迟之后执行或定期执行操作很常见。

                                    -

                                    在 Standard Verticle 中您不能直接让线程休眠以引入延迟，因为它会阻塞 Event Loop 线程。取而代之是使用 Vert.x 定时器。定时器可以是一次性或周期性的，两者我们都会讨论到。

                                    -

                                    一次性计时器

                                    -

                                    一次性计时器会在一定延迟后调用一个 Event Handler，以毫秒为单位计时。

                                    -

                                    您可以通过 setTimer 方法传递延迟时间和一个处理器来设置计时器的触发。

                                    -
                                    long timerID = vertx.setTimer(1000, id -> {
-  System.out.println("And one second later this is printed");
-});
-
-System.out.println("First this is printed");
-
                                    -

                                    返回值是一个唯一的计时器id，该id可用于之后取消该计时器，这个计时器id会传入给处理器。

                                    -

                                    周期性计时器

                                    -

                                    您同样可以使用 setPeriodic 方法设置一个周期性触发的计时器。第一次触发之前同样会有一段设置的延时时间。

                                    -

                                    setPeriodic 方法的返回值也是一个唯一的计时器id，若之后该计时器需要取消则使用该id。传给处理器的参数也是这个唯一的计时器id。

                                    -

                                    请记住这个计时器将会定期触发。如果您的定时任务会花费大量的时间，则您的计时器事件可能会连续执行甚至发生更坏的情况：重叠。这种情况，您应考虑使用 setTimer 方法，当任务执行完成时设置下一个计时器。

                                    -
                                    long timerID = vertx.setPeriodic(1000, id -> {
-  System.out.println("And every second this is printed");
-});
-
-System.out.println("First this is printed");
-
                                    -

                                    取消计时器

                                    -

                                    指定一个计时器id并调用 cancelTimer 方法来取消一个周期性计时器。如：

                                    -
                                    vertx.cancelTimer(timerID);
-
                                    -

                                    Verticle 中自动清除定时器

                                    -

                                    如果您在 Verticle 中创建了计时器，当这个 Verticle 被撤销时这个计时器会被自动关闭。

                                    -

                                    Verticle Worker Pool

                                    -

                                    Verticle 使用 Vert.x 中的 Worker Pool 来执行阻塞式行为，例如 executeBlocking 或 Worker Verticle。

                                    -

                                    可以在部署配置项中指定不同的Worker 线程池：

                                    -
                                    vertx.deployVerticle("the-verticle", new DeploymentOptions().setWorkerPoolName("the-specific-pool"));
-
                                    -

                                    Event Bus

                                    -

                                    Event Bus 是 Vert.x 的神经系统。

                                    -

                                    每一个 Vert.x 实例都有一个单独的 Event Bus 实例。您可以通过 Vertx 实例的 eventBus 方法来获得对应的 EventBus 实例。

                                    -

                                    您的应用中的不同部分通过 Event Bus 相互通信，无论它们使用哪一种语言实现，无论它们在同一个 Vert.x 实例中或在不同的 Vert.x 实例中。

                                    -

                                    甚至可以通过桥接的方式允许在浏览器中运行的客户端JavaScript在相同的Event Bus上相互通信。

                                    -

                                    Event Bus可形成跨越多个服务器节点和多个浏览器的点对点的分布式消息系统。

                                    -

                                    Event Bus支持发布/订阅、点对点、请求/响应的消息通信方式。

                                    -

                                    Event Bus的API很简单。基本上只涉及注册处理器、撤销处理器和发送和发布消息。

                                    -

                                    首先来看些基本概念和理论。

                                    -

                                    基本概念

                                    -

                                    寻址

                                    -

                                    消息会被 Event Bus 发送到一个 地址(address)。

                                    -

                                    同任何花哨的寻址方案相比，Vert.x的地址格式并不麻烦。Vert.x中的地址是一个简单的字符串，任意字符串都合法。当然，使用某种模式来命名仍然是明智的。如：使用点号来划分命名空间。

                                    -

                                    一些合法的地址形如：europe.news.feed1、acme.games.pacman、sausages和X。

                                    -

                                    处理器

                                    -

                                    消息在处理器（Handler）中被接收。您可以在某个地址上注册一个处理器来接收消息。

                                    -

                                    同一个地址可以注册许多不同的处理器，一个处理器也可以注册在多个不同的地址上。

                                    -

                                    发布/订阅消息

                                    -

                                    Event Bus支持 发布消息 功能。

                                    -

                                    消息将被发布到一个地址中，发布意味着会将信息传递给 所有 注册在该地址上的处理器。这和 发布/订阅模式 很类似。

                                    -

                                    点对点模式/请求-响应模式

                                    -

                                    Event Bus也支持 点对点消息模式。

                                    -

                                    消息将被发送到一个地址中，Vert.x将会把消息分发到某个注册在该地址上的处理器。若这个地址上有不止一个注册过的处理器，它将使用 不严格的轮询算法 选择其中一个。

                                    -

                                    点对点消息传递模式下，可在消息发送的时候指定一个应答处理器（可选）。

                                    -

                                    当接收者收到消息并且已经被处理时，它可以选择性决定回复该消息，若选择回复则绑定的应答处理器将会被调用。当发送者收到回复消息时，它也可以回复，这个过程可以不断重复。通过这种方式可以允许在两个不同的 Verticle 之间设置一个对话窗口。这种消息模式被称作 请求-响应 模式。

                                    -

                                    尽力传输

                                    -

                                    Vert.x会尽它最大努力去传递消息，并且不会主动丢弃消息。这种方式称为 尽力传输(Best-effort delivery)。

                                    -

                                    但是，当 Event Bus 中的全部或部分发生故障时，则可能会丢失消息。

                                    -

                                    若您的应用关心丢失的消息，您应该编写具有幂等性的处理器，并且您的发送者可以在恢复后重试。

                                    -
                                    -

                                    译者注：RPC通信通常情况下有三种语义：at least once、at most once 和 exactly once。不同语义情况下要考虑的情况不同。

                                    -
                                    -

                                    消息类型

                                    -

                                    Vert.x 默认允许任何基本/简单类型、String 或 Buffer 作为消息发送。不过在 Vert.x 中的通常做法是使用 JSON 格式来发送消息。

                                    -

                                    JSON 对于 Vert.x 支持的所有语言都是非常容易创建、读取和解析的，因此它已经成为了Vert.x中的通用语(lingua franca)。但是若您不想用 JSON，我们并不强制您使用它。

                                    -

                                    Event Bus 非常灵活，它支持在 Event Bus 中发送任意对象。您可以通过为您想要发送的对象自定义一个 MessageCodec 来实现。

                                    -

                                    Event Bus API

                                    -

                                    下面我们来看一下 API。

                                    -

                                    获取Event Bus

                                    -

                                    您可以通过下面的代码获取 Event Bus 的引用：

                                    -
                                    EventBus eb = vertx.eventBus();
-
                                    -

                                    对于每一个 Vert.x 实例来说它是单例的。

                                    -

                                    注册处理器

                                    -

                                    最简单的注册处理器的方式是使用 consumer 方法，这儿有个例子：

                                    -
                                    EventBus eb = vertx.eventBus();
-
-eb.consumer("news.uk.sport", message -> {
-  System.out.println("I have received a message: " + message.body());
-});
-
                                    -

                                    当一个消息达到您的处理器，该处理器会以 message 为参数被调用。

                                    -

                                    调用 consumer 方法会返回一个 MessageConsumer 对象。该对象随后可用于撤销处理器、或将处理器用作流式处理。

                                    -

                                    您也可以不设置处理器而使用 consumer 方法直接返回一个 MessageConsumer，之后再来设置处理器。如：

                                    -
                                    EventBus eb = vertx.eventBus();
-
-MessageConsumer<String> consumer = eb.consumer("news.uk.sport");
-consumer.handler(message -> {
-  System.out.println("I have received a message: " + message.body());
-});
-
                                    -

                                    在集群模式下的Event Bus上注册处理器时，注册信息会花费一些时间才能传播到集群中的所有节点。

                                    -

                                    若您希望在完成注册后收到通知，您可以在 MessageConsumer 对象上注册一个 completion handler。

                                    -
                                    consumer.completionHandler(res -> {
-  if (res.succeeded()) {
-    System.out.println("The handler registration has reached all nodes");
-  } else {
-    System.out.println("Registration failed!");
-  }
-});
-
                                    -

                                    注销处理器

                                    -

                                    您可以通过 unregister() 方法来注销处理器。

                                    -

                                    若您在集群模式下的 Event Bus 中撤销处理器，则同样会花费一些时间在节点中传播。若您想在完成后收到通知，可以使用unregister(handler) 方法注册处理器：

                                    -
                                    consumer.unregister(res -> {
-  if (res.succeeded()) {
-    System.out.println("The handler un-registration has reached all nodes");
-  } else {
-    System.out.println("Un-registration failed!");
-  }
-});
-
                                    -

                                    发布消息

                                    -

                                    发布消息很简单，只需使用 publish 方法指定一个地址去发布即可。

                                    -
                                    eventBus.publish("news.uk.sport", "Yay! Someone kicked a ball");
-
                                    -

                                    这个消息将会传递给所有在地址 news.uk.sport 上注册过的处理器。

                                    -

                                    发送消息

                                    -

                                    与发布消息的不同之处在于，发送(send)的消息只会传递给在该地址注册的其中一个处理器，这就是点对点模式。Vert.x 使用不严格的轮询算法来选择绑定的处理器。

                                    -

                                    您可以使用 send 方法来发送消息：

                                    -
                                    eventBus.send("news.uk.sport", "Yay! Someone kicked a ball");
-
                                    -

                                    设置消息头

                                    -

                                    在 Event Bus 上发送的消息可包含头信息。这可通过在发送或发布时提供的 DeliveryOptions 来指定。例如：

                                    -
                                    DeliveryOptions options = new DeliveryOptions();
-options.addHeader("some-header", "some-value");
-eventBus.send("news.uk.sport", "Yay! Someone kicked a ball", options);
-
                                    -

                                    消息顺序

                                    -

                                    Vert.x将按照特定发送者发送消息的顺序来传递消息给特定处理器。

                                    -

                                    消息对象

                                    -

                                    您在消息处理器中接收到的对象的类型是 Message。

                                    -

                                    消息的 body 对应发送或发布的对象。消息的头信息可以通过 headers 方法获取。

                                    -

                                    应答消息/发送回复

                                    -

                                    当使用 send 方法发送消息时，Event Bus会尝试将消息传递到注册在Event Bus上的 MessageConsumer中。在某些情况下，发送者需要知道消费者何时收到消息并 处理 了消息。

                                    -

                                    消费者可以通过调用 reply 方法来应答这个消息。

                                    -

                                    当这种情况发生时，它会将消息回复给发送者并且在发送者中调用应答处理器来处理回复的消息。

                                    -

                                    看这个例子会更清楚：

                                    -

                                    接收者：

                                    -
                                    MessageConsumer<String> consumer = eventBus.consumer("news.uk.sport");
-consumer.handler(message -> {
-  System.out.println("I have received a message: " + message.body());
-  message.reply("how interesting!");
-});
-
                                    -

                                    发送者：

                                    -
                                    eventBus.send("news.uk.sport", "Yay! Someone kicked a ball across a patch of grass", ar -> {
-  if (ar.succeeded()) {
-    System.out.println("Received reply: " + ar.result().body());
-  }
-});
-
                                    -

                                    在应答的消息体中可以包含有用的信息。

                                    -

                                    关于 处理中 的含义实际上是由应用程序来定义的。这完全取决于消费者如何执行，Event Bus 对此并不关心。

                                    -

                                    一些例子：

                                    -
                                      -
                                    • 一个简单地实现了返回当天时间的服务，在应答的消息里会包含当天时间信息。
                                      • -
                                    • 一个实现了持久化队列的消息消费者，当消息成功持久化到存储时，可以使用true来应答消息，或false表示失败。
                                      • -
                                    • 一个处理订单的消息消费者也许会用true确认这个订单已经成功处理并且可以从数据库中删除。
                                      • -
                                    -

                                    带超时的发送

                                    -

                                    当发送带有应答处理器的消息时，可以在 DeliveryOptions 中指定一个超时时间。如果在这个时间之内没有收到应答，则会以失败为参数调用应答处理器。默认超时是 30 秒。

                                    -

                                    发送失败

                                    -

                                    消息发送可能会因为其他原因失败，包括：

                                    -
                                      -
                                    • 没有可用的处理器来接收消息
                                      • -
                                    • 接收者调用了 fail 方法显式声明失败
                                      • -
                                    -

                                    发生这些情况时，应答处理器将会以这些失败为参数被调用。

                                    -

                                    消息编解码器

                                    -

                                    您可以在 Event Bus 中发送任何对象，只要你为这个对象类型注册一个编解码器 MessageCodec。消息编解码器有一个名称，您需要在发送或发布消息时通过 DeliveryOptions 来指定：

                                    -
                                    eventBus.registerCodec(myCodec);
-
-DeliveryOptions options = new DeliveryOptions().setCodecName(myCodec.name());
-
-eventBus.send("orders", new MyPOJO(), options);
-
                                    -

                                    若您总是希望某个类使用将特定的编解码器，那么您可以为这个类注册默认编解码器。这样您就不需要在每次发送的时候使用 DeliveryOptions 来指定了：

                                    -
                                    eventBus.registerDefaultCodec(MyPOJO.class, myCodec);
-
-eventBus.send("orders", new MyPOJO());
-
                                    -

                                    您可以通过 unregisterCodec 方法注销某个消息编解码器。

                                    -

                                    消息编解码器的编码和解码不一定使用同一个类型。例如您可以编写一个编解码器来发送 MyPOJO 类的对象，但是当消息发送给处理器后解码成 MyOtherPOJO 对象。

                                    -

                                    集群模式的 Event Bus

                                    -

                                    Event Bus 不仅仅存在于单个 Vert.x 实例中。通过您在网络上将不同的 Vert.x 实例集群在一起，它可以形成一个单一的、分布式的Event Bus。

                                    -

                                    通过代码的方式启用集群模式

                                    -

                                    若您用编程的方式创建 Vert.x 实例（Vertx），则可以通过将 Vert.x 实例配置成集群模式来获取集群模式的Event Bus：

                                    -
                                    VertxOptions options = new VertxOptions();
-Vertx.clusteredVertx(options, res -> {
-  if (res.succeeded()) {
-    Vertx vertx = res.result();
-    EventBus eventBus = vertx.eventBus();
-    System.out.println("We now have a clustered event bus: " + eventBus);
-  } else {
-    System.out.println("Failed: " + res.cause());
-  }
-});
-
                                    -

                                    您需要确在您的 classpath 中（或构建工具的依赖中）包含 ClusterManager 的实现类，如默认的 HazelcastClusterManager。

                                    -

                                    通过命令行启用集群模式

                                    -

                                    您可以通过以下命令以集群模式运行 Vert.x 应用：

                                    -
                                    vertx run my-verticle.js -cluster
-

                                    Verticle 中的自动清理

                                    -

                                    若您在 Verticle 中注册了 Event Bus 的处理器，那么这些处理器在 Verticle 被撤销的时候会自动被注销。

                                    -

                                    配置 Event Bus

                                    -

                                    Event Bus 是可以配置的，这对于以集群模式运行的 Event Bus 是非常有用的。Event Bus 使用 TCP 连接发送和接收消息，因此可以通过 EventBusOptions 对TCP连接进行全面的配置。由于 Event Bus 同时用作客户端和服务器，因此这些配置近似于 NetClientOptions 和 NetServerOptions。

                                    -
                                    VertxOptions options = new VertxOptions()
-    .setEventBusOptions(new EventBusOptions()
-        .setSsl(true)
-        .setKeyStoreOptions(new JksOptions().setPath("keystore.jks").setPassword("wibble"))
-        .setTrustStoreOptions(new JksOptions().setPath("keystore.jks").setPassword("wibble"))
-        .setClientAuth(ClientAuth.REQUIRED)
-    );
-
-Vertx.clusteredVertx(options, res -> {
-  if (res.succeeded()) {
-    Vertx vertx = res.result();
-    EventBus eventBus = vertx.eventBus();
-    System.out.println("We now have a clustered event bus: " + eventBus);
-  } else {
-    System.out.println("Failed: " + res.cause());
-  }
-});
-
                                    -

                                    上边代码段描述了如何在Event Bus中使用SSL连接替换传统的TCP连接。

                                    -
                                    -

                                    警告： 若要在集群模式下保证安全性，您 必须 将集群管理器配置成加密的或强制安全的。参考集群管理器的文档获取更多细节。

                                    -
                                    -

                                    Event Bus 的配置需要在所有集群节点中保持一致性。

                                    -

                                    EventBusOptions还允许您指定 Event Bus 是否运行在集群模式下，以及它的主机信息和端口。您可使用 setClustered、getClusterHost和 getClusterPort 方法来设置。

                                    -

                                    在容器中使用时，您也可以配置公共主机和端口号：

                                    -
                                    VertxOptions options = new VertxOptions()
-    .setEventBusOptions(new EventBusOptions()
-        .setClusterPublicHost("whatever")
-        .setClusterPublicPort(1234)
-    );
-
-Vertx.clusteredVertx(options, res -> {
-  if (res.succeeded()) {
-    Vertx vertx = res.result();
-    EventBus eventBus = vertx.eventBus();
-    System.out.println("We now have a clustered event bus: " + eventBus);
-  } else {
-    System.out.println("Failed: " + res.cause());
-  }
-});
-
                                    -

                                    JSON

                                    -

                                    和其他一些语言不同，Java 没有对 JSON 的原生支持（first class support），因此我们提供了两个类，以便在 Vert.x 应用中处理 JSON 更容易。

                                    -

                                    JSON 对象

                                    -

                                    JsonObject 类用来描述JSON对象。

                                    -

                                    一个JSON 对象基本上只是一个 Map 结构。它具有字符串的键，值可以是任意一种JSON 支持的类型（如 string, number, boolean）。

                                    -

                                    JSON 对象也支持 null 值。

                                    -

                                    创建 JSON 对象

                                    -

                                    可以使用默认构造函数创建空的JSON对象。

                                    -

                                    您可以通过一个 JSON 格式的字符串创建JSON对象：

                                    -
                                    String jsonString = "{\"foo\":\"bar\"}";
-JsonObject object = new JsonObject(jsonString);
-
                                    -

                                    您可以从通过一个Map创建JSON对象：

                                    -
                                    Map<String, Object> map = new HashMap<>();
-map.put("foo", "bar");
-map.put("xyz", 3);
-JsonObject object = new JsonObject(map);
-
                                    -

                                    将键值对放入 JSON 对象

                                    -

                                    使用put 方法可以将值放入到JSON对象里。

                                    -

                                    这个API是流式的，因此这个方法可以被链式地调用。

                                    -
                                    JsonObject object = new JsonObject();
-object.put("foo", "bar").put("num", 123).put("mybool", true);
-
                                    -

                                    从 JSON 对象获取值

                                    -

                                    您可使用 getXXX 方法从JSON对象中获取值。例如：

                                    -
                                    String val = jsonObject.getString("some-key");
-int intVal = jsonObject.getInteger("some-other-key");
-
                                    -

                                    JSON 对象和 Java 对象间的映射

                                    -

                                    您可以从 Java 对象的字段创建一个JSON 对象，如下所示：

                                    -

                                    你可以通过一个JSON 对象来实例化一个Java 对象并填充字段值。如下所示：

                                    -
                                    request.bodyHandler(buff -> {
-  JsonObject jsonObject = buff.toJsonObject();
-  User javaObject = jsonObject.mapTo(User.class);
-});
-
                                    -

                                    请注意上述代码直接使用了 Jackson 的 ObjectMapper#convertValue() 来执行映射。关于字段和构造函数的可见性的影响、对象引用的序列化和反序列化的问题等等可参考 Jackson 的文档获取更多信息。

                                    -

                                    在最简单的情况下，如果 Java 类中所有的字段都是 public（或者有 public 的 getter/setter）时，并且有一个 public 的默认构造函数（或不定义构造函数），mapFrom 和 mapTo 都应该成功。

                                    -

                                    只要不存在对象的循环引用，嵌套的 Java 对象可以被序列化/反序列化为嵌套的JSON对象。

                                    -

                                    将 JSON 对象编码成字符串

                                    -

                                    您可使用 encode 方法将一个对象编码成字符串格式。

                                    -
                                    -

                                    译者注：如要得到更优美、格式化的字符串，可以使用 encodePrettily 方法。

                                    -
                                    -

                                    JSON 数组

                                    -

                                    JsonArray 类用来描述 JSON数组。

                                    -

                                    一个JSON 数组是一个值的序列（值的类型可以是 string、number、boolean 等）。

                                    -

                                    JSON 数组同样可以包含 null 值。

                                    -

                                    创建 JSON 数组

                                    -

                                    可以使用默认构造函数创建空的JSON数组。

                                    -

                                    您可以从JSON格式的字符串创建一个JSON数组：

                                    -
                                    String jsonString = "[\"foo\",\"bar\"]";
-JsonArray array = new JsonArray(jsonString);
-
                                    -

                                    将数组项添加到JSON数组

                                    -

                                    您可以使用 add 方法添加数组项到JSON数组中：

                                    -
                                    JsonArray array = new JsonArray();
-array.add("foo").add(123).add(false);
-
                                    -

                                    从 JSON 数组中获取值

                                    -

                                    您可使用 getXXX 方法从JSON 数组中获取值。例如：

                                    -
                                    String val = array.getString(0);
-Integer intVal = array.getInteger(1);
-Boolean boolVal = array.getBoolean(2);
-
                                    -

                                    将 JSON 数组编码成字符串

                                    -

                                    您可使用 encode 将一个 JsonArray 编码成字符串格式。

                                    -

                                    Buffer

                                    -

                                    在 Vert.x 内部，大部分数据被重新组织（shuffle，表意为洗牌）成 Buffer 格式。

                                    -

                                    一个 Buffer 是可以读取或写入的0个或多个字节序列，并且根据需要可以自动扩容、将任意字节写入 Buffer。您也可以将 Buffer 想象成字节数组（译者注：类似于 JDK 中的 ByteBuffer）。

                                    -

                                    创建 Buffer

                                    -

                                    可以使用静态方法 Buffer.buffer 来创建 Buffer。

                                    -

                                    Buffer 可以从字符串或字节数组初始化，或者直接创建空的 Buffer。

                                    -

                                    这儿有一些创建 Buffer 的例子。

                                    -

                                    创建一个空的 Buffer：

                                    -
                                    Buffer buff = Buffer.buffer();
-
                                    -

                                    从字符串创建一个 Buffer，这个 Buffer 中的字符会以 UTF-8 格式编码：

                                    -
                                    Buffer buff = Buffer.buffer("some string");
-
                                    -

                                    从字符串创建一个 Buffer，这个字符串可以用指定的编码方式编码，例如：

                                    -
                                    Buffer buff = Buffer.buffer("some string", "UTF-16");
-
                                    -

                                    从字节数组 byte[] 创建 Buffer：

                                    -
                                    byte[] bytes = new byte[] {1, 3, 5};
-Buffer buff = Buffer.buffer(bytes);
-
                                    -

                                    创建一个指定初始大小的 Buffer。若您知道您的 Buffer 会写入一定量的数据，您可以创建 Buffer 并指定它的大小。这使得这个 Buffer 初始化时分配了更多的内存，比数据写入时重新调整大小的效率更高。注意以这种方式创建的 Buffer 是 空的。它不会创建一个填满了 0 的Buffer。代码如下：

                                    -
                                    Buffer buff = Buffer.buffer(10000);
-
                                    -

                                    向Buffer写入数据

                                    -

                                    向 Buffer 写入数据的方式有两种：追加和随机写入。任何一种情况下 Buffer 都会自动进行扩容，所以不可能在使用 Buffer 时遇到 IndexOutOfBoundsException。

                                    -

                                    追加到Buffer

                                    -

                                    您可以使用 appendXXX 方法追加数据到 Buffer。Buffer 类提供了追加各种不同类型数据的追加写入方法。

                                    -

                                    因为 appendXXX 方法的返回值就是 Buffer 自身，所以它可以链式地调用:

                                    -
                                    Buffer buff = Buffer.buffer();
-
-buff.appendInt(123).appendString("hello\n");
-
-socket.write(buff);
-
                                    -

                                    随机访问写Buffer

                                    -

                                    您还可以指定一个索引值，通过 setXXX 方法写入数据到 Buffer，它也存在各种不同数据类型的方法。所有的 set 方法都会将索引值作为第一个参数 —— 这表示 Buffer 中开始写入数据的位置。Buffer 始终根据需要进行自动扩容。

                                    -
                                    Buffer buff = Buffer.buffer();
-
-buff.setInt(1000, 123);
-buff.setString(0, "hello");
-
                                    -

                                    从Buffer中读取

                                    -

                                    可使用 getXXX 方法从 Buffer 中读取数据，它存在各种不同数据类型的方法，这些方法的第一个参数是从哪里获取数据的索引（获取位置）。

                                    -
                                    Buffer buff = Buffer.buffer();
-for (int i = 0; i < buff.length(); i += 4) {
-  System.out.println("int value at " + i + " is " + buff.getInt(i));
-}
-
                                    -

                                    使用无符号数

                                    -

                                    可使用 getUnsignedXXX、appendUnsignedXXX 和 setUnsignedXXX 方法将无符号数从 Buffer 中读取或追加/设置到 Buffer 里。这对以优化网络协议和最小化带宽消耗为目的实现的编解码器是很有用的。

                                    -

                                    下边例子中，值 200 被设置到了仅占用一个字节的特定位置：

                                    -
                                    Buffer buff = Buffer.buffer(128);
-int pos = 15;
-buff.setUnsignedByte(pos, (short) 200);
-System.out.println(buff.getUnsignedByte(pos));
-
                                    -

                                    控制台中显示 200。

                                    -

                                    Buffer长度

                                    -

                                    可使用 length 方法获取Buffer长度，Buffer的长度值是Buffer中包含的字节的最大索引 + 1。

                                    -

                                    拷贝Buffer

                                    -

                                    可使用 copy 方法创建一个Buffer的副本。

                                    -

                                    裁剪Buffer

                                    -

                                    裁剪得到的Buffer是基于原始Buffer的一个新的Buffer。它不会拷贝实际的数据。使用 slice 方法裁剪一个Buffer。

                                    -

                                    Buffer 重用

                                    -

                                    将Buffer写入到一个Socket或其他类似位置后，Buffer就不可被重用了。

                                    -

                                    编写 TCP 服务端和客户端

                                    -

                                    Vert.x允许您很容易编写非阻塞的TCP客户端和服务器。

                                    -

                                    创建 TCP 服务端

                                    -

                                    最简单地使用所有默认配置项创建 TCP 服务端的方式如下：

                                    -
                                    NetServer server = vertx.createNetServer();
-
                                    -

                                    配置 TCP 服务端

                                    -

                                    若您不想使用默认配置，可以在创建时通过传入一个 NetServerOptions 实例来配置服务器：

                                    -
                                    NetServerOptions options = new NetServerOptions().setPort(4321);
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    启动服务端监听

                                    -

                                    要告诉服务端监听传入的请求，您可以使用其中一个 listen 方法。

                                    -

                                    让服务器监听配置项指定的主机和端口：

                                    -
                                    NetServer server = vertx.createNetServer();
-server.listen();
-
                                    -

                                    或在调用 listen 方法时指定主机和端口号，忽略配置项中的配置：

                                    -
                                    NetServer server = vertx.createNetServer();
-server.listen(1234, "localhost");
-
                                    -

                                    默认主机名是 0.0.0.0，它表示：监听所有可用地址。默认端口号是 0，这也是一个特殊值，它告诉服务器随机选择并监听一个本地没有被占用的端口。

                                    -

                                    实际的绑定也是异步的，因此服务器在调用了 listen 方法的一段时间之后才会实际开始监听。若您希望在服务器实际监听时收到通知，您可以在调用 listen 方法时提供一个处理器。例如：

                                    -
                                    NetServer server = vertx.createNetServer();
-server.listen(1234, "localhost", res -> {
-  if (res.succeeded()) {
-    System.out.println("Server is now listening!");
-  } else {
-    System.out.println("Failed to bind!");
-  }
-});
-
                                    -

                                    监听随机端口

                                    -

                                    若设置监听端口为0，服务器将随机寻找一个没有使用的端口来监听。

                                    -

                                    可以调用 actualPort 方法来获得服务器实际监听的端口：

                                    -
                                    NetServer server = vertx.createNetServer();
-server.listen(0, "localhost", res -> {
-  if (res.succeeded()) {
-    System.out.println("Server is now listening on actual port: " + server.actualPort());
-  } else {
-    System.out.println("Failed to bind!");
-  }
-});
-
                                    -

                                    接收传入连接的通知

                                    -

                                    若您想要在连接创建完时收到通知，则需要设置一个 connectHandler：

                                    -
                                    NetServer server = vertx.createNetServer();
-server.connectHandler(socket -> {
-  // 在这里处理传入连接
-});
-
                                    -

                                    当连接成功时，您可以在回调函数中处理得到的 NetSocket 实例。这是一个代表了实际连接的套接字接口，它允许您读取和写入数据、以及执行各种其他操作，如关闭 Socket。

                                    -

                                    从Socket读取数据

                                    -

                                    您可以在Socket上调用 handler 方法来设置用于读取数据的处理器。

                                    -

                                    每次 Socket 接收到数据时，会以 Buffer 对象为参数调用处理器。

                                    -
                                    NetServer server = vertx.createNetServer();
-server.connectHandler(socket -> {
-  socket.handler(buffer -> {
-    System.out.println("I received some bytes: " + buffer.length());
-  });
-});
-
                                    -

                                    向Socket中写入数据

                                    -

                                    您可使用 write 方法写入数据到Socket：

                                    -
                                    Buffer buffer = Buffer.buffer().appendFloat(12.34f).appendInt(123);
-socket.write(buffer);
-
-// 以UTF-8的编码方式写入一个字符串
-socket.write("some data");
-
-// 以指定的编码方式写入一个字符串
-socket.write("some data", "UTF-16");
-
                                    -

                                    写入操作是异步的，可能调用 write 方法返回过后一段时间才会发生。

                                    -

                                    关闭处理器

                                    -

                                    若您想要在 Socket 关闭时收到通知，可以设置一个 closeHandler：

                                    -
                                    socket.closeHandler(v -> {
-  System.out.println("The socket has been closed");
-});
-
                                    -

                                    处理异常

                                    -

                                    您可以设置一个 exceptionHandler 用以在发生任何异常的时候接收异常信息。

                                    -

                                    Event Bus 写处理器

                                    -

                                    每个 Socket 会自动在Event Bus中注册一个处理器，当这个处理器中收到任意 Buffer 时，它会将数据写入到 Socket。

                                    -

                                    这意味着您可以通过向这个地址发送 Buffer 的方式，从不同的 Verticle 甚至是不同的 Vert.x 实例中向指定的 Socket 发送数据。

                                    -

                                    处理器的地址由 writeHandlerID 方法提供。

                                    -

                                    本地和远程地址

                                    -

                                    您可以通过 localAddress方法获取 NetSocket 的本地地址，通过 remoteAddress 方法获取 NetSocket 的远程地址（即连接的另一端的地址）。

                                    -

                                    发送文件或 Classpath 中的资源

                                    -

                                    您可以直接通过 sendFile 方法将文件和 classpath 中的资源写入Socket。这种做法是非常高效的，它可以被操作系统内核直接处理。

                                    -

                                    请阅读 从 Classpath 访问文件 章节了解类路径的限制或禁用它。

                                    -

                                    流式的Socket

                                    -

                                    NetSocket 接口继承了 ReadStream 和 WriteStream 接口，因此您可以将它套用（pump）到其他的读写流上。

                                    -

                                    有关更多信息，请参阅 流和管道 章节。

                                    -

                                    升级到 SSL/TLS 连接

                                    -

                                    一个非SSL/TLS连接可以通过upgradeToSsl方法升级到SSL/TLS连接。

                                    -

                                    必须为服务器或客户端配置SSL/TLS才能正常工作。请参阅SSL/TLS章节来获取详细信息。

                                    -

                                    关闭 TCP 服务端

                                    -

                                    您可以调用 close 方法关闭服务端。关闭操作将关闭所有打开的连接并释放所有服务端资源。

                                    -

                                    关闭操作也是异步的，可能直到方法调用返回过后一段时间才会实际关闭。若您想在实际关闭完成时收到通知，那么您可以传递一个处理器。

                                    -

                                    当关闭操作完成后，绑定的处理器将被调用：

                                    -
                                    server.close(res -> {
-  if (res.succeeded()) {
-    System.out.println("Server is now closed");
-  } else {
-    System.out.println("close failed");
-  }
-});
-
                                    -

                                    Verticle中的自动清理

                                    -

                                    若您在 Verticle 内创建了 TCP 服务端和客户端，它们将会在Verticle 撤销时自动被关闭。

                                    -

                                    扩展 - 共享 TCP 服务端

                                    -

                                    任意一个 TCP 服务端中的处理器总是在相同的 Event Loop 线程上执行。这意味着如果您在多核的服务器上运行，并且只部署了一个实例，那么您的服务器上最多只能使用一个核。

                                    -

                                    为了利用更多的服务器核，您将需要部署更多的服务器实例。您可以在代码中以编程方式实例化更多（Server的）实例：

                                    -
                                    for (int i = 0; i < 10; i++) {
-  NetServer server = vertx.createNetServer();
-  server.connectHandler(socket -> {
-    socket.handler(buffer -> {
-        //仅回传数据
-      socket.write(buffer);
-    });
-  });
-  server.listen(1234, "localhost");
-}
-
                                    -

                                    如果您使用的是 Verticle，您可以通过在命令行上使用 -instances 选项来简单部署更多的服务器实例：

                                    -
                                    vertx run com.mycompany.MyVerticle -instances 10
-

                                    或者使用编程方式部署您的 Verticle 时：

                                    -
                                    DeploymentOptions options = new DeploymentOptions().setInstances(10);
-vertx.deployVerticle("com.mycompany.MyVerticle", options);
-
                                    -

                                    一旦您这样做，您将发现echo服务器在功能上与之前相同，但是服务器上的所有核都可以被利用，并且可以处理更多的工作。

                                    -

                                    在这一点上，您可能会问自己：如何让多台服务器在同一主机和端口上侦听？尝试部署一个以上的实例时真的不会遇到端口冲突吗？

                                    -

                                    Vert.x在这里有一点魔法。

                                    -

                                    当您在与现有服务器相同的主机和端口上部署另一个服务器实例时，实际上它并不会尝试创建在同一主机/端口上侦听的新服务器实例。

                                    -

                                    相反，它内部仅仅维护一个服务器实例。当传入新的连接时，它以轮询的方式将其分发给任意一个连接处理器处理。

                                    -

                                    因此，Vert.x TCP 服务端可以水平扩展到多个核，并且每个实例保持单线程环境不变。

                                    -

                                    创建 TCP 客户端

                                    -

                                    使用所有默认选项创建 TCP 客户端的最简单方法如下：

                                    -
                                    NetClient client = vertx.createNetClient();
-
                                    -

                                    配置 TCP 客户端

                                    -

                                    如果您不想使用默认值，则可以在创建实例时传入 NetClientOptions 给客户端：

                                    -
                                    NetClientOptions options = new NetClientOptions().setConnectTimeout(10000);
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    创建连接

                                    -

                                    您可以使用 connect 方法创建到服务器的连接。请指定服务器的端口和主机，以及用于处理 NetSocket 的处理器。当连接成功或失败时处理器会被调用。

                                    -
                                    NetClientOptions options = new NetClientOptions().setConnectTimeout(10000);
-NetClient client = vertx.createNetClient(options);
-client.connect(4321, "localhost", res -> {
-  if (res.succeeded()) {
-    System.out.println("Connected!");
-    NetSocket socket = res.result();
-  } else {
-    System.out.println("Failed to connect: " + res.cause().getMessage());
-  }
-});
-
                                    -

                                    配置连接重试

                                    -

                                    可以将客户端配置为在无法连接的情况下自动重试。这是通过 setReconnectInterval 和 setReconnectAttempts 方法配置的。

                                    -
                                    -

                                    注意：目前如果连接失效，Vert.x将不尝试重新连接。重新连接尝试和时间间隔仅适用于创建初始连接。

                                    -
                                    -
                                    NetClientOptions options = new NetClientOptions().
-  setReconnectAttempts(10).
-  setReconnectInterval(500);
-
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    默认情况下，多个连接尝试是被禁用的。

                                    -

                                    记录网络活动

                                    -

                                    网络活动可以被记录下来，用于调试：

                                    -
                                    NetServerOptions options = new NetServerOptions().setLogActivity(true);
-
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    对于客户端：

                                    -
                                    NetClientOptions options = new NetClientOptions().setLogActivity(true);
-
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    Netty 使用 DEBUG 级别和 io.netty.handler.logging.LoggingHandler 名称来记录网络活动。使用网络活动记录时，需要注意以下几点：

                                    -
                                      -
                                    • 日志的记录是由Netty而不是Vert.x的日志来执行
                                      • -
                                    • 这个功能不能用于生产环境
                                      • -
                                    -

                                    您应该阅读 Netty 日志记录 章节来了解详细信息。

                                    -

                                    配置服务端和客户端以使用SSL/TLS

                                    -

                                    TCP 客户端和服务端可以通过配置来使用 TLS（传输层安全性协议）。早期版本的TLS被称为SSL。

                                    -

                                    无论是否使用SSL/TLS，服务器和客户端的API都是相同的。通过创建客户端/服务器时使用的 NetClientOptions / NetServerOptions 来启用TLS/SSL。

                                    -

                                    在服务端启用SSL/TLS

                                    -

                                    您需要设置 ssl 配置项来启用 SSL/TLS。默认是禁用的。

                                    -

                                    指定服务端的密钥/证书

                                    -

                                    SSL/TLS 服务端通常向客户端提供证书，以便验证服务端的身份。

                                    -

                                    可以通过以下几种方式为服务端配置证书/密钥：

                                    -

                                    第一种方法是指定包含证书和私钥的Java密钥库位置。可以使用 JDK 附带的 keytool 实用程序来管理Java密钥存储。

                                    -

                                    还应提供密钥存储的密码：

                                    -
                                    NetServerOptions options = new NetServerOptions().setSsl(true).setKeyStoreOptions(
-  new JksOptions().
-    setPath("/path/to/your/server-keystore.jks").
-    setPassword("password-of-your-keystore")
-);
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    或者，您可以自己读取密钥库到一个Buffer，并将它直接提供给 JksOptions：

                                    -
                                    Buffer myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/server-keystore.jks");
-JksOptions jksOptions = new JksOptions().
-  setValue(myKeyStoreAsABuffer).
-  setPassword("password-of-your-keystore");
-NetServerOptions options = new NetServerOptions().
-  setSsl(true).
-  setKeyStoreOptions(jksOptions);
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    PKCS＃12格式的密钥/证书（http://en.wikipedia.org/wiki/PKCS_12，通常为.pfx或.p12扩展名）也可以用与JKS密钥存储相似的方式加载：

                                    -
                                    NetServerOptions options = new NetServerOptions().setSsl(true).setPfxKeyCertOptions(
-  new PfxOptions().
-    setPath("/path/to/your/server-keystore.pfx").
-    setPassword("password-of-your-keystore")
-);
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    也支持通过 Buffer 来配置：

                                    -
                                    Buffer myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/server-keystore.pfx");
-PfxOptions pfxOptions = new PfxOptions().
-  setValue(myKeyStoreAsABuffer).
-  setPassword("password-of-your-keystore");
-NetServerOptions options = new NetServerOptions().
-  setSsl(true).
-  setPfxKeyCertOptions(pfxOptions);
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    另外一种分别提供服务器私钥和证书的方法是使用.pem文件。

                                    -
                                    NetServerOptions options = new NetServerOptions().setSsl(true).setPemKeyCertOptions(
-  new PemKeyCertOptions().
-    setKeyPath("/path/to/your/server-key.pem").
-    setCertPath("/path/to/your/server-cert.pem")
-);
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    也支持通过 Buffer 来配置：

                                    -
                                    Buffer myKeyAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/server-key.pem");
-Buffer myCertAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/server-cert.pem");
-PemKeyCertOptions pemOptions = new PemKeyCertOptions().
-  setKeyValue(myKeyAsABuffer).
-  setCertValue(myCertAsABuffer);
-NetServerOptions options = new NetServerOptions().
-  setSsl(true).
-  setPemKeyCertOptions(pemOptions);
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    请记住pem的配置和私钥是不加密的。

                                    -

                                    指定服务器信任

                                    -

                                    SSL/TLS 服务端可以使用证书颁发机构来验证客户端的身份。

                                    -

                                    证书颁发机构可通过多种方式为服务端配置。

                                    -

                                    可使用JDK随附的keytool实用程序来管理Java 受信存储。

                                    -

                                    还应提供受信存储的密码：

                                    -
                                    NetServerOptions options = new NetServerOptions().
-  setSsl(true).
-  setClientAuth(ClientAuth.REQUIRED).
-  setTrustStoreOptions(
-    new JksOptions().
-      setPath("/path/to/your/truststore.jks").
-      setPassword("password-of-your-truststore")
-  );
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    或者您可以自己读取受信存储到Buffer，并将它直接提供：

                                    -
                                    Buffer myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/truststore.jks");
-NetServerOptions options = new NetServerOptions().
-  setSsl(true).
-  setClientAuth(ClientAuth.REQUIRED).
-  setTrustStoreOptions(
-    new JksOptions().
-      setValue(myTrustStoreAsABuffer).
-      setPassword("password-of-your-truststore")
-  );
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    PKCS＃12格式的密钥/证书（http://en.wikipedia.org/wiki/PKCS_12，通常为.pfx或.p12扩展名）也可以用与JKS密钥存储相似的方式加载：

                                    -
                                    NetServerOptions options = new NetServerOptions().
-  setSsl(true).
-  setClientAuth(ClientAuth.REQUIRED).
-  setPfxTrustOptions(
-    new PfxOptions().
-      setPath("/path/to/your/truststore.pfx").
-      setPassword("password-of-your-truststore")
-  );
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    也支持通过 Buffer 来配置：

                                    -
                                    Buffer myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/truststore.pfx");
-NetServerOptions options = new NetServerOptions().
-  setSsl(true).
-  setClientAuth(ClientAuth.REQUIRED).
-  setPfxTrustOptions(
-    new PfxOptions().
-      setValue(myTrustStoreAsABuffer).
-      setPassword("password-of-your-truststore")
-  );
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    另一种提供服务器证书颁发机构的方法是使用一个 .pem 文件列表。

                                    -
                                    NetServerOptions options = new NetServerOptions().
-  setSsl(true).
-  setClientAuth(ClientAuth.REQUIRED).
-  setPemTrustOptions(
-    new PemTrustOptions().
-      addCertPath("/path/to/your/server-ca.pem")
-  );
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    也支持通过 Buffer 来配置：

                                    -
                                    Buffer myCaAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/server-ca.pfx");
-NetServerOptions options = new NetServerOptions().
-  setSsl(true).
-  setClientAuth(ClientAuth.REQUIRED).
-  setPemTrustOptions(
-    new PemTrustOptions().
-      addCertValue(myCaAsABuffer)
-  );
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    客户端启用SSL/TLS

                                    -

                                    客户端也可以轻松地配置为SSL。使用SSL和使用标准套接字具有完全相同的API。

                                    -

                                    若要启用 NetClient 上的SSL，可调用函数 setSSL(true)。

                                    -

                                    客户端受信配置

                                    -

                                    若客户端将 trustAll 设置为 true，则客户端将信任所有服务端证书。连接仍然会被加密，但这种模式很容易受到中间人攻击。即您无法确定您正连接到谁，请谨慎使用。默认值为false。

                                    -
                                    NetClientOptions options = new NetClientOptions().
-  setSsl(true).
-  setTrustAll(true);
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    若客户端没有设置trustAll，则必须配置客户端受信存储，并且受信客户端应该包含服务器的证书。

                                    -

                                    默认情况下，客户端禁用主机验证。要启用主机验证，请在客户端上设置使用的算法（目前仅支持HTTPS和LDAPS）：

                                    -
                                    NetClientOptions options = new NetClientOptions().
-  setSsl(true).
-  setHostnameVerificationAlgorithm("HTTPS");
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    和服务器配置相同，也可通过以下几种方式配置受信客户端：

                                    -

                                    第一种方法是指定包含证书颁发机构的Java受信库的位置。

                                    -

                                    它只是一个标准的Java密钥存储，与服务器端的密钥存储相同。通过在jsk options上使用path设置客户端受信存储位置。如果服务器在连接期间提供不在客户端受信存储中的证书，则尝试连接将不会成功。

                                    -
                                    NetClientOptions options = new NetClientOptions().
-  setSsl(true).
-  setTrustStoreOptions(
-    new JksOptions().
-      setPath("/path/to/your/truststore.jks").
-      setPassword("password-of-your-truststore")
-  );
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    它也支持Buffer的配置：

                                    -
                                    Buffer myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/truststore.jks");
-NetClientOptions options = new NetClientOptions().
-  setSsl(true).
-  setTrustStoreOptions(
-    new JksOptions().
-      setValue(myTrustStoreAsABuffer).
-      setPassword("password-of-your-truststore")
-  );
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    PKCS＃12格式的密钥/证书（http://en.wikipedia.org/wiki/PKCS_12，通常为.pfx或.p12扩展名）也可以用与JKS密钥存储相似的方式加载：

                                    -
                                    NetClientOptions options = new NetClientOptions().
-  setSsl(true).
-  setPfxTrustOptions(
-    new PfxOptions().
-      setPath("/path/to/your/truststore.pfx").
-      setPassword("password-of-your-truststore")
-  );
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    也支持通过 Buffer 来配置：

                                    -
                                    Buffer myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/truststore.pfx");
-NetClientOptions options = new NetClientOptions().
-  setSsl(true).
-  setPfxTrustOptions(
-    new PfxOptions().
-      setValue(myTrustStoreAsABuffer).
-      setPassword("password-of-your-truststore")
-  );
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    另一种提供服务器证书颁发机构的方法是使用一个.pem文件列表。

                                    -
                                    NetClientOptions options = new NetClientOptions().
-  setSsl(true).
-  setPemTrustOptions(
-    new PemTrustOptions().
-      addCertPath("/path/to/your/ca-cert.pem")
-  );
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    也支持通过 Buffer 来配置：

                                    -
                                    Buffer myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/ca-cert.pem");
-NetClientOptions options = new NetClientOptions().
-  setSsl(true).
-  setPemTrustOptions(
-    new PemTrustOptions().
-      addCertValue(myTrustStoreAsABuffer)
-  );
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    指定客户端的密钥/证书

                                    -

                                    如果服务器需要客户端认证，那么当连接时，客户端必须向服务器提供自己的证书。可通过以下几种方式配置客户端：

                                    -

                                    第一种方法是指定包含密钥和证书的Java 密钥库的位置，它只是一个常规的Java 密钥存储。使用jks options上的功能路径设置客户端密钥库位置。

                                    -
                                    NetClientOptions options = new NetClientOptions().setSsl(true).setKeyStoreOptions(
-  new JksOptions().
-    setPath("/path/to/your/client-keystore.jks").
-    setPassword("password-of-your-keystore")
-);
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    也支持通过 Buffer 来配置：

                                    -
                                    Buffer myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/client-keystore.jks");
-JksOptions jksOptions = new JksOptions().
-  setValue(myKeyStoreAsABuffer).
-  setPassword("password-of-your-keystore");
-NetClientOptions options = new NetClientOptions().
-  setSsl(true).
-  setKeyStoreOptions(jksOptions);
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    PKCS＃12格式的密钥/证书（http://en.wikipedia.org/wiki/PKCS_12，通常为.pfx或.p12扩展名）也可以用与JKS密钥存储相似的方式加载：

                                    -
                                    NetClientOptions options = new NetClientOptions().setSsl(true).setPfxKeyCertOptions(
-  new PfxOptions().
-    setPath("/path/to/your/client-keystore.pfx").
-    setPassword("password-of-your-keystore")
-);
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    也支持通过 Buffer 来配置：

                                    -
                                    Buffer myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/client-keystore.pfx");
-PfxOptions pfxOptions = new PfxOptions().
-  setValue(myKeyStoreAsABuffer).
-  setPassword("password-of-your-keystore");
-NetClientOptions options = new NetClientOptions().
-  setSsl(true).
-  setPfxKeyCertOptions(pfxOptions);
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    另一种单独提供服务器私钥和证书的方法是使用 .pem 文件。

                                    -
                                    NetClientOptions options = new NetClientOptions().setSsl(true).setPemKeyCertOptions(
-  new PemKeyCertOptions().
-    setKeyPath("/path/to/your/client-key.pem").
-    setCertPath("/path/to/your/client-cert.pem")
-);
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    也支持通过 Buffer 来配置：

                                    -
                                    Buffer myKeyAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/client-key.pem");
-Buffer myCertAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/client-cert.pem");
-PemKeyCertOptions pemOptions = new PemKeyCertOptions().
-  setKeyValue(myKeyAsABuffer).
-  setCertValue(myCertAsABuffer);
-NetClientOptions options = new NetClientOptions().
-  setSsl(true).
-  setPemKeyCertOptions(pemOptions);
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    请记住 pem 的配置和私钥是不加密的。

                                    -

                                    用于测试和开发目的的自签名证书

                                    -
                                    -

                                    提醒：不要在生产设置中使用，这里生成的密钥非常不安全。

                                    -
                                    -

                                    在运行单元/集成测试或是运行开发版的应用程序时都经常需要自签名证书。

                                    -

                                    SelfSignedCertificate 可用于提供自签名PEM证书，并可以提供 KeyCertOptions和 TrustOptions 配置：

                                    -
                                    SelfSignedCertificate certificate = SelfSignedCertificate.create();
-
-NetServerOptions serverOptions = new NetServerOptions()
-  .setSsl(true)
-  .setKeyCertOptions(certificate.keyCertOptions())
-  .setTrustOptions(certificate.trustOptions());
-
-NetServer server = vertx.createNetServer(serverOptions)
-  .connectHandler(socket -> socket.write("Hello!").end())
-  .listen(1234, "localhost");
-
-NetClientOptions clientOptions = new NetClientOptions()
-  .setSsl(true)
-  .setKeyCertOptions(certificate.keyCertOptions())
-  .setTrustOptions(certificate.trustOptions());
-
-NetClient client = vertx.createNetClient(clientOptions);
-client.connect(1234, "localhost", ar -> {
-  if (ar.succeeded()) {
-    ar.result().handler(buffer -> System.out.println(buffer));
-  } else {
-    System.err.println("Woops: " + ar.cause().getMessage());
-  }
-});
-
                                    -

                                    客户端也可配置为信任所有证书：

                                    -
                                    NetClientOptions clientOptions = new NetClientOptions()
-  .setSsl(true)
-  .setTrustAll(true);
-
                                    -

                                    自签名证书也适用于其他基于TCP的协议，如HTTPS：

                                    -
                                    SelfSignedCertificate certificate = SelfSignedCertificate.create();
-
-vertx.createHttpServer(new HttpServerOptions()
-  .setSsl(true)
-  .setKeyCertOptions(certificate.keyCertOptions())
-  .setTrustOptions(certificate.trustOptions()))
-  .requestHandler(req -> req.response().end("Hello!"))
-  .listen(8080);
-
                                    -

                                    待撤销证书颁发机构

                                    -

                                    可以通过配置证书吊销列表（CRL）来吊销不再被信任的证书机构。crlPath配置了使用的CRL：

                                    -
                                    NetClientOptions options = new NetClientOptions().
-  setSsl(true).
-  setTrustStoreOptions(trustOptions).
-  addCrlPath("/path/to/your/crl.pem");
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    也支持通过Buffer来配置：

                                    -
                                    Buffer myCrlAsABuffer = vertx.fileSystem().readFileBlocking("/path/to/your/crl.pem");
-NetClientOptions options = new NetClientOptions().
-  setSsl(true).
-  setTrustStoreOptions(trustOptions).
-  addCrlValue(myCrlAsABuffer);
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    配置密码套件

                                    -

                                    默认情况下，TLS配置将使用运行Vert.x的JVM 密码套件，该密码套件可以配置一套启用的密码：

                                    -
                                    NetServerOptions options = new NetServerOptions().
-  setSsl(true).
-  setKeyStoreOptions(keyStoreOptions).
-  addEnabledCipherSuite("ECDHE-RSA-AES128-GCM-SHA256").
-  addEnabledCipherSuite("ECDHE-ECDSA-AES128-GCM-SHA256").
-  addEnabledCipherSuite("ECDHE-RSA-AES256-GCM-SHA384").
-  addEnabledCipherSuite("CDHE-ECDSA-AES256-GCM-SHA384");
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    密码套件可在NetServerOptions或NetClientOptions配置项中指定。

                                    -

                                    配置TLS协议版本

                                    -

                                    默认情况下，TLS配置将使用以下协议版本：SSLv2Hello、TLSv1、TLSv1.1 和 TLSv1.2。 协议版本可以通过显式添加启用协议进行配置：

                                    -
                                    NetServerOptions options = new NetServerOptions().
-  setSsl(true).
-  setKeyStoreOptions(keyStoreOptions).
-  addEnabledSecureTransportProtocol("TLSv1.1").
-  addEnabledSecureTransportProtocol("TLSv1.2");
-NetServer server = vertx.createNetServer(options);
-
                                    -

                                    协议版本可在NetServerOptions或NetClientOptions配置项中指定。

                                    -

                                    SSL引擎

                                    -

                                    引擎实现可以配置为使用 OpenSSL 而不是JDK实现（来支持SSL）。 OpenSSL提供比JDK引擎更好的性能和CPU使用率、以及JDK版本独立性。

                                    -

                                    引擎选项可使用：

                                    - -
                                    NetServerOptions options = new NetServerOptions().
-  setSsl(true).
-  setKeyStoreOptions(keyStoreOptions);
-
-// Use JDK SSL engine explicitly
-// 显式使用JDK SSL引擎
-options = new NetServerOptions().
-  setSsl(true).
-  setKeyStoreOptions(keyStoreOptions).
-  setJdkSslEngineOptions(new JdkSSLEngineOptions());
-
-// Use OpenSSL engine
-// 使用OpenSSL引擎
-options = new NetServerOptions().
-  setSsl(true).
-  setKeyStoreOptions(keyStoreOptions).
-  setOpenSslEngineOptions(new OpenSSLEngineOptions());
-
                                    -

                                    应用层协议协商

                                    -

                                    ALPN(Application-Layer Protocol Negotiation)是应用层协议协商的TLS扩展，它被HTTP/2使用：在TLS握手期时，客户端给出其接受的应用协议列表，之后服务器使用它所支持的协议响应。

                                    -

                                    标准的Java 8不支持ALPN，所以ALPN应该通过其他方式启用：

                                    -
                                      -
                                    • OpenSSL支持
                                      • -
                                    • Jetty-ALPN支持
                                      • -
                                    -

                                    引擎选项可使用:

                                    - -

                                    OpenSSL ALPN支持

                                    -

                                    OpenSSL提供了原生的ALPN支持。

                                    -

                                    OpenSSL需要配置 setOpenSslEngineOptions 并在类路径上使用 netty-tcnative 的jar库。依赖于tcnative的实现它需要OpenSSL安装在您的操作系统中。

                                    -

                                    Jetty-ALPN支持

                                    -

                                    Jetty-ALPN是一个小型的jar，它覆盖了几种Java 8发行版用以支持ALPN。

                                    -

                                    JVM必须将 alpn-boot-${version}.jar 放在它的 boot classpath 中启动：

                                    -
                                    -Xbootclasspath/p:/path/to/alpn-boot${version}.jar
-

                                    其中 ${version} 取决于JVM的版本，如 OpenJDK 1.8.0u74 中的 8.1.7.v20160121。这个完整列表可以在 Jetty-ALPN 页面上找到。

                                    -

                                    这种方法主要缺点是ALPN的实现版本依赖于JVM的版本。为了解决这个问题，可以使用 Jetty ALPN agent。agent是一个JVM代理，它会为运行它的JVM选择正确的ALPN版本：

                                    -
                                    -javaagent:/path/to/alpn/agent
-

                                    客户端连接使用代理

                                    -

                                    NetClient 支持HTTP/1.x CONNECT、SOCKS4a 或 SOCKS5 代理。

                                    -

                                    代理可以在 NetClientOptions 内设置 ProxyOptions 来配置代理类型、主机名、端口、可选的用户名和密码。

                                    -

                                    以下是一个例子：

                                    -
                                    NetClientOptions options = new NetClientOptions()
-  .setProxyOptions(new ProxyOptions().setType(ProxyType.SOCKS5)
-    .setHost("localhost").setPort(1080)
-    .setUsername("username").setPassword("secret"));
-NetClient client = vertx.createNetClient(options);
-
                                    -

                                    DNS 解析总是在代理服务器上完成解析，为了实现 SOCKS4 客户端的功能，需要先在本地解析 DNS 地址。

                                    -

                                    编写 HTTP 服务端和客户端

                                    -

                                    Vert.x 允许您轻松编写非阻塞的 HTTP 客户端和服务端。

                                    -

                                    Vert.x 支持 HTTP/1.0、HTTP/1.1 和 HTTP/2 协议。

                                    -

                                    用于 HTTP 的基本 API 对 HTTP/1.x 和 HTTP/2 是相同的，特定的API功能也可用于处理 HTTP/2 协议。

                                    -

                                    创建 HTTP 服务端

                                    -

                                    使用所有默认选项创建 HTTP 服务端的最简单方法如下：

                                    -
                                    HttpServer server = vertx.createHttpServer();
-
                                    -

                                    配置 HTTP 服务端

                                    -

                                    若您不想用默认值，可以在创建服务器时传递一个 HttpServerOptions 实例给它：

                                    -
                                    HttpServerOptions options = new HttpServerOptions().setMaxWebsocketFrameSize(1000000);
-
-HttpServer server = vertx.createHttpServer(options);
-
                                    -

                                    配置 HTTP/2 服务端

                                    -

                                    Vert.x支持 TLS h2和TCP h2c之上的 HTTP/2 协议。

                                    -
                                      -
                                    • h2 表示使用了TLS的应用层协议协商(ALPN)协议来协商的 HTTP/2 协议
                                      • -
                                    • h2c 表示在TCP层上使用明文形式的 HTTP/2 协议，这样的连接是使用 HTTP/1.1升级 请求或者直接建立
                                      • -
                                    -

                                    要处理 h2 请求，你必须调用 setUseAlpn 方法来启用TLS：

                                    -
                                    HttpServerOptions options = new HttpServerOptions()
-    .setUseAlpn(true)
-    .setSsl(true)
-    .setKeyStoreOptions(new JksOptions().setPath("/path/to/my/keystore"));
-
-HttpServer server = vertx.createHttpServer(options);
-
                                    -

                                    ALPN是一个TLS的扩展，它在客户端和服务器开始交换数据之前协商协议。

                                    -

                                    不支持ALPN的客户端仍然可以执行经典的SSL握手。

                                    -

                                    通常情况，ALPN会对 h2 协议达成一致，尽管服务器或客户端决定了仍然使用 HTTP/1.1 协议。

                                    -

                                    要处理 h2c 请求，TLS必须被禁用，服务器将升级到 HTTP/2 以满足任何希望升级到 HTTP/2 的 HTTP/1.1 请求。它还将接受以 PRI*HTTP/2.0\r\nSM\r\n 开始的h2c直接连接。

                                    -
                                    -

                                    警告：大多数浏览器不支持 h2c，所以在建站时，您应该使用 h2 而不是 h2c。

                                    -
                                    -

                                    当服务器接受 HTTP/2 连接时，它会向客户端发送其初始设置。定义客户端如何使用连接，服务器的默认初始设置为：

                                    - -
                                    -

                                    请注意：Worker Verticle 和 HTTP/2 不兼容。

                                    -
                                    -

                                    记录服务端网络活动

                                    -

                                    为了进行调试，可记录网络活动。

                                    -
                                    HttpServerOptions options = new HttpServerOptions().setLogActivity(true);
-
-HttpServer server = vertx.createHttpServer(options);
-
                                    -

                                    详细说明请参阅 记录网络活动 章节。

                                    -

                                    开启服务端监听

                                    -

                                    要告诉服务器监听传入的请求，您可以使用其中一个 listen 方法。

                                    -

                                    在配置项中告诉服务器监听指定的主机和端口：

                                    -
                                    HttpServer server = vertx.createHttpServer();
-server.listen();
-
                                    -

                                    或在调用 listen 方法时指定主机和端口号，这样就忽略了配置项（中的主机和端口）：

                                    -
                                    HttpServer server = vertx.createHttpServer();
-server.listen(8080, "myhost.com");
-
                                    -

                                    默认主机名是0.0.0.0，它表示：监听所有可用地址；默认端口号是80。

                                    -

                                    实际的绑定也是异步的，因此服务器也许并没有在调用 listen 方法返回时监听，而是在一段时间过后才监听。

                                    -

                                    若您希望在服务器实际监听时收到通知，您可以向 listen 提供一个处理器。例如：

                                    -
                                    HttpServer server = vertx.createHttpServer();
-server.listen(8080, "myhost.com", res -> {
-  if (res.succeeded()) {
-    System.out.println("Server is now listening!");
-  } else {
-    System.out.println("Failed to bind!");
-  }
-});
-
                                    -

                                    收到传入请求的通知

                                    -

                                    若您需要在收到请求时收到通知，则需要设置一个 requestHandler：

                                    -
                                    HttpServer server = vertx.createHttpServer();
-server.requestHandler(request -> {
-  // 在这里处理请求
-});
-
                                    -

                                    处理请求

                                    -

                                    当请求到达时，Vert.x 会像对应的处理函数传入一个 HttpServerRequest 实例并调用请求处理函数，此对象表示服务端 HTTP 请求。当请求的头信息被完全读取时会调用该请求处理器。

                                    -

                                    如果请求包含请求体，那么该请求体将在请求处理器被调用后的某个时间到达服务器。

                                    -

                                    服务请求对象允许您检索 uri，path，params 和 headers 等其他信息。

                                    -

                                    每一个服务请求对象和一个服务响应对象绑定，您可以用 response 方法获取一个 HttpServerResponse 对象的引用。

                                    -

                                    这是服务器处理请求并回复 “hello world” 的简单示例。

                                    -
                                    vertx.createHttpServer().requestHandler(request -> {
-  request.response().end("Hello world");
-}).listen(8080);
-
                                    -

                                    请求版本

                                    -

                                    在请求中指定的 HTTP 版本可通过 version 方法获取。

                                    -

                                    请求方法

                                    -

                                    使用 method 方法读取请求中的 HTTP Method（即GET、POST、PUT、DELETE、HEAD、OPTIONS等）。

                                    -

                                    请求URI

                                    -

                                    使用 uri 方法读取请求中的URI路径。

                                    -

                                    请注意，这是在HTTP 请求中传递的实际URI，它总是一个相对的URI。

                                    -

                                    这个URI是在 Section 5.1.2 of the HTTP specification - Request-URI 中定义的。

                                    -

                                    请求路径

                                    -

                                    使用 path 方法读取URI中的路径部分。

                                    -

                                    例如，请求的URI为：

                                    -
                                    a/b/c/page.html?param1=abc&param2=xyz
-

                                    路径部分应该是：

                                    -
                                    /a/b/c/page.html
-

                                    请求查询

                                    -

                                    使用query读取URI中的查询部分。

                                    -

                                    例如，请求的URI为：

                                    -
                                    a/b/c/page.html?param1=abc&param2=xyz
-

                                    查询部分应该是：

                                    -
                                    param1=abc&param2=xyz
-

                                    请求头部

                                    -

                                    使用 headers 方法获取HTTP 请求中的请求头部信息。

                                    -

                                    这个方法返回一个 MultiMap 实例。它像一个普通的Map或Hash，并且它还允许同一个键支持多个值 —— 因为HTTP允许同一个键支持多个请求头的值。

                                    -

                                    它的键值不区分大小写，这意味着您可以执行以下操作：

                                    -
                                    MultiMap headers = request.headers();
-
-// Get the User-Agent:
-// 读取User-Agent
-System.out.println("User agent is " + headers.get("user-agent"));
-
-// You can also do this and get the same result:
-// 这样做可以得到和上边相同的结果
-System.out.println("User agent is " + headers.get("User-Agent"));
-
                                    -

                                    请求主机

                                    -

                                    使用 host 方法返回 HTTP 请求中的主机名。

                                    -

                                    对于 HTTP/1.x 请求返回请求头中的 host 值，对于 HTTP/1 请求则返回伪头中的:authority的值。

                                    -

                                    请求参数

                                    -

                                    您可以使用 params 方法返回HTTP请求中的参数信息。像 headers 方法一样它也会返回一个 MultiMap 实例，因为可以有多个具有相同名称的参数。

                                    -

                                    请求参数在请求URI的 path 部分之后，例如URI是：

                                    -
                                    /page.html?param1=abc&param2=xyz
-

                                    那么参数将包含以下内容：

                                    -
                                    param1: 'abc'
-param2: 'xyz'
-

                                    请注意，这些请求参数是从请求的 URI 中解析读取的，若您已经将表单属性存放在请求体中发送出去，并且该请求为 multi-part/form-data 类型请求，那么它们将不会显示在此处的参数中。

                                    -

                                    远程地址

                                    -

                                    可以使用 remoteAddress 方法读取请求发送者的地址。

                                    -

                                    绝对URI

                                    -

                                    HTTP 请求中传递的URI通常是相对的，若您想要读取请求中和相对URI对应的绝对URI，可调用 absoluteURI 方法。

                                    -

                                    结束处理器

                                    -

                                    当整个请求（包括任何正文）已经被完全读取时，请求中的 endHandler 方法会被调用。

                                    -

                                    请求体中读取数据

                                    -

                                    HTTP请求通常包含我们需要读取的主体。如前所述，当请求头部达到时，请求处理器会被调用，因此请求对象在此时没有请求体。

                                    -

                                    这是因为请求体可能非常大（如文件上传），并且我们不会在内容发送给您之前将其全部缓冲存储在内存中，这可能会导致服务器耗尽可用内存。

                                    -

                                    要接收请求体，您可在请求中调用 handler 方法设置一个处理器，每次请求体的一小块数据收到时，该处理器都会被调用。以下是一个例子：

                                    -
                                    request.handler(buffer -> {
-  System.out.println("I have received a chunk of the body of length " + buffer.length());
-});
-
                                    -

                                    传递给处理器的对象是一个 Buffer，当数据从网络到达时，处理器可以多次被调用，这取决于请求体的大小。

                                    -

                                    在某些情况下（例：若请求体很小），您将需要将这个请求体聚合到内存中，以便您可以按照下边的方式进行聚合：

                                    -
                                    Buffer totalBuffer = Buffer.buffer();
-
-request.handler(buffer -> {
-  System.out.println("I have received a chunk of the body of length " + buffer.length());
-  totalBuffer.appendBuffer(buffer);
-});
-
-request.endHandler(v -> {
-  System.out.println("Full body received, length = " + totalBuffer.length());
-});
-
                                    -

                                    这是一个常见的情况，Vert.x为您提供了一个 bodyHandler 方法来执行此操作。当所有请求体被收到时，bodyHandler 绑定的处理器会被调用一次：

                                    -
                                    request.bodyHandler(totalBuffer -> {
-  System.out.println("Full body received, length = " + totalBuffer.length());
-});
-
                                    -

                                    Pumping 请求

                                    -

                                    请求对象实现了 ReadStream 接口，因此您可以将请求体读取到任何 WriteStream 实例中。

                                    -

                                    详细请参阅 流和管道 章节。

                                    -

                                    处理 HTML 表单

                                    -

                                    您可使用 application/x-www-form-urlencoded 或 multipart/form-data 这两种 content-type 来提交 HTML 表单。

                                    -

                                    对于使用 URL 编码过的表单，表单属性会被编码在URL中，如同普通查询参数一样。

                                    -

                                    对于 multipart 类型的表单，它会被编码在请求体中，而且在整个请求体被完全读取之前它是不可用的。Multipart 表单还可以包含文件上传。

                                    -

                                    若您想要读取 multipart 表单的属性，您应该告诉 Vert.x 您会在读取任何正文 之前 调用 setExpectMultipart(true) 方法，然后在整个请求体都被读取后，您可以使用 formAttributes 方法来读取实际的表单属性。

                                    -
                                    server.requestHandler(request -> {
-  request.setExpectMultipart(true);
-  request.endHandler(v -> {
-    // 请求体被完全读取，所以直接读取表单属性
-    MultiMap formAttributes = request.formAttributes();
-  });
-});
-
                                    -

                                    处理文件上传

                                    -

                                    Vert.x 可以处理以 multipart 编码形式上传的的文件。

                                    -

                                    要接收文件，您可以告诉 Vert.x 使用 multipart 表单，并对请求设置 uploadHandler。

                                    -

                                    当服务器每次接收到上传请求时，该处理器将被调用一次。

                                    -

                                    传递给处理器的对象是一个 HttpServerFileUpload 实例。

                                    -
                                    server.requestHandler(request -> {
-  request.setExpectMultipart(true);
-  request.uploadHandler(upload -> {
-    System.out.println("Got a file upload " + upload.name());
-  });
-});
-
                                    -

                                    上传的文件可能很大，我们不会在单个缓冲区中包含整个上传的数据，因为这样会导致内存耗尽。相反，上传数据是以块的形式被接收的：

                                    -
                                    request.uploadHandler(upload -> {
-  upload.handler(chunk -> {
-    System.out.println("Received a chunk of the upload of length " + chunk.length());
-  });
-});
-
                                    -

                                    上传对象实现了 ReadStream 接口，因此您可以将请求体读取到任何 WriteStream 实例中。详细说明请参阅 流和管道（泵） 章节。

                                    -

                                    若您只是想将文件上传到服务器的某个磁盘，可以使用 streamToFileSystem 方法：

                                    -
                                    request.uploadHandler(upload -> {
-  upload.streamToFileSystem("myuploads_directory/" + upload.filename());
-});
-
                                    -
                                    -

                                    警告：确保您检查了生产系统的文件名，以避免恶意客户将文件上传到文件系统中的任意位置。有关详细信息，参阅 安全说明。

                                    -
                                    -

                                    处理压缩体

                                    -

                                    Vert.x 可以处理在客户端通过 deflate 或 gzip 算法压缩过的请求体信息。

                                    -

                                    若要启用解压缩功能则您要在创建服务器时调用 setDecompressionSupported 方法设置配置项。默认情况下解压缩是被禁用的。

                                    -

                                    接收自定义 HTTP/2 帧

                                    -

                                    HTTP/2 是用于 HTTP 请求/响应模型的包含各种帧的一种帧协议，该协议允许发送和接收其他类型的帧。

                                    -

                                    若要接收自定义帧(frame)，您可以在请求中使用 customFrameHandler，每次当自定义的帧数据到达时，这个处理器会被调用。这而是一个例子：

                                    -
                                    request.customFrameHandler(frame -> {
-  System.out.println("Received a frame type=" + frame.type() +
-      " payload" + frame.payload().toString());
-});
-
                                    -

                                    HTTP/2 帧不受流量控制限制 —— 当接收到自定义帧时，不论请求是否暂停，自定义帧处理器都将立即被调用。

                                    -

                                    非标准的 HTTP 方法

                                    -

                                    OTHER HTTP 方法可用于非标准方法，在这种情况下，rawMethod 方法返回客户端发送的实际 HTTP 方法。

                                    -

                                    发回响应

                                    -

                                    服务器响应对象是一个 HttpServerResponse 实例，它可以从 request 对应的 response 方法中读取。

                                    -

                                    您可以使用响应对象回写一个响应到 HTTP客户端。

                                    -

                                    设置状态码和消息

                                    -

                                    默认的 HTTP 状态响应码为 200，表示 OK。

                                    -

                                    可使用 setStatusCode 方法设置不同状态代码。

                                    -

                                    您还可用 setStatusMessage 方法指定自定义状态消息。

                                    -

                                    若您不指定状态信息，将会使用默认的状态码响应。

                                    -
                                    -

                                    注意：对于 HTTP/2 中的状态不会在响应中描述 —— 因为协议不会将消息发送回客户端。

                                    -
                                    -

                                    向 HTTP 响应写入数据

                                    -

                                    想要将数据写入 HTTP Response，您可使用任意一个 write 方法。

                                    -

                                    它们可以在响应结束之前被多次调用，它们可以通过以下几种方式调用：

                                    -

                                    对用单个缓冲区：

                                    -
                                    HttpServerResponse response = request.response();
-response.write(buffer);
-
                                    -

                                    写入字符串，这种请求字符串将使用 UTF-8 进行编码，并将结果写入到报文中。

                                    -
                                    HttpServerResponse response = request.response();
-response.write("hello world!");
-
                                    -

                                    写入带编码方式的字符串，这种情况字符串将使用指定的编码方式编码，并将结果写入到报文中。

                                    -
                                    HttpServerResponse response = request.response();
-response.write("hello world!", "UTF-16");
-
                                    -

                                    响应写入是异步的，并且在写操作进入队列之后会立即返回。

                                    -

                                    若您只需要将单个字符串或 Buffer 写入到HTTP 响应，则可使用 end 方法将其直接写入响应中并发回到客户端。

                                    -

                                    第一次写入操作会触发响应头的写入，因此，若您不使用HTTP 分块，那么必须在写入响应之前设置 Content-Length 头，否则会太迟。若您使用 HTTP 分块则不需要担心这点。

                                    -

                                    完成 HTTP 响应

                                    -

                                    一旦您完成了 HTTP 响应，可调用 end 将其发回客户端。

                                    -

                                    这可以通过几种方式完成：

                                    -

                                    没有参数，直接结束响应，发回客户端：

                                    -
                                    HttpServerResponse response = request.response();
-response.write("hello world!");
-response.end();
-
                                    -

                                    您也可以和调用write方法一样传 String 或 Buffer 给 end 方法。这种情况，它和先调用带 String 或 Buffer 参数的 write 方法，之后调用无参 end 方法一样。例如：

                                    -
                                    HttpServerResponse response = request.response();
-response.end("hello world!");
-
                                    -

                                    关闭底层连接

                                    -

                                    您可以调用 close 方法关闭底层的TCP 连接。

                                    -

                                    当响应结束时，Vert.x 将自动关闭非 keep-alive 的连接。

                                    -

                                    默认情况下，Vert.x 不会自动关闭 keep-alive 的连接，若您想要在一段空闲时间之后让 Vert.x 自动关闭 keep-alive 的连接，则使用setIdleTimeout 方法进行配置。

                                    -

                                    HTTP/2 连接在关闭响应之前会发送 GOAWAY 帧。

                                    -

                                    设置响应头

                                    -

                                    HTTP 响应头可直接添加到 HTTP 响应中，通常直接操作 headers：

                                    -
                                    HttpServerResponse response = request.response();
-MultiMap headers = response.headers();
-headers.set("content-type", "text/html");
-headers.set("other-header", "wibble");
-
                                    -

                                    或您可使用 putHeader 方法：

                                    -
                                    HttpServerResponse response = request.response();
-response.putHeader("content-type", "text/html").putHeader("other-header", "wibble");
-
                                    -

                                    响应头必须在写入响应正文消息之前进行设置。

                                    -

                                    分块 HTTP 响应和附加尾部

                                    -

                                    Vert.x 支持 分块传输编码(HTTP Chunked Transfer Encoding)。

                                    -

                                    这允许HTTP 响应体以块的形式写入，通常在响应体预先不知道尺寸、需要将很大响应正文以流式传输到客户端时使用。

                                    -

                                    您可以通过如下方式开启分块模式：

                                    -
                                    HttpServerResponse response = request.response();
-response.setChunked(true);
-
                                    -

                                    默认是不分块的，当处于分块模式，每次调用任意一个 write 方法将导致新的 HTTP 块被写出。

                                    -

                                    在分块模式下，您还可以将响应的HTTP 响应附加尾部(trailers)写入响应，这种方式实际上是在写入响应的最后一块。

                                    -
                                    -

                                    注意：分块响应在 HTTP/2 流中无效。

                                    -
                                    -

                                    若要向响应添加尾部，则直接添加到 trailers 里。

                                    -
                                    HttpServerResponse response = request.response();
-response.setChunked(true);
-MultiMap trailers = response.trailers();
-trailers.set("X-wibble", "woobble").set("X-quux", "flooble");
-
                                    -

                                    或者调用 putTrailer 方法：

                                    -
                                    HttpServerResponse response = request.response();
-response.setChunked(true);
-response.putTrailer("X-wibble", "woobble").putTrailer("X-quux", "flooble");
-
                                    -

                                    直接从磁盘或 Classpath 读文件

                                    -

                                    若您正在编写一个Web 服务端，一种从磁盘中读取并提供文件的方法是将文件作为 AsyncFile 对象打开并其传送到HTTP 响应中。

                                    -

                                    或您可以使用 readFile 方法一次性加载它，并直接将其写入响应。

                                    -

                                    或者，Vert.x 提供了一种方法，允许您在一个操作中将文件从磁盘或文件系统中读取并提供给HTTP 响应。若底层操作系统支持，这会导致操作系统不通过用户空间复制而直接将文件内容中字节数据从文件传输到Socket。这是使用 sendFile 方法完成的，对于大文件处理通常更有效，而这个方法对于小文件可能很慢。

                                    -

                                    这儿是一个非常简单的 Web 服务器，它使用 sendFile 方法从文件系统中读取并提供文件：

                                    -
                                    vertx.createHttpServer().requestHandler(request -> {
-  String file = "";
-  if (request.path().equals("/")) {
-    file = "index.html";
-  } else if (!request.path().contains("..")) {
-    file = request.path();
-  }
-  request.response().sendFile("web/" + file);
-}).listen(8080);
-
                                    -

                                    发送文件是异步的，可能在调用返回一段时间后才能完成。如果要在文件写入时收到通知，可以在 sendFile 方法中设置一个处理器。

                                    -

                                    请阅读 从 Classpath 访问文件 章节了解类路径的限制或禁用它。

                                    -
                                    -

                                    注意：若在 HTTPS 协议中使用 sendFile 方法，它将会通过用户空间进行复制，因为若内核将数据直接从磁盘复制到 Socket，则不会给我们任何加密的机会。

                                    -

                                    警告：若您要直接使用 Vert.x 编写 Web 服务器，请注意，您想提供文件和类路径之外访问的位置 —— 用户是无法直接利用路径访问的。更安全的做法是使用Vert.x Web替代。

                                    -
                                    -

                                    当需要提供文件的一部分，从给定的字节开始，您可以像下边这样做：

                                    -
                                    vertx.createHttpServer().requestHandler(request -> {
-  long offset = 0;
-  try {
-    offset = Long.parseLong(request.getParam("start"));
-  } catch (NumberFormatException e) {
-    // 异常处理
-  }
-
-  long end = Long.MAX_VALUE;
-  try {
-    end = Long.parseLong(request.getParam("end"));
-  } catch (NumberFormatException e) {
-    // 异常处理
-  }
-
-  request.response().sendFile("web/mybigfile.txt", offset, end);
-}).listen(8080);
-
                                    -

                                    若您想要从偏移量开始发送文件直到尾部，则不需要提供长度信息，这种情况下，您可以执行以下操作：

                                    -
                                    vertx.createHttpServer().requestHandler(request -> {
-  long offset = 0;
-  try {
-    offset = Long.parseLong(request.getParam("start"));
-  } catch (NumberFormatException e) {
-    //异常处理
-  }
-
-  request.response().sendFile("web/mybigfile.txt", offset);
-}).listen(8080);
-
                                    -

                                    Pumping 响应

                                    -

                                    服务端响应 HttpServerResponse 也是一个 WriteStream 实例，因此您可以从任何 ReadStream 向其泵送数据，如 AsyncFile、NetSocket、WebSocket 或 HttpServerRequest。

                                    -

                                    这儿有一个例子，它回应了任何 PUT 方法的响应中的请求体，它为请求体使用了 Pump，所以即使 HTTP 请求体很大并填满了内存，任何时候它依旧会工作：

                                    -
                                    vertx.createHttpServer().requestHandler(request -> {
-  HttpServerResponse response = request.response();
-  if (request.method() == HttpMethod.PUT) {
-    response.setChunked(true);
-    Pump.pump(request, response).start();
-    request.endHandler(v -> response.end());
-  } else {
-    response.setStatusCode(400).end();
-  }
-}).listen(8080);
-
                                    -

                                    写入 HTTP/2 帧

                                    -

                                    HTTP/2 是用于 HTTP 请求/响应模型的包含各种帧的一种帧协议，该协议允许发送和接收其他类型的帧。

                                    -

                                    要发送这样的帧，您可以在响应中使用 writeCustomFrame 方法，以下是一个例子：

                                    -
                                    int frameType = 40;
-int frameStatus = 10;
-Buffer payload = Buffer.buffer("some data");
-
-// 向客户端发送一帧
-response.writeCustomFrame(frameType, frameStatus, payload);
-
                                    -

                                    这些帧被立即发送，并且不受流程控制的影响——当这样的帧被发送到那里时，可以在其他的 DATA 帧之前完成。

                                    -

                                    流重置

                                    -

                                    HTTP/1.x 不允许请求或响应流执行清除重置，如当客户端上传的资源已经存在于服务器上，服务器就需要接受整个响应。

                                    -

                                    HTTP/2 在请求/响应期间随时支持流重置：

                                    -
                                    request.response().reset();
-
                                    -

                                    默认的 NO_ERROR(0) 错误代码会发送，您也可以发送另外一个错误代码：

                                    -
                                    request.response().reset(8);
-
                                    -

                                    HTTP/2 规范中定义了可用的 错误码 列表：

                                    -

                                    若使用了 request handler 和 response handler 两个处理器过后，在流重置完成时您将会收到通知：

                                    -
                                    request.response().exceptionHandler(err -> {
-  if (err instanceof StreamResetException) {
-    StreamResetException reset = (StreamResetException) err;
-    System.out.println("Stream reset " + reset.getCode());
-  }
-});
-
                                    -

                                    服务器推送

                                    -

                                    服务器推送(Server Push)是 HTTP/2 支持的一个新功能，可以为单个客户端请求并行发送多个响应。

                                    -

                                    当服务器处理请求时，它可以向客户端推送请求/响应：

                                    -
                                    HttpServerResponse response = request.response();
-
-// 推送main.js到客户端
-response.push(HttpMethod.GET, "/main.js", ar -> {
-
-  if (ar.succeeded()) {
-
-    // 服务器准备推送响应
-    HttpServerResponse pushedResponse = ar.result();
-
-    // 发送main.js响应
-    pushedResponse.
-        putHeader("content-type", "application/json").
-        end("alert(\"Push response hello\")");
-  } else {
-    System.out.println("Could not push client resource " + ar.cause());
-  }
-});
-
-// 发送请求的资源内容
-response.sendFile("<html><head><script src=\"/main.js\"></script></head><body></body></html>");
-
                                    -

                                    当服务器准备推送响应时，推送响应处理器会被调用，并会发送响应。

                                    -

                                    推送响应处理器客户能会接收到失败，如：客户端可能取消推送，因为它已经在缓存中包含了 main.js，并不在需要它。

                                    -

                                    您必须在响应结束之前调用 push 方法，但是在推送响应过后依然可以写响应。

                                    -

                                    HTTP 压缩

                                    -

                                    Vert.x 支持 HTTP 压缩。

                                    -

                                    这意味着在响应发送回客户端之前，您可以将响应体自动压缩。

                                    -

                                    若客户端不支持HTTP 压缩，则它可以发回没有压缩过的请求。

                                    -

                                    这允许它同时处理支持HTTP 压缩的客户端和不支持的客户端。

                                    -

                                    要启用压缩，可以使用 setCompressionSupported 方法进行配置。默认情况下，未启用压缩。

                                    -

                                    当启用HTTP 压缩时，服务器将检查客户端请求头中是否包含了 Accept-Encoding 并支持常用的 deflate 和 gzip 压缩算法。Vert.x 两者都支持。若找到这样的请求头，服务器将使用所支持的压缩算法之一自动压缩响应正文并发送回客户端。

                                    -

                                    注意：压缩可以减少网络流量，单是CPU密集度会更高。

                                    -

                                    为了解决后边一个问题，Vert.x也允许您调整原始的 gzip/deflate 压缩算法的 “压缩级别” 参数

                                    -

                                    压缩级别允许根据所得数据的压缩比和压缩/解压的计算成本来配置 gzip/deflate 算法。

                                    -

                                    压缩级别是从 1 到 9 的整数值，其中 1 表示更低的压缩比但是最快的算法，9 表示可用的最大压缩比但比较慢的算法。

                                    -

                                    使用高于 1-2 的压缩级别通常允许仅仅保存一些字节大小 —— 它的增益不是线性的，并取决于要压缩的特定数据 —— 但它可以满足服务器所要求的CPU周期的不可控的成本（注意现在Vert.x不支持任何缓存形式的响应数据，如静态文件，因此压缩是在每个请求体生成时进行的）,它可生成压缩过的响应数据、并对接收的响应解码（膨胀）—— 和客户端使用的方式一致，这种操作随着压缩级别的增长会变得更加倾向于CPU密集型。

                                    -

                                    默认情况下 —— 如果通过 setCompressionSupported 方法启用压缩，Vert.x 将使用 6 作为压缩级别，但是该参数可通过 setCompressionLevel 方法来更改。

                                    -

                                    创建 HTTP 客户端

                                    -

                                    您可通过以下方式创建一个具有默认配置的 HttpClient 实例：

                                    -
                                    HttpClient client = vertx.createHttpClient();
-
                                    -

                                    若您想要配置客户端选项，可按以下方式创建：

                                    -
                                    HttpClientOptions options = new HttpClientOptions().setKeepAlive(false);
-HttpClient client = vertx.createHttpClient(options);
-
                                    -

                                    Vert.x 支持基于 TLS h2 和 TCP h2c 的 HTTP/2 协议。

                                    -

                                    默认情况下，HTTP 客户端会发送 HTTP/1.1 请求。若要执行 HTTP/2 请求，则必须调用 setProtocolVersion 方法将版本设置成 HTTP_2。

                                    -

                                    对于 h2 请求，必须使用应用层协议协商(ALPN)启用TLS：

                                    -
                                    HttpClientOptions options = new HttpClientOptions().
-    setProtocolVersion(HttpVersion.HTTP_2).
-    setSsl(true).
-    setUseAlpn(true).
-    setTrustAll(true);
-
-HttpClient client = vertx.createHttpClient(options);
-
                                    -

                                    对于 h2c 请求，TLS必须禁用，客户端将执行 HTTP/1.1 请求并尝试升级到 HTTP/2：

                                    -
                                    HttpClientOptions options = new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_2);
-
-HttpClient client = vertx.createHttpClient(options);
-
                                    -

                                    h2c 连接也可以直接建立，如连接可以使用前文提到的方式创建，当 setHttp2ClearTextUpgrade 选项设置为 false 时：建立连接后，客户端将发送 HTTP/2 连接前缀，并期望从服务端接收相同的连接偏好。

                                    -

                                    HTTP 服务端可能不支持 HTTP/2，当响应到达时，可以使用 version 方法检查响应实际HTTP版本。

                                    -

                                    当客户端连接到 HTTP/2 服务端时，它将向服务端发送其初始设置。设置定义服务器如何使用连接、客户端的默认初始设置是由 HTTP/2 RFC定义的。

                                    -

                                    记录客户端网络活动

                                    -

                                    为了进行调试，可以记录网络活动：

                                    -
                                    HttpClientOptions options = new HttpClientOptions().setLogActivity(true);
-HttpClient client = vertx.createHttpClient(options);
-
                                    -

                                    详情请参阅 记录网络活动 章节。

                                    -

                                    发出请求

                                    -

                                    HTTP 客户端是很灵活的，您可以通过各种方式发出请求。

                                    -

                                    通常您希望使用 HTTP 客户端向同一个主机/端口发送很多请求。为避免每次发送请求时重复设主机/端口，您可以为客户端配置默认主机/端口：

                                    -
                                    HttpClientOptions options = new HttpClientOptions().setDefaultHost("wibble.com");
-// Can also set default port if you want...
-// 若您想可设置默认端口
-HttpClient client = vertx.createHttpClient(options);
-client.getNow("/some-uri", response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-});
-
                                    -

                                    或者您发现自己使用相同的客户端向不同主机的主机/端口发送大量请求，则可以在发出请求时简单指定主机/端口：

                                    -
                                    HttpClient client = vertx.createHttpClient();
-
-// 指定端口和主机名
-client.getNow(8080, "myserver.mycompany.com", "/some-uri", response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-});
-
-// 这次使用默认端口80和指定的主机名
-client.getNow("foo.othercompany.com", "/other-uri", response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-});
-
                                    -

                                    用客户端发出请求的所有不同方式都支持这两种指定主机/端口的方法。

                                    -

                                    无请求体的简单请求

                                    -

                                    通常，您想发出没有请求体的HTTP 请求，这种情况通常如HTTP GET、OPTIONS 和 HEAD 请求。

                                    -

                                    使用 Vert.x HTTP Client 执行这种请求最简单的方式是使用加了 Now 后缀的请求方法，如 getNow。这些方法会创建HTTP 请求，并在单个方法调用中发送它，而且允许您提供一个处理器，当HTTP 响应发送回来时调用该处理器来处理响应结果。

                                    -
                                    HttpClient client = vertx.createHttpClient();
-
-// 发送GET请求
-client.getNow("/some-uri", response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-});
-
-// 发送HEAD请求
-client.headNow("/other-uri", response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-});
-
                                    -

                                    发送通用请求

                                    -

                                    有时您在运行时不知道发送请求的 HTTP 方法，对于这种情况，我们提供通用请求方法 request，允许您在运行时指定 HTTP 方法：

                                    -
                                    HttpClient client = vertx.createHttpClient();
-
-client.request(HttpMethod.GET, "some-uri", response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-}).end();
-
-client.request(HttpMethod.POST, "foo-uri", response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-}).end("some-data");
-
                                    -

                                    写请求体

                                    -

                                    有时您想要发送一个包含了请求体的请求，或者也许您想要在发送请求之前写入头部到请求中。

                                    -

                                    为此，您可以调用其中一个指定的请求方法，如 post 或一个其他通用请求方法，如 request。这些方法都不会立即发送请求，而是返回一个 HttpClientRequest 实例，它可以用来写数据到请求体和请求头。

                                    -

                                    这儿有一些写入请求体的 POST 请求例子：

                                    -
                                    HttpClient client = vertx.createHttpClient();
-
-HttpClientRequest request = client.post("some-uri", response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-});
-
-// 现在准备请求的一些东西
-request.putHeader("content-length", "1000");
-request.putHeader("content-type", "text/plain");
-request.write(body);
-
-// 确保请求完成后结束
-request.end();
-
-// 或使用Fluent的API
-client.post("some-uri", response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-}).putHeader("content-length", "1000").putHeader("content-type", "text/plain").write(body).end();
-
-// 或事情更简单
-client.post("some-uri", response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-}).putHeader("content-type", "text/plain").end(body);
-
                                    -

                                    可以用UTF-8编码方式编码字符串和以指定方式编码编码字符串、或写Buffer的方法：

                                    -
                                    // 写UTF-8编码的字符串
-request.write("some data");
-
-// 写指定编码的字符串
-request.write("some other data", "UTF-16");
-
-// 写Buffer
-Buffer buffer = Buffer.buffer();
-buffer.appendInt(123).appendLong(245l);
-request.write(buffer);
-
                                    -

                                    若您仅需要写单个字符串或 Buffer 到HTTP请求中，您可以直接调用 end 函数完成写入和请求的发送操作。

                                    -
                                    request.end("some simple data");
-
-// 在单次调用中写Buffer并结束请求（直接发送）
-Buffer buffer = Buffer.buffer().appendDouble(12.34d).appendLong(432l);
-request.end(buffer);
-
                                    -

                                    当您写入请求时，第一次调用 write 方法将先将请求头写入到请求报文中。

                                    -

                                    实际写入操作是异步的，它可能在调用返回一段时间后才发生。

                                    -

                                    带请求体的非分块 HTTP 请求需要提供 Content-Length 头。因此，若您不使用 HTTP 分块，则必须在写入请求之前设置Content-Length头，否则会出错。

                                    -

                                    若您在调用其中一个 end 方法处理 String 或 Buffer，在写入请求体之前，Vert.x 将自动计算并设置 Content-Length。若您在使用HTTP 分块模式，则不需要 Content-Length 头，因此您不必先计算大小。

                                    -

                                    写请求头

                                    -

                                    您可以直接使用 MultiMap 结构的 headers 来设置请求头：

                                    -
                                    MultiMap headers = request.headers();
-headers.set("content-type", "application/json").set("other-header", "foo");
-
                                    -

                                    这个headers是一个 MultiMap 的实例，它提供了添加、设置、删除条目的操作。HTTP Header允许一个特定的键包含多个值。

                                    -

                                    您也可以使用 putHeader 方法编写头文件：

                                    -
                                    request.putHeader("content-type", "application/json").putHeader("other-header", "foo");
-
                                    -

                                    若您想写入请求头，则您必须在写入任何请求体之前这样做来设置请求头。

                                    -

                                    非标准的HTTP 方法

                                    -

                                    OTHER HTTP方法用于非标准HTTP方法，当使用此方法时，必须使用 setRawMethod 方法来设置需要发送到服务器的raw方法。

                                    -

                                    发送 HTTP 请求

                                    -

                                    一旦完成了 HTTP 请求的准备工作，您必须调用其中一个 end 方法来发送该请求（结束请求）。

                                    -

                                    结束一个请求时，若请求头尚未被写入，会导致它们被写入，并且请求被标记成完成的。

                                    -

                                    请求可以通过多种方式结束。无参简单结束请求的方式如：

                                    -
                                    request.end();
-
                                    -

                                    或可以在调用 end 方法时提供 String 或 Buffer，这个和先调用带 String/Buffer 参数的 write 方法之后再调用无参 end 方法一样：

                                    -
                                    request.end("some-data");
-
-// 使用buffer结束
-Buffer buffer = Buffer.buffer().appendFloat(12.3f).appendInt(321);
-request.end(buffer);
-
                                    -

                                    分块 HTTP 请求

                                    -

                                    Vert.x 支持 HTTP Chunked Transfer Encoding 请求。

                                    -

                                    这允许使用块方式写入HTTP 请求体，这个在请求体比较大需要流式发送到服务器，或预先不知道大小时很常用。

                                    -

                                    您可使用 setChuncked 将HTTP 请求设置成分块模式。

                                    -

                                    在分块模式下，每次调用 write 方法将导致新的块被写入到报文，这种模式中，无需先设置请求头中的 Content-Length。

                                    -
                                    request.setChunked(true);
-
-// Write some chunks
-// 写一些块
-for (int i = 0; i < 10; i++) {
-  request.write("this-is-chunk-" + i);
-}
-
-request.end();
-
                                    -

                                    请求超时

                                    -

                                    您可使用 setTimeout设置一个特定 HTTP 请求的超时时间。

                                    -

                                    若请求在超时期限内未返回任何数据，则异常将会被传给异常处理器（若提供），并且请求将会被关闭。

                                    -

                                    处理异常

                                    -

                                    您可以通过在 HttpClientRequest 实例中设置异常处理器来处理请求时发生的异常：

                                    -
                                    HttpClientRequest request = client.post("some-uri", response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-});
-request.exceptionHandler(e -> {
-  System.out.println("Received exception: " + e.getMessage());
-  e.printStackTrace();
-});
-
                                    -

                                    这种处理器不处理需要在 HttpClientResponse 中处理的非 2xx 响应：

                                    -
                                    HttpClientRequest request = client.post("some-uri", response -> {
-  if (response.statusCode() == 200) {
-    System.out.println("Everything fine");
-    return;
-  }
-  if (response.statusCode() == 500) {
-    System.out.println("Unexpected behavior on the server side");
-    return;
-  }
-});
-request.end();
-
                                    -
                                    -

                                    重要提示：一系列的 XXXNow 方法均不接收异常处理器做为参数。

                                    -
                                    -

                                    客户端请求中指定处理器

                                    -

                                    不像在调用中提供响应处理器来创建客户端请求对象，相反您可以当请求创建时不提供处理器、稍后在请求对象中调用 handler 来设置。如：

                                    -
                                    HttpClientRequest request = client.post("some-uri");
-request.handler(response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-});
-
                                    -

                                    使用流式请求

                                    -

                                    HttpClientRequest 实例实现了 WriteStream 接口，这意味着您可以从任何 ReadStream 实例将数据泵入请求中。

                                    -

                                    例如，您可以将磁盘上的文件直接泵送到HTTP 请求体中，如下所示：

                                    -
                                    request.setChunked(true);
-Pump pump = Pump.pump(file, request);
-file.endHandler(v -> request.end());
-pump.start();
-
                                    -

                                    写 HTTP/2 帧

                                    -

                                    HTTP/2 是用于 HTTP 请求/响应模型的具有各种帧的一个帧协议，该协议允许发送和接收其他类型的帧。

                                    -

                                    要发送这样的帧，您可以使用 write 方法写入请求，以下是一个例子：

                                    -
                                    int frameType = 40;
-int frameStatus = 10;
-Buffer payload = Buffer.buffer("some data");
-
-// Sending a frame to the server
-// 发送一帧到服务器
-request.writeCustomFrame(frameType, frameStatus, payload);
-
                                    -

                                    流重置

                                    -

                                    HTTP/1.x 不允许请求或响应流进行重置，如当客户端上传了服务器上存在的资源时，服务器依然要接收整个响应。

                                    -

                                    HTTP/2 在请求/响应期间随时支持流重置：

                                    -
                                    request.reset();
-
                                    -

                                    默认情况，发送 NO_ERROR(0)错误代码，可发送另一个代码：

                                    -
                                    request.reset(8);
-
                                    -

                                    HTTP/2规范定义了可使用的 错误码 列表。

                                    -

                                    若使用了 request handler 和 response handler 两个处理器过后，在流重置完成时您将会收到通知。

                                    -
                                    request.exceptionHandler(err -> {
-  if (err instanceof StreamResetException) {
-    StreamResetException reset = (StreamResetException) err;
-    System.out.println("Stream reset " + reset.getCode());
-  }
-});
-
                                    -

                                    处理 HTTP 响应

                                    -

                                    您可以在请求方法中指定处理器或通过 HttpClientRequest 对象直接设置处理器来接收到 HttpClientResponse 的实例。

                                    -

                                    您可以通过 statusCode 和 statusMessage 方法从响应中查询响应的状态码和状态消息：

                                    -
                                    client.getNow("some-uri", response -> {
-  // the status code - e.g. 200 or 404
-  // 状态代码,如:200、404
-  System.out.println("Status code is " + response.statusCode());
-
-  // the status message e.g. "OK" or "Not Found".
-  // 状态消息,如:OK、Not Found
-  System.out.println("Status message is " + response.statusMessage());
-});
-
                                    -

                                    使用流式响应

                                    -

                                    HttpClientResponse 实例也是一个 ReadStream 实例，这意味着您可以泵送数据到任何 WriteStream 实例。

                                    -

                                    响应头和尾

                                    -

                                    HTTP 响应可包含头信息。您可以使用 headers 方法来读取响应头。该方法返回的对象是 一个 MultiMap 实例，因为 HTTP 响应头中单个键可以关联多个值。

                                    -
                                    String contentType = response.headers().get("content-type");
-String contentLength = response.headers().get("content-lengh");
-
                                    -

                                    分块 HTTP 响应还可以包含响应尾(trailer) —— 这实际上是在发送响应体的最后一个（数据）块。

                                    -

                                    您可使用 trailers方法读取响应尾，尾数据也是一个 MultiMap。

                                    -

                                    读取请求体

                                    -

                                    当从报文中读取到响应头时，响应处理器就会被调用。如果收到的HTTP 响应包含响应体（正文），它可能会在响应头被读取后的某个时间以分片的方式到达。在调用响应处理器之前，我们不要等待所有的响应体到达，因为它可能非常大而要等待很长时间、又或者会花费大量内存。

                                    -

                                    当响应体的某部分（数据）到达时，handler 方法绑定的回调函数将会被调用，其中传入的 Buffer 中包含了响应体的这一分片（部分）内容：

                                    -
                                    client.getNow("some-uri", response -> {
-
-  response.handler(buffer -> {
-    System.out.println("Received a part of the response body: " + buffer);
-  });
-});
-
                                    -

                                    若您知道响应体不是很大，并想在处理之前在内存中聚合所有响应体数据，那么您可以自己聚合：

                                    -
                                    client.getNow("some-uri", response -> {
-
-  // Create an empty buffer
-  // 创建空的缓冲区
-  Buffer totalBuffer = Buffer.buffer();
-
-  response.handler(buffer -> {
-    System.out.println("Received a part of the response body: " + buffer.length());
-
-    totalBuffer.appendBuffer(buffer);
-  });
-
-  response.endHandler(v -> {
-    // Now all the body has been read
-    // 现在所有的响应体都读取了
-    System.out.println("Total response body length is " + totalBuffer.length());
-  });
-});
-
                                    -

                                    或者当响应已被完全读取时，您可以使用 bodyHandler 方法以便读取整个响应体：

                                    -
                                    client.getNow("some-uri", response -> {
-
-  response.bodyHandler(totalBuffer -> {
-    // Now all the body has been read
-    // 现在所有的响应体都读取了
-    System.out.println("Total response body length is " + totalBuffer.length());
-  });
-});
-
                                    -

                                    响应完成处理器

                                    -

                                    当整个响应体被完全读取或者无响应体的响应头被完全读取时，响应的 endHandler 就会被调用。

                                    -

                                    从响应中读取Cookie

                                    -

                                    您可以通过 cookies 方法从响应中获取 Cookie 列表。或者您可以在响应中自己解析Set-Cookie头。

                                    -

                                    30x 重定向处理器

                                    -

                                    客户端可配置成遵循HTTP 重定向：当客户端接收到 301、302、303 或 307 状态代码时，它遵循由 Location 响应头提供的重定向，并且响应处理器将传递重定向响应以替代原始响应。

                                    -

                                    这有个例子：

                                    -
                                    client.get("some-uri", response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-}).setFollowRedirects(true).end();
-
                                    -

                                    重定向策略如下：

                                    -
                                      -
                                    • 当接收到 301、302 或 303 状态代码时，使用 GET 方法执行重定向
                                      • -
                                    • 当接收到 307 状态代码时，使用相同的 HTTP 方法和缓存的请求体执行重定向
                                      • -
                                    -
                                    -

                                    警告：随后的重定向会缓存请求体。

                                    -
                                    -

                                    默认情况最大的重定向数为 16，您可使用 setMaxRedirects 方法设置。

                                    -
                                    HttpClient client = vertx.createHttpClient(
-    new HttpClientOptions()
-        .setMaxRedirects(32));
-
-client.get("some-uri", response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-}).setFollowRedirects(true).end();
-
                                    -

                                    没有放之四海而皆准的策略，缺省的重定向策略可能不能满足您的需要。默认重定向策略可使用自定义实现更改：

                                    -
                                    client.redirectHandler(response -> {
-
-  // Only follow 301 code
-  // 仅仅遵循301状态代码
-  if (response.statusCode() == 301 && response.getHeader("Location") != null) {
-
-    // Compute the redirect URI
-    // 计算重定向URI
-    String absoluteURI = resolveURI(response.request().absoluteURI(), response.getHeader("Location"));
-
-    // Create a new ready to use request that the client will use
-    // 创建客户端将使用的新的可用请求
-    return Future.succeededFuture(client.getAbs(absoluteURI));
-  }
-
-  // We don't redirect
-  // 我们不需要重定向
-  return null;
-});
-
                                    -

                                    这个策略将会处理接收到的原始 HttpClientResponse，并返回 null 或 Future<HttpClientRequest> 。

                                    -
                                      -
                                    • 当返回的是 null 时，处理原始响应
                                      • -
                                    • 当返回的是 Future 时，请求将在它成功完成后发送
                                      • -
                                    • 当返回的是 Future 时，请求失败时调用设置的异常处理器
                                      • -
                                    -

                                    返回的请求必须是未发送的，这样原始请求处理器才会被发送而且客户端之后才能发送请求。大多数原始请求设置将会传播（拷贝）到新请求中：

                                    -
                                      -
                                    • 请求头，除非您已经设置了一些头（包括 setHost）
                                      • -
                                    • 请求体，除非返回的请求使用了 GET 方法
                                      • -
                                    • 响应处理器
                                      • -
                                    • 请求异常处理器
                                      • -
                                    • 请求超时
                                      • -
                                    -

                                    100-Continue 处理

                                    -

                                    根据 HTTP/1.1 规范，一个客户端可以设置请求头 Expect: 100-Continue，并且在发送剩余请求体之前先发送请求头。然后服务器可以通过回复临时响应状态 Status: 100 (Continue) 来告诉客户端可以发送请求的剩余部分。

                                    -

                                    这里的想法是允许服务器在发送大量数据之前授权、接收/拒绝请求，若请求不能被接收，则发送大量数据信息会浪费带宽，并将服务器绑定在读取即将丢弃的无用数据中。

                                    -

                                    Vert.x 允许您在客户端请求对象中设置一个 continueHandler。它将在服务器发回一个状态 Status: 100 (Continue) 时被调用, 同时也表示（客户端）可以发送请求的剩余部分。通常将其与 sendHead 结合起来发送请求的头信息。

                                    -

                                    以下是一个例子：

                                    -
                                    HttpClientRequest request = client.put("some-uri", response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-});
-
-request.putHeader("Expect", "100-Continue");
-
-request.continueHandler(v -> {
-  // OK to send rest of body
-  // 可发送请求体剩余部分
-  request.write("Some data");
-  request.write("Some more data");
-  request.end();
-});
-
                                    -

                                    在服务端，Vert.x HTTP Server可配置成接收到 Expect: 100-Continue 头时自动发回 100 Continue 临时响应信息。这个可通过 setHandle100ContinueAutomatically 方法来设置。

                                    -

                                    若您想要决定是否手动发送持续响应，那么此属性可设置成false（默认值），然后您可以通过检查头信息并且调用 writeContinue 方法让客户端持续发送请求体：

                                    -
                                    httpServer.requestHandler(request -> {
-  if (request.getHeader("Expect").equalsIgnoreCase("100-Continue")) {
-
-    // Send a 100 continue response
-    // 发送100 Continue持续响应
-    request.response().writeContinue();
-
-    // The client should send the body when it receives the 100 response
-    // 当客户端收到100响应代码则可以发送剩余请求体
-    request.bodyHandler(body -> {
-      // Do something with body
-    });
-
-    request.endHandler(v -> {
-      request.response().end();
-    });
-  }
-});
-
                                    -

                                    您也可以通过直接发送故障状态代码来拒绝该请求：这种情况下，请求体应该被忽略或连接应该被关闭（100-Continue 是一个性能提示，并不是逻辑协议约束）：

                                    -
                                    httpServer.requestHandler(request -> {
-  if (request.getHeader("Expect").equalsIgnoreCase("100-Continue")) {
-
-    //
-    boolean rejectAndClose = true;
-    if (rejectAndClose) {
-
-      // Reject with a failure code and close the connection
-      // this is probably best with persistent connection
-      // 使用失败码拒绝并关闭这个连接，这可能是长连接最好的
-      request.response()
-          .setStatusCode(405)
-          .putHeader("Connection", "close")
-          .end();
-    } else {
-
-      // Reject with a failure code and ignore the body
-      // this may be appropriate if the body is small
-      // 使用失败码拒绝忽略请求体，若体很小，这是适用的
-      request.response()
-          .setStatusCode(405)
-          .end();
-    }
-  }
-});
-
                                    -

                                    客户端推送

                                    -

                                    服务器推送(Server Push)是 HTTP/2 的一个新功能，它可以为单个客户端并行发送多个响应。

                                    -

                                    可以在接收服务器推送的请求/响应的请求上设置一个推送处理器：

                                    -
                                    HttpClientRequest request = client.get("/index.html", response -> {
-  // Process index.html response
-  // 处理index.html响应
-});
-
-// Set a push handler to be aware of any resource pushed by the server
-// 设置一个推送处理器来感知服务器推送的任何资源
-request.pushHandler(pushedRequest -> {
-
-  // A resource is pushed for this request
-  // 为当前请求推送资源
-  System.out.println("Server pushed " + pushedRequest.path());
-
-  // Set an handler for the response
-  // 为响应设置处理器
-  pushedRequest.handler(pushedResponse -> {
-    System.out.println("The response for the pushed request");
-  });
-});
-
-// End the request
-// 结束请求
-request.end();
-
                                    -

                                    若客户端不想收到推送请求，它可重置流：

                                    -
                                    request.pushHandler(pushedRequest -> {
-  if (pushedRequest.path().equals("/main.js")) {
-    pushedRequest.reset();
-  } else {
-    // Handle it
-    // 处理逻辑
-  }
-});
-
                                    -

                                    若没有设置任何处理器时，任何被推送的流将被客户端自动重置流（错误代码 8）。

                                    -

                                    接收自定义 HTTP/2 帧

                                    -

                                    HTTP/2 是用于 HTTP 请求/响应模型的具有各种帧的一个帧协议，该协议允许发送和接收其他类型的帧。

                                    -

                                    要接收自定义帧，您可以在请求中使用 customFrameHandler，每次自定义帧到达时就会调用它。以下是一个例子：

                                    -
                                    response.customFrameHandler(frame -> {
-
-  System.out.println("Received a frame type=" + frame.type() +
-      " payload" + frame.payload().toString());
-});
-
                                    -

                                    客户端启用压缩

                                    -

                                    HTTP 客户端支持开箱即用的 HTTP 压缩功能。这意味着客户端可以让远程服务器知道它支持压缩，并且能处理压缩过的响应体（数据）。

                                    -

                                    HTTP 服务端可以自由地使用自己支持的压缩算法之一进行压缩，也可以在不压缩的情况下将响应体发回。所以这仅仅是 HTTP 服务端的一个可能被随意忽略的提示。

                                    -

                                    要告诉服务器当前客户端支持哪种压缩，则它（请求头）将包含一个 Accept-Encoding 头，其值为可支持的压缩算法，（该值可）支持多种压缩算法。这种情况 Vert.x 将添加以下头：

                                    -
                                    Accept-Encoding: gzip, deflate
-
                                    -

                                    服务器将从其中（算法）选择一个，您可以通过服务器发回的响应中响应头 Content-Encoding 来检测服务器是否适应这个正文。

                                    -

                                    若响应体通过 gzip 压缩，它将包含例如下边的头：

                                    -
                                    Content-Encoding: gzip
-
                                    -

                                    创建客户端时可使用 setTryUseCompression 设置配置项启用压缩。

                                    -

                                    默认情况压缩被禁用。

                                    -

                                    HTTP/1.x Pooling 和 Keep alive

                                    -

                                    HTTP 的 Keep Alive 允许单个 HTTP 连接用于多个请求。当您向同一台服务器发送多个请求时，可以更加有效使用连接。

                                    -

                                    对于 HTTP/1.x 版本，HTTP 客户端支持连接池，它允许您重用请求之间的连接。

                                    -

                                    为了连接池（能）工作，配置客户端时，keep alive 必须通过 setKeepAlive 方法设置成true。默认值为true。

                                    -

                                    当 keep alive 启用时，Vert.x 将为每一个发送的 HTTP/1.0 请求添加一个 Connection: Keep-Alive 头。当 keep alive 禁用时，Vert.x 将为每一个 HTTP/1.1 请求添加一个 Connection: Close 头 —— 表示在响应完成后连接将被关闭。

                                    -

                                    可使用 setMaxPoolSize 方法为每个服务器配置连接池的最大连接数。

                                    -

                                    当启用连接池创建请求时，若存在少于已经为服务器创建的最大连接数，Vert.x 将创建一个新连接，否则直接将请求添加到队列中。

                                    -

                                    Keep Alive的连接将不会被客户端自动关闭，要关闭它们您可以关闭客户端实例。

                                    -

                                    或者，您可使用setIdleTimeout设置空闲时间——在设置的时间内然后没使用的连接将被关闭。请注意空闲超时值以秒为单位而不是毫秒。

                                    -

                                    HTTP/1.1 Pipe-lining

                                    -

                                    客户端还支持连接上的请求管道(pipeline)。

                                    -

                                    管道意味着在返回一个响应之前，在同一个连接上发送另一个请求，管道不适合所有请求。

                                    -

                                    若要启用管道，必须调用setPipelining方法，默认管道是禁止的。

                                    -

                                    当启用管道时，请求可以不等待以前的响应返回而写入到连接。

                                    -

                                    单个连接的管道请求限制数由 setPipeliningLimit 方法设置，此选项定义了发送到服务器的等待响应的最大请求数。这个限制可以确保和同一个服务器的连接分发到客户端的公平性。

                                    -

                                    HTTP/2 多路复用

                                    -

                                    HTTP/2 提倡使用服务器的单一连接，默认情况下，HTTP 客户端针对每个服务器都使用单一连接，同样服务器上的所有流都会复用到对应连接中。

                                    -

                                    当客户端需要使用连接池并使用超过一个连接时，则可使用setHttp2MaxPoolSize 设置。

                                    -

                                    当您希望限制每个连接的多路复用流数量而使用连接池而不是单个连接时，可使用 setHttp2MultiplexingLimit 设置。

                                    -
                                    HttpClientOptions clientOptions = new HttpClientOptions().
-    setHttp2MultiplexingLimit(10).
-    setHttp2MaxPoolSize(3);
-
-// Uses up to 3 connections and up to 10 streams per connection
-// 每个连接最多可用三个连接，每个连接可连接10个流
-HttpClient client = vertx.createHttpClient(clientOptions);
-
                                    -

                                    连接的复用限制是在客户端上设置限制单个连接的流数量，如果服务器使用 SETTINGS_MAX_CONCURRENT_STREAMS 设置了下限，则有效值可以更低。

                                    -

                                    HTTP/2 连接不会被客户端自动关闭，若要关闭它们，可以调用 close 来关闭客户端实例。

                                    -

                                    或者，您可以使用setIdleTimeout设置空闲时间——这个时间内没有使用的任何连接将被关闭，注意，空闲时间以秒为单位，不是毫秒。

                                    -

                                    HTTP 连接

                                    -

                                    HttpConnection 接口提供了处理HTTP 连接事件、生命周期、设置的API。

                                    -

                                    HTTP/2 实现了完整的 HttpConnection API。

                                    -

                                    HTTP/1.x 实现了 HttpConnection 中的部分API：仅关闭操作，实现了关闭处理器和异常处理器。该协议并不提供其他操作的语义。

                                    -

                                    服务端连接

                                    -

                                    connection 方法会返回服务器上的请求连接：

                                    -
                                    HttpConnection connection = request.connection();
-
                                    -

                                    可以在服务器上设置连接处理器，任意连接传入时可得到通知：

                                    -
                                    HttpServer server = vertx.createHttpServer(http2Options);
-
-server.connectionHandler(connection -> {
-  System.out.println("A client connected");
-});
-
                                    -

                                    客户端连接

                                    -

                                    connection 方法会返回客户端上的连接请求：

                                    -
                                    HttpConnection connection = request.connection();
-
                                    -

                                    可以在请求上设置连接处理器在连接发生时通知：

                                    -
                                    request.connectionHandler(connection -> {
-  System.out.println("Connected to the server");
-});
-
                                    -

                                    连接配置

                                    -

                                    HTTP/2 由 Http2Settings 数据对象来配置。

                                    -

                                    每个 Endpoint 都必须遵守连接另一端的发送设置。

                                    -

                                    当建立连接时，客户端和服务器交换初始配置，初始设置由客户端上的 setInitialSettings 和服务器上的 setInitialSettings 方法配置。

                                    -

                                    连接建立后可随时更改设置：

                                    -
                                    connection.updateSettings(new Http2Settings().setMaxConcurrentStreams(100));
-
                                    -

                                    由于远程方应该确认接收者的配置更新，也有可能在回调中接收确认通知：

                                    -
                                    connection.updateSettings(new Http2Settings().setMaxConcurrentStreams(100), ar -> {
-  if (ar.succeeded()) {
-    System.out.println("The settings update has been acknowledged ");
-  }
-});
-
                                    -

                                    相反，在收到新的远程设置时会通知 remoteSettingsHandler：

                                    -
                                    connection.remoteSettingsHandler(settings -> {
-  System.out.println("Received new settings");
-});
-
                                    -
                                    -

                                    请注意：此功能仅适用于 HTTP/2 协议。

                                    -
                                    -

                                    连接 Ping

                                    -

                                    HTTP/2 连接 ping 对于确定连接往返时间或检查连接有效性很有用：ping 发送 PING 帧到远端：

                                    -
                                    Buffer data = Buffer.buffer();
-for (byte i = 0;i < 8;i++) {
-  data.appendByte(i);
-}
-connection.ping(data, pong -> {
-  System.out.println("Remote side replied");
-});
-
                                    -

                                    当接收到 PING 帧时，Vert.x 将自动发送确认，可设置处理器当收到 ping 帧时发送通知调用处理器：

                                    -
                                    connection.pingHandler(ping -> {
-  System.out.println("Got pinged by remote side");
-});
-
                                    -

                                    处理器只是接到通知，确认被发送，这个功能旨在基于 HTTP/2 协议之上实现。

                                    -
                                    -

                                    请注意：此功能仅适用于 HTTP/2 协议。

                                    -
                                    -

                                    连接关闭/GOAWAY

                                    -

                                    调用 shutdown 方法将发送 GOAWAY 帧到远程的连接，要求其停止创建流：客户端将停止发送新请求，并且服务器将停止推送响应。发送 GOAWAY 帧后，连接将等待一段时间（默认为30秒），直到所有当前流关闭和连接关闭。

                                    -
                                    connection.shutdown();
-
                                    -

                                    shutdownHandler 通知何时关闭所有流，连接尚未关闭。

                                    -

                                    有可能只需发送 GOAWAY 帧，和关闭主要的区别在于它将只是告诉远程连接停止创建新流，而没有计划关闭连接：

                                    -
                                    connection.goAway(0);
-
                                    -

                                    相反，也可以在收到 GOAWAY 时收到通知：

                                    -
                                    connection.goAwayHandler(goAway -> {
-  System.out.println("Received a go away frame");
-});
-
                                    -

                                    当所有当前流已经关闭并且可关闭连接时，shutdownHandler 将被调用：

                                    -
                                    connection.goAway(0);
-connection.shutdownHandler(v -> {
-
-  // All streams are closed, close the connection
-  // 所有流被关闭，连接也关闭
-  connection.close();
-});
-
                                    -

                                    当接收到 GOAWAY 时也适用。

                                    -
                                    -

                                    请注意：此功能仅适用于HTTP/2协议。

                                    -
                                    -

                                    连接关闭

                                    -

                                    您可以通过 close 方法关闭连接：

                                    -
                                      -
                                    • 对于 HTTP/1.x 来说，它会关闭底层的 Socket
                                      • -
                                    • 对于 HTTP/2 来说，它将执行无延迟关闭，GOAWAY 帧将会在连接关闭之前被发送
                                      • -
                                    -

                                    连接关闭时 closeHandler 将发出通知。

                                    -

                                    HttpClient 使用说明

                                    -

                                    HttpClient可以在一个 Verticle 中使用或者嵌入使用。

                                    -

                                    在 Verticle 中使用时，Verticle 应该使用自己的客户端实例。

                                    -

                                    一般来说，不应该在不同的 Vert.x 上下文环境之间共享客户端，因为它可能导致不可预知的意外。例如：保持活动连接将在打开连接的请求上下文环境调用客户端处理器，后续请求将使用相同上下文环境。

                                    -

                                    当这种情况发生时，Vert.x会检测到并记录下边警告：

                                    -
                                    Reusing a connection with a different context: an HttpClient is probably shared between different Verticles
-

                                    HttpClient 可以嵌套在非 Vert.x 线程中，如单元测试或纯Java的 main 线程中：客户端处理器将被不同的Vert.x 线程和上下文调用，这样的上下文会根据需要创建。对于生产环境，不推荐这样使用。

                                    -

                                    水平扩展 - 服务端共享

                                    -

                                    当多个 HTTP 服务端在同一个端口上监听时，Vert.x 会使用轮询策略来管理请求处理。

                                    -

                                    我们用 Verticle 来创建 HTTP 服务端，如：

                                    -

                                    io.vertx.examples.http.sharing.HttpServerVerticle

                                    -
                                    vertx.createHttpServer().requestHandler(request -> {
-  request.response().end("Hello from server " + this);
-}).listen(8080);
-
                                    -

                                    这个服务正在监听 8080 端口。所以，当这个 Verticle 被实例化多次，如运行以下命令：

                                    -
                                    vertx run io.vertx.examples.http.sharing.HttpServerVerticle -instances 2
-

                                    将会发生什么？如果两个 Verticle 都绑定到同一个端口，您将收到一个 Socket 异常。幸运的是，Vert.x 可以为您处理这种情况。在与现有服务端相同的主机和端口上部署另一个服务器时，实际上并不会尝试创建在同一主机/端口上监听的新服务端，它只绑定一次到Socket，当接收到请求时，会按照轮询策略调用服务端的请求处理函数。

                                    -

                                    我们现在想象一个客户端，如下：

                                    -
                                    vertx.setPeriodic(100, (l) -> {
-  vertx.createHttpClient().getNow(8080, "localhost", "/", resp -> {
-    resp.bodyHandler(body -> {
-      System.out.println(body.toString("ISO-8859-1"));
-    });
-  });
-});
-
                                    -

                                    Vert.x 将请求顺序委托给其中一个服务器：

                                    -
                                    Hello from i.v.e.h.s.HttpServerVerticle@1
-Hello from i.v.e.h.s.HttpServerVerticle@2
-Hello from i.v.e.h.s.HttpServerVerticle@1
-Hello from i.v.e.h.s.HttpServerVerticle@2
-...
-

                                    因此，服务器可直接扩展可用的核，而每个 Vert.x 中的 Verticle 实例仍然严格使用单线程，您不需要像编写负载均衡器那样使用任何特殊技巧去编写，以便在多核机器上扩展服务器。

                                    -

                                    使用 HTTPS

                                    -

                                    Vert.x 的 HTTP 服务端和客户端可以配置成和网络服务器完全相同的方式使用 HTTPS。

                                    -

                                    有关详细信息，请参阅 配置网络服务器以使用 SSL 章节。

                                    -

                                    SSL可以通过每个请求的 RequestOptions 来启用/禁用，或在指定模式时调用 requestAbs：

                                    -
                                    client.getNow(new RequestOptions()
-    .setHost("localhost")
-    .setPort(8080)
-    .setURI("/")
-    .setSsl(true), response -> {
-  System.out.println("Received response with status code " + response.statusCode());
-});
-
                                    -

                                    setSsl 设置将用作客户端默认配置。

                                    -

                                    setSsl 将覆盖默认客户端设置：

                                    -
                                      -
                                    • 即使客户端配置成使用 SSL/TLS，该值设置成false将禁用SSL/TLS。
                                      • -
                                    • 即使客户端配置成不使用 SSL/TLS，该值设置成true将启用SSL/TLS，实际的客户端SSL/TLS（如受信、密钥/证书、密码、ALPN 等）将被重用。
                                      • -
                                    -

                                    同样，requestAbs 方法也会（在调用时）覆盖默认客户端设置。

                                    -

                                    WebSocket

                                    -

                                    WebSocket 是一种Web技术，可以在 HTTP 服务端和 HTTP 客户端（通常是浏览器）之间实现全双工 Socket 连接。

                                    -

                                    Vert.x HTTP 客户端和服务端都支持 WebSocket。

                                    -

                                    服务端 WebSocket

                                    -

                                    在服务端处理 WebSocket 有两种方法。

                                    -
                                      -
                                    • WebSocket Handler
                                      • -
                                    -

                                    第一种方法需要在服务端实例上提供一个 websocketHandler。

                                    -

                                    当对服务端创建 WebSocket 连接时，Vert.x 将向 Handler传入一个 ServerWebSocket 实例，在其中去处理它。

                                    -
                                    server.websocketHandler(websocket -> {
-  System.out.println("Connected!");
-});
-
                                    -

                                    您可以调用reject 方法来拒绝一个 WebSocket。

                                    -
                                    server.websocketHandler(websocket -> {
-  if (websocket.path().equals("/myapi")) {
-    websocket.reject();
-  } else {
-    // Do something
-    // 做一些事
-  }
-});
-
                                    -
                                      -
                                    • 转换到 WebSocket
                                      • -
                                    -

                                    处理 WebSocket 的第二种方法是处理从客户端发送的HTTP升级请求，调用服务器请求对象的 upgrade方法：

                                    -
                                    server.requestHandler(request -> {
-  if (request.path().equals("/myapi")) {
-
-    ServerWebSocket websocket = request.upgrade();
-    // Do something
-    // 做一些事
-  } else {
-    // Reject
-    // 拒绝
-    request.response().setStatusCode(400).end();
-  }
-});
-
                                    -
                                      -
                                    • 服务端 WebSocket
                                      • -
                                    -

                                    ServerWebSocket 实例能够让您读取在WebSocket 握手中的HTTP 请求的 headers、path、query 和 URI。

                                    -

                                    客户端 WebSocket

                                    -

                                    Vert.x 的 HttpClient 支持 WebSocket。

                                    -

                                    您可以调用其中任意一个 websocket 方法创建 WebSocket 连接到服务端，并提供回调函数。

                                    -

                                    当连接建立时，处理器将被调用并且传入 WebSocket实例：

                                    -
                                    client.websocket("/some-uri", websocket -> {
-  System.out.println("Connected!");
-});
-
                                    -

                                    向 WebSocket 写入消息

                                    -

                                    若您想将一个 WebSocket 消息写入 WebSocket，可使用writeBinaryMessage 方法或 writeTextMessage 方法来执行该操作：

                                    -
                                    Buffer buffer = Buffer.buffer().appendInt(123).appendFloat(1.23f);
-websocket.writeBinaryMessage(buffer);
-
-// Write a simple text message
-// 写一个简单文本消息
-String message = "hello";
-websocket.writeTextMessage(message);
-
                                    -

                                    若WebSocket 消息大于使用setMaxWebsocketFrameSize 设置的W ebSocket 的帧的最大值，则Vert.x在将其发送到报文之前将其拆分为多个WebSocket 帧。

                                    -

                                    向 WebSocket 写入帧

                                    -

                                    WebSocket 消息可以由多个帧组成，在这种情况下，第一帧是二进制或文本帧（text | binary），后边跟着零个或多个 连续 帧。

                                    -

                                    消息中的最后一帧标记成 final。

                                    -

                                    要发送多个帧组成的消息，请使用 WebSocketFrame.binaryFrame、WebSocketFrame.textFrame 或 WebSocketFrame.continuationFrame 方法创建帧，并使用 writeFrame 方法将其写入WebSocket。

                                    -

                                    以下是二进制帧的示例：

                                    -
                                    WebSocketFrame frame1 = WebSocketFrame.binaryFrame(buffer1, false);
-websocket.writeFrame(frame1);
-
-WebSocketFrame frame2 = WebSocketFrame.continuationFrame(buffer2, false);
-websocket.writeFrame(frame2);
-
-// Write the final frame
-// 写最终帧
-WebSocketFrame frame3 = WebSocketFrame.continuationFrame(buffer2, true);
-websocket.writeFrame(frame3);
-
                                    -

                                    许多情况下，您只需要发送一个包含了单个最终帧的 WebSocket 消息，因此我们提供了 writeFinalBinaryFrame 和 writeFinalTextFrame 这两个快捷方法。

                                    -

                                    下边是示例：

                                    -
                                    websocket.writeFinalTextFrame("Geronimo!");
-
-// Send a websocket messages consisting of a single final binary frame:
-// 发送由单个最终二进制帧组成的websocket消息：
-Buffer buff = Buffer.buffer().appendInt(12).appendString("foo");
-
-websocket.writeFinalBinaryFrame(buff);
-
                                    -

                                    从 WebSocket 读取帧

                                    -

                                    要 从WebSocket 读取帧，您可以使用frameHandler 方法。

                                    -

                                    当帧到达时，会传入一个WebSocketFrame实例给帧处理器，并调用它，例如：

                                    -
                                    websocket.frameHandler(frame -> {
-  System.out.println("Received a frame of size!");
-});
-
                                    -

                                    关闭 WebSocket

                                    -

                                    处理完成之后，请使用 close 方法关闭 WebSocket 连接。

                                    -

                                    流式 WebSocket

                                    -

                                    WebSocket 实例也是ReadStream和WriteStream 的实现类，因此可以和泵(pump)一起使用。

                                    -

                                    当使用 WebSocket 作为可写流或可读流时，它只能用于不分割多个帧的二进制帧一起使用的 WebSocket 连接。

                                    -

                                    使用 HTTP/HTTPS 连接代理

                                    -

                                    HTTP 客户端支持通过HTTP 代理（如Squid）或 SOCKS4a 或 SOCKS5 代理访问 HTTP/HTTPS 的 URL。CONNECT 协议使用 HTTP/1.x，但可以连接到 HTTP/1.x 和 HTTP/2 服务器。

                                    -

                                    到 h2c（未加密HTTP/2服务器）的连接可能不受 HTTP 代理支持，因为代理仅支持 HTTP/1.1。

                                    -

                                    您可以通过 HttpClientOptions 中的 ProxyOptions 对象配置来配置代理（包括代理类型、主机名、端口和可选用户名和密码）。

                                    -

                                    以下是使用 HTTP 代理的例子：

                                    -
                                    HttpClientOptions options = new HttpClientOptions()
-    .setProxyOptions(new ProxyOptions().setType(ProxyType.HTTP)
-        .setHost("localhost").setPort(3128)
-        .setUsername("username").setPassword("secret"));
-HttpClient client = vertx.createHttpClient(options);
-
                                    -

                                    当客户端连接到HTTP URL时，它连接到代理服务器，并在HTTP请求中提供完整URL（GET http://www.somehost.com/path/file.html HTTP/1.1）。

                                    -

                                    当客户端连接到HTTPS URL时，它要求代理使用 CONNECT 方法创建到远程主机的通道。

                                    -

                                    对于 SOCKS5 代理：

                                    -
                                    HttpClientOptions options = new HttpClientOptions()
-    .setProxyOptions(new ProxyOptions().setType(ProxyType.SOCKS5)
-        .setHost("localhost").setPort(1080)
-        .setUsername("username").setPassword("secret"));
-HttpClient client = vertx.createHttpClient(options);
-
                                    -

                                    DNS 解析会一直在代理服务器上执行。为了实现 SOCKS4 客户端的功能，需要先在本地解析 DNS 地址。

                                    -

                                    Verticle 中自动清理

                                    -

                                    如果您是在 Verticle 内部创建的 HTTP 服务端和客户端，则在撤销该Verticle时，它们将自动关闭。

                                    -

                                    使用 Vert.x 共享数据

                                    -

                                    共享数据（Shared Data）包含的功能允许您可以安全地在应用程序的不同部分之间、同一 Vert.x 实例中的不同应用程序之间或集群中的不同 Vert.x 实例之间安全地共享数据。

                                    -

                                    共享数据包括本地共享Map、分布式、集群范围Map、异步集群范围锁和异步集群范围计数器。

                                    -
                                    -

                                    重要提示：分布式数据结构的行为取决于您使用的集群管理器，网络分区面临的备份（复制）和行为由集群管理器和它的配置来定义。请参阅集群管理器文档以及底层框架手册。

                                    -
                                    -

                                    本地共享Map

                                    -

                                    本地共享Map LocalMap 允许您在同一个 Vert.x 实例中的不同 Event Loop（如不同的 Verticle 中）之间安全共享数据。

                                    -

                                    本地共享Map仅允许将某些数据类型作为键值和值，这些类型必须是不可变的，或可以像Buffer那样复制某些其他类型。在后一种情况中，键/值将被复制，然后再放到Map中。

                                    -

                                    这样，我们可以确保在Vert.x应用程序不同线程之间 没有共享访问可变状态，因此您不必担心需要通过同步访问来保护该状态。

                                    -

                                    以下是使用 LocalMap 的示例：

                                    -
                                    SharedData sd = vertx.sharedData();
-
-LocalMap<String, String> map1 = sd.getLocalMap("mymap1");
-
-// String是不可变的，所以不需要复制
-map1.put("foo", "bar"); // Strings are immutable so no need to copy
-
-LocalMap<String, Buffer> map2 = sd.getLocalMap("mymap2");
-
-// Buffer将会在添加到Map之前拷贝
-map2.put("eek", Buffer.buffer().appendInt(123)); // This buffer will be copied before adding to map
-
-// Then... in another part of your application:
-// 之后，您的应用另外一部分
-map1 = sd.getLocalMap("mymap1");
-
-String val = map1.get("foo");
-
-map2 = sd.getLocalMap("mymap2");
-
-Buffer buff = map2.get("eek");
-
                                    -

                                    集群范围异步Map

                                    -

                                    集群范围异步Map(Cluster-wide asynchronous maps)允许从集群的任何节点将数据放到 Map 中，并从任何其他节点读取。

                                    -

                                    这使得它们对于托管Vert.x Web应用程序的服务器场中的会话状态存储非常有用。

                                    -

                                    您可以使用 getClusterWideMap 方法获取AsyncMap的实例。

                                    -

                                    获取Map的过程是异步的，返回结果可以传给您指定的处理器中。以下是一个例子：

                                    -
                                    SharedData sd = vertx.sharedData();
-
-sd.<String, String>getClusterWideMap("mymap", res -> {
-  if (res.succeeded()) {
-    AsyncMap<String, String> map = res.result();
-  } else {
-    // Something went wrong!
-    // 出现一些错误
-  }
-});
-
                                    -

                                    将数据放入Map

                                    -

                                    您可以使用 put 方法将数据放入Map。put方法是异步的，一旦完成它会通知处理器：

                                    -
                                    map.put("foo", "bar", resPut -> {
-  if (resPut.succeeded()) {
-    // Successfully put the value
-    // 成功放入值
-  } else {
-    // Something went wrong!
-    // 出了些问题
-  }
-});
-
                                    -

                                    从Map读取数据

                                    -

                                    您可以使用 get 方法从Map读取数据。get 方法也是异步的，一段时间过后它会通知处理器并传入结果。

                                    -
                                    map.get("foo", resGet -> {
-  if (resGet.succeeded()) {
-    // Successfully got the value
-    // 成功读取值
-    Object val = resGet.result();
-  } else {
-    // Something went wrong!
-    // 出了些问题
-  }
-});
-
                                    -

                                    其他Map操作

                                    -

                                    您还可以从异步Map中删除条目、清除Map、读取它的大小。

                                    -

                                    有关更多信息，请参阅 API 文档。

                                    -

                                    集群范围锁

                                    -

                                    集群范围锁（Lock）允许您在集群中获取独占锁 —— 当您想要在任何时间只在集群一个节点上执行某些操作或访问资源时，这很有用。

                                    -

                                    集群范围锁具有异步API，它和大多数等待锁释放的阻塞调用线程的API锁不相同。

                                    -

                                    可使用 getLock 方法获取锁。

                                    -

                                    它不会阻塞，但当锁可用时，将 Lock 的实例传入处理器并调用它，表示您现在拥有该锁。

                                    -

                                    若您拥有的锁没有其他调用者，集群上的任何地方都可以获得该锁。

                                    -

                                    当您用完锁后，您可以调用 release 方法来释放它，以便另一个调用者可获得它。

                                    -
                                    sd.getLock("mylock", res -> {
-  if (res.succeeded()) {
-    // Got the lock!
-    // 获得锁
-    Lock lock = res.result();
-
-    // 5 seconds later we release the lock so someone else can get it
-    // 5秒后我们释放该锁其他人可以得到它
-    vertx.setTimer(5000, tid -> lock.release());
-
-  } else {
-    // Something went wrong
-    // 出了些问题
-  }
-});
-
                                    -

                                    您可以为锁设置一个超时，若在超时时间期间无法获取锁，将会进入失败状态，处理器会去处理对应的异常：

                                    -
                                    sd.getLockWithTimeout("mylock", 10000, res -> {
-  if (res.succeeded()) {
-    // Got the lock!
-    // 获得锁
-    Lock lock = res.result();
-
-  } else {
-    // Failed to get lock
-    // 锁获取失败
-  }
-});
-
                                    -

                                    集群范围计时器

                                    -

                                    很多时候我们需要在集群范围内维护一个原子计数器。

                                    -

                                    您可以用 Counter 来做到这一点。

                                    -

                                    您可以通过 getCounter 方法获取一个实例：

                                    -
                                    sd.getCounter("mycounter", res -> {
-  if (res.succeeded()) {
-    Counter counter = res.result();
-  } else {
-    // Something went wrong!
-    // 出了些问题
-  }
-});
-
                                    -

                                    一旦您有了一个实例，您可以获取当前的计数，以原子方式递增、递减，并使用各种方法添加一个值。

                                    -

                                    有更多信息，请参阅 API 文档。

                                    -

                                    访问文件系统

                                    -

                                    Vert.x 中的 FileSystem 对象提供了许多操作文件系统的方法。

                                    -

                                    每个Vert.x 实例有一个文件系统对象，您可以使用 fileSystem 方法获取它。

                                    -

                                    每个操作都提供了阻塞和非阻塞版本，其中非阻塞版本接受一个处理器 Handler，当操作完成或发生错误时调用该处理器。

                                    -

                                    以下是文件异步拷贝的示例：

                                    -
                                    FileSystem fs = vertx.fileSystem();
-
-// Copy file from foo.txt to bar.txt
-// 从foo.txt拷贝到bar.txt
-fs.copy("foo.txt", "bar.txt", res -> {
-    if (res.succeeded()) {
-        // Copied ok!
-        // 拷贝完成
-    } else {
-        // Something went wrong
-        // 出了些问题
-    }
-});
-
                                    -

                                    阻塞版本的方法名为 xxxBlocking，它要么返回结果或直接抛出异常。很多情况下，一些潜在的阻塞操作可以快速返回（这取决于操作系统和文件系统），这就是我们为什么提供它。但是强烈建议您在 Event Loop 中使用它之前测试使用它们究竟需要耗费多长时间，以避免打破黄金法则。

                                    -

                                    以下是使用阻塞 API的拷贝示例：

                                    -
                                    FileSystem fs = vertx.fileSystem();
-
-// Copy file from foo.txt to bar.txt synchronously
-// 同步拷贝从foo.txt到bar.txt
-fs.copyBlocking("foo.txt", "bar.txt");
-
                                    -

                                    Vert.x 文件系统支持诸如 copy、move、truncate、chmod 和许多其他文件操作。我们不会在这里列出所有内容，请参考 API 文档 获取完整列表。

                                    -

                                    让我们看看使用异步方法的几个例子：

                                    -
                                    Vertx vertx = Vertx.vertx();
-
-// Read a file
-// 读取文件
-vertx.fileSystem().readFile("target/classes/readme.txt", result -> {
-    if (result.succeeded()) {
-        System.out.println(result.result());
-    } else {
-        System.err.println("Oh oh ..." + result.cause());
-    }
-});
-
-// Copy a file
-// 拷贝文件
-vertx.fileSystem().copy("target/classes/readme.txt", "target/classes/readme2.txt", result -> {
-    if (result.succeeded()) {
-        System.out.println("File copied");
-    } else {
-        System.err.println("Oh oh ..." + result.cause());
-    }
-});
-
-// Write a file
-// 写文件
-vertx.fileSystem().writeFile("target/classes/hello.txt", Buffer.buffer("Hello"), result -> {
-    if (result.succeeded()) {
-        System.out.println("File written");
-    } else {
-        System.err.println("Oh oh ..." + result.cause());
-    }
-});
-
-// Check existence and delete
-// 检测存在以及删除
-vertx.fileSystem().exists("target/classes/junk.txt", result -> {
-    if (result.succeeded() && result.result()) {
-        vertx.fileSystem().delete("target/classes/junk.txt", r -> {
-            System.out.println("File deleted");
-        });
-    } else {
-        System.err.println("Oh oh ... - cannot delete the file: " + result.cause());
-    }
-});
-
                                    -

                                    异步文件访问

                                    -

                                    Vert.x提供了异步文件访问的抽象，允许您操作文件系统上的文件。

                                    -

                                    您可以像下边代码打开一个 AsyncFile ：

                                    -
                                    OpenOptions options = new OpenOptions();
-fileSystem.open("myfile.txt", options, res -> {
-    if (res.succeeded()) {
-        AsyncFile file = res.result();
-    } else {
-        // Something went wrong!
-        // 出了些问题
-    }
-});
-
                                    -

                                    AsyncFile 实现了 ReadStream 和 WriteStream 接口，因此您可以将文件和其他流对象配合 泵 工作，如 NetSocket、HTTP 请求和响应和 WebSocket 等。

                                    -

                                    它们还允许您直接读写。

                                    -

                                    随机访问写

                                    -

                                    要使用AsyncFile进行随机访问写，请使用 write 方法。

                                    -

                                    这个方法的参数有：

                                    -
                                      -
                                    • buffer：要写入的缓冲
                                      • -
                                    • position：一个整数指定在文件中写入缓冲的位置，若位置大于或等于文件大小，文件将被扩展以适应偏移的位置
                                      • -
                                    • handler：结果处理器
                                      • -
                                    -

                                    这是随机访问写的示例：

                                    -
                                    Vertx vertx = Vertx.vertx();
-vertx.fileSystem().open("target/classes/hello.txt", new OpenOptions(), result -> {
-    if (result.succeeded()) {
-        AsyncFile file = result.result();
-        Buffer buff = Buffer.buffer("foo");
-        for (int i = 0; i < 5; i++) {
-            file.write(buff, buff.length() * i, ar -> {
-                if (ar.succeeded()) {
-                    System.out.println("Written ok!");
-                    // etc
-                    // 等
-                } else {
-                    System.err.println("Failed to write: " + ar.cause());
-                }
-            });
-        }
-    } else {
-        System.err.println("Cannot open file " + result.cause());
-    }
-});
-
                                    -

                                    随机访问读

                                    -

                                    要使用AsyncFile进行随机访问读，请使用 read 方法。

                                    -

                                    该方法的参数有：

                                    -
                                      -
                                    • buffer：读取数据的 Buffer
                                      • -
                                    • offset：读取数据将被放到 Buffer 中的偏移量
                                      • -
                                    • position：从文件中读取数据的位置
                                      • -
                                    • length：要读取的数据的字节数
                                      • -
                                    • handler：结果处理器
                                      • -
                                    -

                                    一下是随机访问读的示例：

                                    -
                                    Vertx vertx = Vertx.vertx();
-vertx.fileSystem().open("target/classes/les_miserables.txt", new OpenOptions(), result -> {
-    if (result.succeeded()) {
-        AsyncFile file = result.result();
-        Buffer buff = Buffer.buffer(1000);
-        for (int i = 0; i < 10; i++) {
-            file.read(buff, i * 100, i * 100, 100, ar -> {
-                if (ar.succeeded()) {
-                    System.out.println("Read ok!");
-                } else {
-                    System.err.println("Failed to write: " + ar.cause());
-                }
-            });
-        }
-    } else {
-        System.err.println("Cannot open file " + result.cause());
-    }
-});
-
                                    -

                                    打开选项

                                    -

                                    打开 AsyncFile 时，您可以传递一个 OpenOptions 实例，这些选项描述了访问文件的行为。例如：您可使用 setRead、setWrite 和 setPerm 方法配置文件访问权限。

                                    -

                                    若打开的文件已经存在，则可以使用 setCreateNew 和 setTruncateExisting 配置对应行为。

                                    -

                                    您可以使用 setDeleteOnClose 标记在关闭时或JVM停止时要删除的文件。

                                    -

                                    将数据刷新到底层存储

                                    -

                                    在 OpenOptions 中，您可以使用 setDsync 方法在每次写入时启用/禁用内容的自动同步。这种情况下，您可以使用 flush 方法手动刷新OS缓存中的数据写入。

                                    -

                                    该方法也可使用一个处理器来调用，这个处理器在 flush 完成时被调用。

                                    -

                                    将 AsyncFile 作为 ReadStream 和 WriteStream

                                    -

                                    AsyncFile实现了 ReadStream 和 WriteStream 接口。您可以使用泵将数据与其他读取和写入流进行数据泵送。例如，这会将内容复制到另外一个AsyncFile：

                                    -
                                    Vertx vertx = Vertx.vertx();
-final AsyncFile output = vertx.fileSystem().openBlocking("target/classes/plagiary.txt", new OpenOptions());
-
-vertx.fileSystem().open("target/classes/les_miserables.txt", new OpenOptions(), result -> {
-    if (result.succeeded()) {
-        AsyncFile file = result.result();
-        Pump.pump(file, output).start();
-        file.endHandler((r) -> {
-            System.out.println("Copy done");
-        });
-    } else {
-        System.err.println("Cannot open file " + result.cause());
-    }
-});
-
                                    -

                                    您还可以使用泵将文件内容写入到HTTP 响应中，或者写入任意 WriteStream。

                                    -

                                    从 Classpath 访问文件

                                    -

                                    当Vert.x找不到文件系统上的文件时，它尝试从类路径中解析该文件。请注意，类路径的资源路径不以 / 开头。

                                    -

                                    由于Java不提供对类路径资源的异步方法，所以当类路径资源第一次被访问时，该文件将复制到工作线程中的文件系统。当第二次访问相同资源时，访问的文件直接从（工作线程的）文件系统提供。即使类路径资源发生变化（例如开发系统中），也会提供原始内容。

                                    -

                                    您可以将系统属性vertx.disableFileCaching设置为true，禁用此（文件）缓存行为。文件缓存的路径默认为.vertx，它可以通过设置系统属性vertx.cacheDirBase进行自定义。

                                    -

                                    您还可以通过系统属性vertx.disableFileCPResolving设置为true来禁用整个类路径解析功能。

                                    -
                                    -

                                    请注意：当加载io.vertx.core.impl.FileResolver类时，这些系统属性将被评估一次，因此，在加载此类之前应该设置这些属性，或者在启动它时作为JVM系统属性来设置。

                                    -
                                    -

                                    关闭 AsyncFile

                                    -

                                    您可调用 close 方法来关闭 AsyncFile。关闭是异步的，如果希望在关闭过后收到通知，您可指定一个处理器作为函数（close）参数传入。

                                    -

                                    数据报套接字（UDP）

                                    -

                                    在Vert.x中使用用户数据报协议（UDP）就是小菜一碟。

                                    -

                                    UDP是无连接的传输，这意味着您与远程客户端没有建立持续的连接。

                                    -

                                    所以，您发送和接收的数据包都要包含有远程的地址。

                                    -

                                    除此之外，UDP不像TCP的使用那样安全，这也就意味着不能保证发送的数据包一定会被对应的接收端（Endpoint）接收。

                                    -

                                    唯一的保证是，它既不会被完全接收到，也不会完全不被接收到，即只有部分会被接收到。

                                    -

                                    因为每一个数据包将会作为一个包发送，所以在通常情况下您不能发送大于网络接口的最大传输单元（MTU）的数据包。

                                    -

                                    但是要注意，即使数据包尺寸小于MTU，它仍然可能会发送失败。

                                    -

                                    它失败的尺寸取决于操作系统等（其他原因），所以按照经验法则就是尝试发送小数据包。

                                    -

                                    依照UDP的本质，它最适合一些允许丢弃数据包的应用（如监视应用程序）。

                                    -

                                    其优点是与TCP相比具有更少的开销，而且可以由NetServer和NetClient处理（参考前文）。

                                    -

                                    创建 DatagramSocket

                                    -

                                    要使用UDP，您首先要创建一个 DatagramSocket 实例，无论您是要仅仅发送数据或者收发数据，这都是一样的。

                                    -
                                    DatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions());
-
                                    -

                                    返回的 DatagramSocket 实例不会绑定到特定端口，如果您只想发送数据（如作为客户端）的话，这是没问题的，但更多详细的内容在下一节。

                                    -

                                    发送数据报包

                                    -

                                    如上所述，用户数据报协议（UDP）将数据分组发送给远程对等体，但是以不持续的方式来传送到它们。

                                    -

                                    这意味着每个数据包都可以发送到不同的远程对等体。

                                    -

                                    发送数据包很容易，如下所示：

                                    -
                                    DatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions());
-Buffer buffer = Buffer.buffer("content");
-// 发送Buffer
-socket.send(buffer, 1234, "10.0.0.1", asyncResult -> {
-  System.out.println("Send succeeded? " + asyncResult.succeeded());
-});
-// 发送一个字符串
-socket.send("A string used as content", 1234, "10.0.0.1", asyncResult -> {
-  System.out.println("Send succeeded? " + asyncResult.succeeded());
-});
-
                                    -

                                    接收数据报包

                                    -

                                    若您想要接收数据包，则您需要调用 listen(...) 方法绑定 DatagramSocket。

                                    -

                                    这样您就可以接收到被发送至 DatagramSocket 所监听的地址和端口的 DatagramPacket。

                                    -

                                    除此之外，您还要设置一个Handler，每接收到一个 DatagramPacket 时它都会被调用。

                                    -

                                    DatagramPacket 有以下方法：

                                    -
                                      -
                                    • sender：表示数据发送方的InetSocketAddress。
                                      • -
                                    • data：保存接收数据的Buffer。
                                      • -
                                    -

                                    当您需要监听一个特定地址和端口时，您可以像下边这样：

                                    -
                                    DatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions());
-socket.listen(1234, "0.0.0.0", asyncResult -> {
-  if (asyncResult.succeeded()) {
-    socket.handler(packet -> {     
-      // 对包进行处理
-   });
-  } else {
-    System.out.println("Listen failed" + asyncResult.cause());
-  }
-});
-
                                    -

                                    注意，即使 AsyncResult 成功，它只意味着它可能已经写入了网络堆栈，但不保证它已经到达或者将到达远端。

                                    -

                                    若您需要这样的保证，您可在TCP之上建立一些握手逻辑。

                                    -

                                    多播

                                    -

                                    发送多播数据包

                                    -

                                    多播允许多个Socket接收相同的数据包，该目标可以通过加入到同一个可发送数据包的多播组来实现。

                                    -

                                    我们将在下一节中介绍如何加入多播组，从而接收数据包。

                                    -

                                    现在让我们专注于如何发送多播报文，发送多播报文与发送普通数据报报文没什么不同。

                                    -

                                    唯一的区别是您可以将多播组的地址传递给 send 方法发送出去。

                                    -

                                    如下所示：

                                    -
                                    DatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions());
-Buffer buffer = Buffer.buffer("content");
-// Send a Buffer to a multicast address
-// 发送Buffer到多播地址
-socket.send(buffer, 1234, "230.0.0.1", asyncResult -> {
-  System.out.println("Send succeeded? " + asyncResult.succeeded());
-});
-
                                    -

                                    所有已经加入多播组 230.0.0.1 的Socket都将收到该报文。

                                    -

                                    接收多播数据包

                                    -

                                    若要接收特定多播组的数据包，您需要通过调用 DatagramSocket 的listen(...)方法来绑定一个地址并且加入多播组，并加入多播组。

                                    -

                                    这样，您将能够接收到被发送到 DatagramSocket 所监听的地址和端口的数据报，同时也可以接收被发送到该多播组的数据报。

                                    -

                                    除此之外，您还可设置一个处理器，它在每次接收到 DatagramPacket 时会被调用。

                                    -

                                    DatagramPacket 有以下方法：

                                    -
                                      -
                                    • sender()：表示数据报发送方的InetSocketAddress
                                      • -
                                    • data()：保存接收数据的Buffer
                                      • -
                                    -

                                    因此，要监听指定的地址和端口、并且接收多播组230.0.0.1的数据报，您将执行如下操作：

                                    -
                                    DatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions());
-socket.listen(1234, "0.0.0.0", asyncResult -> {
-  if (asyncResult.succeeded()) {
-    socket.handler(packet -> {    
-      // 对数据包进行处理
-    });
-
-    // 加入多播组
-    socket.listenMulticastGroup("230.0.0.1", asyncResult2 -> {
-        System.out.println("Listen succeeded? " + asyncResult2.succeeded());
-    });
-  } else {
-    System.out.println("Listen failed" + asyncResult.cause());
-  }
-});
-
                                    -

                                    取消订阅/离开多播组

                                    -

                                    有时候您想只在特定时间内接收多播组的数据包。

                                    -

                                    这种情况下，您可以先监听他们，之后再取消监听。

                                    -

                                    如下所示：

                                    -
                                    DatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions());
-socket.listen(1234, "0.0.0.0", asyncResult -> {
-    if (asyncResult.succeeded()) {
-      socket.handler(packet -> {
-        // Do something with the packet
-        // 处理数据报
-     });
-
-      // join the multicast group
-      // 加入多播组
-      socket.listenMulticastGroup("230.0.0.1", asyncResult2 -> {
-          if (asyncResult2.succeeded()) {
-            // will now receive packets for group
-            // 现在将接收组的数据包
-            // do some work
-            // 做一些工作
-            socket.unlistenMulticastGroup("230.0.0.1", asyncResult3 -> {
-              System.out.println("Unlisten succeeded? " + asyncResult3.succeeded());
-            });
-          } else {
-            System.out.println("Listen failed" + asyncResult2.cause());
-          }
-      });
-    } else {
-      System.out.println("Listen failed" + asyncResult.cause());
-    }
-});
-
                                    -

                                    屏蔽多播

                                    -

                                    除了取消监听一个多播地址以外，也可以做到屏蔽指定发送者地址的多播。

                                    -

                                    请注意这仅适用于某些操作系统和内核版本，所以请检查操作系统文档看是它是否支持。

                                    -

                                    这是专家级别的技巧。

                                    -

                                    要屏蔽来自特定地址的多播，您可以在 DatagramSocket 上调用 blockMulticastGroup(...)，如下所示：

                                    -
                                    DatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions());
-
-// Some code
-// 一些代码
-
-// This would block packets which are send from 10.0.0.2
-// 这将阻止从10.0.0.2发送的数据包
-socket.blockMulticastGroup("230.0.0.1", "10.0.0.2", asyncResult -> {
-  System.out.println("block succeeded? " + asyncResult.succeeded());
-});
-
                                    -

                                    DatagramSocket 属性

                                    -

                                    当创建DatagramSocket时，您可以通过DatagramSocketOptions对象来设置多个属性以更改它的功能。这些（属性）列在这儿：

                                    -
                                      -
                                    • setSendBufferSize以字节为单位设置发送缓冲区的大小。
                                      • -
                                    • setReceiveBufferSize设置TCP接收缓冲区大小（以字节为单位）。
                                      • -
                                    • setReuseAddress若为true，则TIME_WAIT状态中的地址在关闭后可重用。
                                      • -
                                    • setTrafficClass
                                      • -
                                    • setBroadcast设置或清除SO_BROADCAST套接字选项，设置此选项时，数据报（UDP）数据包可能会发送到本地接口的广播地址。
                                      • -
                                    • setMulticastNetworkInterface设置或清除IP_MULTICAST_LOOP套接字选项，设置此选项时，多播数据包也将在本地接口上接收。
                                      • -
                                    • setMulticastTimeToLive设置IP_MULTICAST_TTL套接字选项。TTL表示“活动时间”，单这种情况下，它指定允许数据包经过的IP跳数，特别是用于多播流量。转发数据包的每个路由器或网管会递减TTL，如果路由器将TTL递减为0，则不会再转发。
                                      • -
                                    -

                                    DatagramSocket本地地址

                                    -

                                    若您在调用listen(...)之前已经绑定了DatagramSocket，您可以通过调用localAddress来查找套接字的本地地址（即UDP Socket这边的地址，它将返回一个InetSocketAddress，否则返回null。

                                    -

                                    关闭DatagramSocket

                                    -

                                    您可以通过调用close方法来关闭Socket，它将关闭Socket并释放所有资源。

                                    -

                                    DNS 客户端

                                    -

                                    通常情况下，您需要以异步方式来获取DNS信息。

                                    -

                                    但不幸的是，Java 虚拟机本身附带的API是不可能的，因此Vert.x提供了它自己的完全异步解析DNS的API。

                                    -

                                    若要获取 DnsClient 实例，您可以通过 Vertx 实例来创建一个。

                                    -
                                    DnsClient client = vertx.createDnsClient(53, "10.0.0.1");
-
                                    -

                                    请注意，您可以传入 InetSocketAddress 参数的变量，以指定多个的DNS服务器来尝试查询解析DNS。它将按照此处指定的相同顺序查询DNS服务器，若在使用上一个DNS服务器解析时出现了错误，下一个将会被继续调用。

                                    -

                                    lookup

                                    -

                                    当尝试为一个指定名称元素获取A（ipv4）或 AAAA（ipv6）记录时，第一条被返回的（记录）将会被使用。它的操作方式和操作系统上使用 nslookup 类似。

                                    -

                                    要为 vertx.io 获取 A/AAAA 记录，您需要像下面那样做：

                                    -
                                    DnsClient client = vertx.createDnsClient(53, "10.0.0.1");
-client.lookup("vertx.io", ar -> {
-  if (ar.succeeded()) {
-    System.out.println(ar.result());
-  } else {
-    System.out.println("Failed to resolve entry" + ar.cause());
-  }
-});
-
                                    -

                                    lookup4

                                    -

                                    尝试查找给定名称的A（ipv4）记录。第一个返回的（记录）将会被使用，因此它的操作方式与操作系统上使用nslookup类似。

                                    -

                                    要查找 vertx.io 的A记录，您需要像下面那样做：

                                    -
                                    DnsClient client = vertx.createDnsClient(53, "10.0.0.1");
-client.lookup4("vertx.io", ar -> {
-  if (ar.succeeded()) {
-    System.out.println(ar.result());
-  } else {
-    System.out.println("Failed to resolve entry" + ar.cause());
-  }
-});
-
                                    -

                                    lookup6

                                    -

                                    尝试查找给定名称的 AAAA（ipv6）记录。第一个返回的（记录）将会被使用，因此它的操作方式与在操作系统上使用 nslookup 类似。

                                    -

                                    要查找 vertx.io 的 AAAA记录，您需要像下面那样做：

                                    -
                                    DnsClient client = vertx.createDnsClient(53, "10.0.0.1");
-client.lookup6("vertx.io", ar -> {
-  if (ar.succeeded()) {
-    System.out.println(ar.result());
-  } else {
-    System.out.println("Failed to resolve entry" + ar.cause());
-  }
-});
-
                                    -

                                    resolveA

                                    -

                                    尝试解析给定名称的所有A（ipv4）记录，这与在unix操作系统上使用dig类似。

                                    -

                                    要查找vertx.io的所有A记录，您通常会执行以下操作：

                                    -
                                    DnsClient client = vertx.createDnsClient(53, "10.0.0.1");
-client.resolveA("vertx.io", ar -> {
-  if (ar.succeeded()) {
-    List<String> records = ar.result();
-    for (String record : records) {
-      System.out.println(record);
-    }
-  } else {
-    System.out.println("Failed to resolve entry" + ar.cause());
-  }
-});
-
                                    -

                                    resolveAAAA

                                    -

                                    尝试解析给定名称的所有AAAA（ipv6）记录，这与在Unix操作系统上使用dig类似。

                                    -

                                    要查找vertx.io的所有AAAA记录，您通常会执行以下操作：

                                    -
                                    DnsClient client = vertx.createDnsClient(53, "10.0.0.1");
-client.resolveAAAA("vertx.io", ar -> {
-  if (ar.succeeded()) {
-    List<String> records = ar.result();
-    for (String record : records) {
-      System.out.println(record);
-    }
-  } else {
-    System.out.println("Failed to resolve entry" + ar.cause());
-  }
-});
-
                                    -

                                    resolveCNAME

                                    -

                                    尝试解析给定名称的所有CNAME记录，这与在Unix操作系统上使用dig类似。

                                    -

                                    要查找vertx.io的所有CNAME记录，您通常会执行以下操作：

                                    -
                                    DnsClient client = vertx.createDnsClient(53, "10.0.0.1");
-client.resolveCNAME("vertx.io", ar -> {
-  if (ar.succeeded()) {
-    List<String> records = ar.result();
-    for (String record : records) {
-      System.out.println(record);
-    }
-  } else {
-    System.out.println("Failed to resolve entry" + ar.cause());
-  }
-});
-
                                    -

                                    resolveMX

                                    -

                                    尝试解析给定名称的所有MX记录，MX记录用于定义哪个邮件服务器接受给定域的电子邮件。

                                    -

                                    要查找您常用执行的vertx.io的所有MX记录：

                                    -
                                    DnsClient client = vertx.createDnsClient(53, "10.0.0.1");
-client.resolveMX("vertx.io", ar -> {
-  if (ar.succeeded()) {
-    List<MxRecord> records = ar.result();
-    for (MxRecord record: records) {
-      System.out.println(record);
-    }
-  } else {
-    System.out.println("Failed to resolve entry" + ar.cause());
-  }
-});
-
                                    -

                                    请注意，列表将包含按照它们优先级排序的MxRecord，这意味着列表中优先级低的MX记录会第一个优先出现在列表中。

                                    -

                                    MxRecord允许您通过下边提供的方法访问MX记录的优先级和名称：

                                    -
                                    record.priority();
-record.name();
-
                                    -

                                    resolveTXT

                                    -

                                    尝试解析给定名称的所有TXT记录，TXT记录通常用于定义域的额外信息。

                                    -

                                    要解析vertx.io的所有TXT记录，您可以使用下边几行：

                                    -
                                    DnsClient client = vertx.createDnsClient(53, "10.0.0.1");
-client.resolveTXT("vertx.io", ar -> {
-  if (ar.succeeded()) {
-    List<String> records = ar.result();
-    for (String record: records) {
-      System.out.println(record);
-    }
-  } else {
-    System.out.println("Failed to resolve entry" + ar.cause());
-  }
-});
-
                                    -

                                    resolveNS

                                    -

                                    尝试解析给定名称的所有NS记录，NS记录指定哪个DNS服务器托管给定域的DNS信息。

                                    -

                                    要解析vertx.io的所有NS记录，您可以使用下边几行：

                                    -
                                    DnsClient client = vertx.createDnsClient(53, "10.0.0.1");
-client.resolveNS("vertx.io", ar -> {
-  if (ar.succeeded()) {
-    List<String> records = ar.result();
-    for (String record: records) {
-      System.out.println(record);
-    }
-  } else {
-    System.out.println("Failed to resolve entry" + ar.cause());
-  }
-});
-
                                    -

                                    resolveSRV

                                    -

                                    尝试解析给定名称的所有SRV记录，SRV记录用于定义服务端口和主机名等额外信息。一些协议需要这个额外信息。

                                    -

                                    要查找vertx.io的所有SRV记录，您通常会执行以下操作：

                                    -
                                    DnsClient client = vertx.createDnsClient(53, "10.0.0.1");
-client.resolveSRV("vertx.io", ar -> {
-  if (ar.succeeded()) {
-    List<SrvRecord> records = ar.result();
-    for (SrvRecord record: records) {
-      System.out.println(record);
-    }
-  } else {
-    System.out.println("Failed to resolve entry" + ar.cause());
-  }
-});
-
                                    -

                                    请注意，列表将包含按照它们优先级排序的SrvRecord，这意味着优先级低的记录会第一个优先出现在列表中。

                                    -

                                    SrvRecord允许您访问SRV记录本身中包含的所有信息：

                                    -
                                    record.priority();
-record.name();
-record.weight();
-record.port();
-record.protocol();
-record.service();
-record.target();
-
                                    -

                                    有关详细信息，请参阅API文档。

                                    -

                                    resolvePTR

                                    -

                                    尝试解析给定名称的PTR记录，PTR记录将ipaddress映射到名称。

                                    -

                                    要解析IP地址10.0.0.1的PTR记录，您将使用1.0.0.10.in-addr.arpa的PTR概念。

                                    -
                                    DnsClient client = vertx.createDnsClient(53, "10.0.0.1");
-client.resolvePTR("1.0.0.10.in-addr.arpa", ar -> {
-  if (ar.succeeded()) {
-    String record = ar.result();
-    System.out.println(record);
-  } else {
-    System.out.println("Failed to resolve entry" + ar.cause());
-  }
-});
-
                                    -

                                    reverseLookup

                                    -

                                    尝试对ipaddress进行反向查找，这与解析PTR记录类似，但是允许您只传递ipaddress，而不是有效的PTR查询字符串。

                                    -

                                    要做ipaddress 10.0.0.1的反向查找类似的事：

                                    -
                                    DnsClient client = vertx.createDnsClient(53, "10.0.0.1");
-client.reverseLookup("10.0.0.1", ar -> {
-  if (ar.succeeded()) {
-    String record = ar.result();
-    System.out.println(record);
-  } else {
-    System.out.println("Failed to resolve entry" + ar.cause());
-  }
-});
-
                                    -

                                    错误处理

                                    -

                                    如前边部分所述，DnsClient 允许您传递一个Handler，一旦查询完成将会传入一个AsyncResult给Handler并通知它。

                                    -

                                    在出现错误的情况下，通知中将包含一个DnsException，该异常会包含一个说明为何失败的DnsResponseCode。此DnsResponseCode可用于更详细检查原因。

                                    -

                                    可能的DnsResponseCode值是：

                                    - -

                                    所有这些错误都由DNS服务器本身“生成”，您可以从 DnsException 中获取 DnsResponseCode，如：

                                    -
                                    DnsClient client = vertx.createDnsClient(53, "10.0.0.1");
-client.lookup("nonexisting.vert.xio", ar -> {
-  if (ar.succeeded()) {
-    String record = ar.result();
-    System.out.println(record);
-  } else {
-    Throwable cause = ar.cause();
-    if (cause instanceof DnsException) {
-      DnsException exception = (DnsException) cause;
-      DnsResponseCode code = exception.code();
-      // ...
-    } else {
-      System.out.println("Failed to resolve entry" + ar.cause());
-    }
-  }
-});
-
                                    -

                                    流

                                    -

                                    Vert.x有多个对象可以用于文件的读取和写入。

                                    -

                                    在以前的版本中，只能通过操作指定的 Buffer 对象来实现文件读写。从现在开始，流不再与 Buffer 耦合，它们可以和任意类型的对象一起工作。

                                    -

                                    在 Vert.x 中，写调用是立即返回的，而写操作的实际是在内部队列中排队写入。

                                    -

                                    不难看出，若写入对象的速度比实际写入底层数据资源速度快，那么写入队列就会无限增长，最终导致内存耗尽。

                                    -

                                    为了解决这个问题，Vert.x API中的一些对象提供了简单的流程控制（回压）功能。

                                    -

                                    任何可控制的写入流对象都实现了 WriteStream 接口，相应的，任何可控制的读取流对象都实现了 ReadStream 接口。

                                    -

                                    让我们举个例子，我们要从ReadStream中读取数据，然后将数据写入WriteStream。

                                    -

                                    一个非常简单的例子是从NetSocket读取然后写回到同一个NetSocket —— 因为NetSocket既实现了ReadStream也实现了WriteStream 接口。请注意，这些操作适用于任何实现了ReadStream和 WriteStream 接口的对象，包括HTTP 请求、HTTP 响应、异步文件 I/O 和 WebSocket等。

                                    -

                                    一个最简单的方法是直接获取已经读取的数据，并立即将其写入NetSocket：

                                    -
                                    NetServer server = vertx.createNetServer(
-    new NetServerOptions().setPort(1234).setHost("localhost")
-);
-server.connectHandler(sock -> {
-  sock.handler(buffer -> {
-    // Write the data straight back
-    // 直接写入数据
-    sock.write(buffer);
-  });
-}).listen();
-
                                    -

                                    上面的例子有一个问题：如果从Socket读取数据的速度比写回Socket的速度快，那么它将在NetSocket的写队列中不断堆积，最终耗尽内存。这是有可能会发生，例如，若Socket另一端的客户端读取速度不够快，无法快速地向连接的另一端回压。

                                    -

                                    由于 NetSocket 实现了 WriteStream 接口，我们可以在写入之前检查 WriteStream 是否已满：

                                    -
                                    NetServer server = vertx.createNetServer(
-    new NetServerOptions().setPort(1234).setHost("localhost")
-);
-server.connectHandler(sock -> {
-  sock.handler(buffer -> {
-    if (!sock.writeQueueFull()) {
-      sock.write(buffer);
-    }
-  });
-
-}).listen();
-
                                    -

                                    这个例子不会耗尽内存，但如果写入队列已满，我们最终会丢失数据。我们真正想要做的是在写入队列已满时暂停读取 NetSocket：

                                    -
                                    NetServer server = vertx.createNetServer(
-    new NetServerOptions().setPort(1234).setHost("localhost")
-);
-server.connectHandler(sock -> {
-  sock.handler(buffer -> {
-    sock.write(buffer);
-    if (sock.writeQueueFull()) {
-      sock.pause();
-    }
-  });
-}).listen();
-
                                    -

                                    我们已经快达到我们的目标，但还没有完全实现。现在 NetSocket 在文件已满时会暂停，但是当写队列处理完成时，我们需要取消暂停：

                                    -
                                    NetServer server = vertx.createNetServer(
-    new NetServerOptions().setPort(1234).setHost("localhost")
-);
-server.connectHandler(sock -> {
-  sock.handler(buffer -> {
-    sock.write(buffer);
-    if (sock.writeQueueFull()) {
-      sock.pause();
-      sock.drainHandler(done -> {
-        sock.resume();
-      });
-    }
-  });
-}).listen();
-
                                    -

                                    在这里，我们的目标实现了。当写队列准备好接收更多的数据时，drainHandler事件处理器将被调用，它会恢复NetSocket的状态，允许读取更多的数据。

                                    -

                                    在编写Vert.x 应用程序时，这样做是很常见的，因此我们提供了一个名为Pump的帮助类，它为您完成所有这些艰苦的工作。您只需要给 ReadStream 追加上 WriteStream，然后启动它：

                                    -
                                    NetServer server = vertx.createNetServer(
-    new NetServerOptions().setPort(1234).setHost("localhost")
-);
-server.connectHandler(sock -> {
-  Pump.pump(sock, sock).start();
-}).listen();
-
                                    -

                                    这和更加详细的例子完全一样。

                                    -

                                    现在我们来看看 ReadStream 和 WriteStream 的方法。

                                    -

                                    ReadStream

                                    -

                                    ReadStream（可读流） 接口的实现类包括：HttpClientResponse, DatagramSocket, HttpClientRequest, HttpServerFileUpload, HttpServerRequest, MessageConsumer, NetSocket, WebSocket, TimeoutStream, AsyncFile。

                                    -

                                    函数：

                                    -
                                      -
                                    • handler：设置一个处理器，它将从ReadStream读取项
                                      • -
                                    • pause：暂停处理器，暂停时，处理器中将不会受到任何项
                                      • -
                                    • resume：恢复处理器，若任何项到达则处理器将被调用
                                      • -
                                    • exceptionHandler若ReadStream发生异常，将被调用
                                      • -
                                    • endHandler：当流到达时将被调用。这有可能是到达了描述文件的EOF、达到HTTP请求的请求结束、或TCP Socket的连接被关闭
                                      • -
                                    -

                                    WriteStream

                                    -

                                    WriteStream（可写流）接口的实现类包括：HttpClientRequest, HttpServerResponse，WebSocket, NetSocket, AsyncFile, MessageProducer

                                    -

                                    函数：

                                    -
                                      -
                                    • write：写入一个对象到 WriteStream，该方法将永远不会阻塞，内部是排队写入并且底层资源是异步写入。
                                      • -
                                    • setWriteQueueMaxSize：设置写入队列被认为是 full 的对象的数量——方法writeQueueFull返回true。注意，当写队列被认为已满时，若写（操作）被调用则数据依然会被接收和排队。实际数量取决于流的实现，对于Buffer，尺寸代表实际写入的字节数，而并非缓冲区的数量。
                                      • -
                                    • writeQueueFull：若写队列被认为已满，则返回true。
                                      • -
                                    • exceptionHandler：若WriteStream发生异常，则被调用。
                                      • -
                                    • drainHandler：若WriteStream被认为不再满，则处理器将被调用。
                                      • -
                                    -

                                    泵

                                    -

                                    泵（Pump）的实例有以下几种方法：

                                    - -

                                    一个泵可以启动和停止多次。

                                    -

                                    当泵首次创建时，它不会启动，您需要调用 start() 方法来启动它。

                                    -

                                    记录解析器

                                    -

                                    记录解析器（Record Parser）允许您轻松解析由字节序列或固定尺寸带分隔符的记录的协议。

                                    -

                                    它将输入缓冲区序列转换为已配置的缓冲区序列（固定大小或带分隔符的记录）。

                                    -

                                    例如，若您使用\n分割的简单ASCII文本协议，并输入如下：

                                    -
                                    buffer1:HELLO\nHOW ARE Y
-buffer2:OU?\nI AM
-buffer3: DOING OK
-buffer4:\n
-

                                    记录解析器将生成下结果：

                                    -
                                    buffer1:HELLO
-buffer2:HOW ARE YOU?
-buffer3:I AM DOING OK
-

                                    我们来看看相关代码：

                                    -
                                    final RecordParser parser = RecordParser.newDelimited("\n", h -> {
-  System.out.println(h.toString());
-});
-
-parser.handle(Buffer.buffer("HELLO\nHOW ARE Y"));
-parser.handle(Buffer.buffer("OU?\nI AM"));
-parser.handle(Buffer.buffer("DOING OK"));
-parser.handle(Buffer.buffer("\n"));
-
                                    -

                                    我们还可以生成固定尺寸的块，如下：

                                    -
                                    RecordParser.newFixed(4, h -> {
-  System.out.println(h.toString());
-});
-
                                    -

                                    有关更多详细信息，请查看RecordParser类。

                                    -

                                    线程安全

                                    -

                                    大多数Vert.x 对象可以从被不同的线程安全地访问，但在相同的上下文中访问它们时，性能才是最优的。

                                    -

                                    例如，若您部署了一个创建NetServer的Verticle，该NetServer在处理器中提供了NetSocket 实例，则最好始终从该Verticle的Event Loop中访问Socket 实例。

                                    -

                                    如您坚持使用标准的Vert.x Verticle部署模型，避免在 Verticle 之间分享对象，那这种情况您无需考虑。

                                    -

                                    Metrics SPI

                                    -

                                    默认情况下，Vert.x不会记录任何指标。相反，它为其他人提供了一个SPI，可以将其添加到类路径中。SPI是一项高级功能，允许实施者从Vert.x捕获事件以收集指标。有关详细信息，请参阅 API 文档。

                                    -

                                    若使用setFactory嵌入了Vert.x实例，也可以用编程方式指定度量工厂。

                                    -

                                    OSGi

                                    -

                                    Vert.x Core被打包成了 OSGi Bundle，因此可以在任何OSGi R4.2+环境中使用，如 Apache Felix 或 Eclipse Equinox，（这个）Bundle导出io.vertx.core*。

                                    -

                                    但是 Bundle 对 Jackson 和 Netty 有一些依赖，若部署Vert.x Core Bundle则需要：

                                    -
                                      -
                                    • Jackson Annotation [2.6.0,3)
                                      • -
                                    • Jackson Core [2.6.2,3)
                                      • -
                                    • Jackson Databind [2.6.2,3)
                                      • -
                                    • Netty Buffer [4.0.31,5)
                                      • -
                                    • Netty Codec [4.0.31,5)
                                      • -
                                    • Netty Codec/Socks [4.0.31,5)
                                      • -
                                    • Netty Codec/Common [4.0.31,5)
                                      • -
                                    • Netty Codec/Handler [4.0.31,5)
                                      • -
                                    • Netty Codec/Transport [4.0.31,5)
                                      • -
                                    -

                                    下边是Apache Felix 5.2.0上的工作部署：

                                    -
                                    14|Active     |    1|Jackson-annotations (2.6.0)
-15|Active     |    1|Jackson-core (2.6.2)
-16|Active     |    1|jackson-databind (2.6.2)
-18|Active     |    1|Netty/Buffer (4.0.31.Final)
-19|Active     |    1|Netty/Codec (4.0.31.Final)
-20|Active     |    1|Netty/Codec/HTTP (4.0.31.Final)
-21|Active     |    1|Netty/Codec/Socks (4.0.31.Final)
-22|Active     |    1|Netty/Common (4.0.31.Final)
-23|Active     |    1|Netty/Handler (4.0.31.Final)
-24|Active     |    1|Netty/Transport (4.0.31.Final)
-25|Active     |    1|Netty/Transport/SCTP (4.0.31.Final)
-26|Active     |    1|Vert.x Core (3.1.0)
-

                                    在Equinox上，您可能需要使用下边的框架属性禁用ContextFilter：eclipse.bundle.setTCCL=false。

                                    -

                                    vertx 命令行

                                    -

                                    vertx 命令行工具用于在终端中与 Vert.x 进行交互。主要用于运行 Vert.x Verticle。为此，您需要下载并安装Vert.x 发行版，并将安装目录中的bin添加到PATH环境变量中，还要确保您的PATH上有一个Java 8的JDK。

                                    -
                                    -

                                    请注意：JDK需要支持Java代码的快速编译。

                                    -
                                    -

                                    运行 Verticle

                                    -

                                    您可以使用 vertx run 从命令行直接运行Vert.x 的 Verticle，以下是run命令的几个实例：

                                    -
                                    vertx run my-verticle.js                                 (1)
-vertx run my-verticle.groovy                             (2)
-vertx run my-verticle.rb                                 (3)
-
-vertx run io.vertx.example.MyVerticle                    (4)
-vertx run io.vertx.example.MVerticle -cp my-verticle.jar (5)
-
-vertx run MyVerticle.java                                (6)
-
                                      -
                                    1. 部署一个JavaScript的Verticle
                                      2. -
                                    2. 部署一个Groovy的Verticle
                                      3. -
                                    3. 部署一个Ruby的Verticle
                                      4. -
                                    4. 部署一个已经编译好的Java的Verticle，类的根路径是当前目录
                                      5. -
                                    5. 部署一个已经打包成jar的Verticle，这个jar需要在类路径中
                                      6. -
                                    6. 编译Java源代码并进行部署
                                      7. -
                                    -

                                    正如您在Java中可看到的，该Verticle的名称要么是Java 完全限定类名，也可以指定Java 源文件，Vert.x会为你编译它。

                                    -

                                    您可以用其他语言的前缀来指定Verticle的名称进行部署。例如：若Verticle是一个编译的Groovy 类，您可以使用语言前缀groovy:，因此Vert.x 知道它是一个Groovy 类而不是Java 类。

                                    -
                                    vertx run groovy:io.vertx.example.MyGroovyVerticle
-

                                    vertx run命令可以使用几个可选参数，它们是：

                                    -
                                      -
                                    • -conf <config_file>：提供了Verticle的一些配置，config_file是包含描述Verticle配置的JSON对象的文本文件的名称，该参数是可选的。
                                      • -
                                    • -cp <path>：搜索Verticle和它使用的其他任何资源的路径，默认为.（当前目录）。若您的Verticle引用了其他脚本、类或其他资源（例如jar文件），请确保这些脚本、其他资源存在此路径上。该路径可以包含由以下内容分隔的多个路径条目：:（冒号）或;（分号）——这取决于操作系统。每个路径条目可以是包含脚本的目录的绝对路径或相对路径，也可以是jar或zip文件的绝对或相对文件名。一个示例路径可能是-cp classes:lib/otherscripts:jars/myjar.jar:jars/otherjar.jar。始终使用路径引用您的Verticle需要的任何资源，不要将它们放在系统类路径上，因为这会导致部署的Verticle之间的隔离问题。
                                      • -
                                    • -instances <instances>：要实例化的Verticle实例的数目，每个Verticle实例都是严格单线程（运行）的，以便在可用的核上扩展应用程序，您可能需要部署多个实例。若省略，则部署单个实例。
                                      • -
                                    • -worker：此选项可确定一个Verticle是否为Worker Verticle。
                                      • -
                                    • -cluster：此选项确定Vert.x实例是否尝试与网络上的其他Vert.x实例形成集群，集群Vert.x实例允许Vert.x与其他节点形成分布式Event Bus。默认为false（非集群模式）。
                                      • -
                                    • -cluster-port：若指定了cluster选项，则可以确定哪个端口将用于与其他Vert.x实例进行集群通信。默认为0——这意味着“选择一个空闲的随机端口”。除非您帧需要绑定特定端口，您通常不需要指定此参数。
                                      • -
                                    • -cluster-host：若指定了cluster选项，则可以确定哪个主机地址将用于其他Vert.x实例进行集群通信。默认情况下，它将尝试从可用的接口中选一个。若您有多个接口而您想要使用指定的一个，就在这里指定。
                                      • -
                                    • -ha：若指定，该Verticle将部署为（支持）高可用性（HA）。有关详细信息，请参阅相关章节。
                                      • -
                                    • -quorum：该参数需要和-ha一起使用，它指定集群中所有HA部署ID处于活动状态的最小节点数，默认为0。
                                      • -
                                    • -hagroup：该参数需要和-ha一起使用，它指定此节点将加入的HA组。集群中可以有多个HA组，节点只会故障转移到同一组中的其他节点。默认为__DEFAULT__。
                                      • -
                                    -

                                    您还可以使用下边方式设置系统属性：-Dkey=value。

                                    -

                                    下面有更多的例子：

                                    -

                                    使用默认设置运行JavaScript的Verticle：server.js：

                                    -
                                    vertx run server.js
-

                                    运行指定类路径的预编译好的10个Java Verticle实例

                                    -
                                    vertx run com.acme.MyVerticle -cp "classes:lib/myjar.jar" -instances 10
-

                                    通过源文件运行10个Java Verticle的实例

                                    -
                                    vertx run MyVerticle.java -instances 10
-

                                    运行20个Ruby语言的Worker Verticle实例

                                    -
                                    vertx run order_worker.rb -instances 20 -worker
-

                                    在同一台计算机上运行两个JavaScript Verticle，并让它们彼此在网络上的其他任何服务器上集群在一起：

                                    -
                                    vertx run handler.js -cluster
-vertx run sender.js -cluster
-

                                    运行一个Ruby Verticle并传入一些配置：

                                    -
                                    vertx run my_verticle.rb -conf my_verticle.conf
-

                                    其中my_verticle.conf也许会包含以下配置：

                                    -
                                    {
- "name": "foo",
- "num_widgets": 46
-}
-
                                    -

                                    该配置可通过Core API在Verticle内部可用。

                                    -

                                    当使用Vert.x的高可用功能时，您可能需要创建一个Vert.x的 裸 实例。此实例在启动时未部署任何Verticle，但它若接收到若集群中的另一个节点死亡，则会在此节点运行之前挂掉的实例。如需要创建一个 裸 实例，执行以下命令：

                                    -
                                    vertx bare
-

                                    根据您的集群配置，您可能需要添加cluster-host和cluster-port参数。

                                    -

                                    执行打包成 fat-jar 的Vert.x 应用

                                    -

                                    fat-jar 是一个包含了所有依赖项jar的可执行的jar，这意味着您不必在执行jar的机器上预先安装Vert.x。它像任何可执行的Java jar一样可直接执行：

                                    -
                                    java -jar my-application-fat.jar
-

                                    对于这点，Vert.x 没什么特别的，您可以使用任何Java应用程序。

                                    -

                                    您可以创建自己的主类并在 MANIFEST 中指定，但建议您将代码编写成Verticle，并使用Vert.x中的Launcher类（io.vertx.core.Launcher）作为您的主类。这是在命令行中运行Vert.x使用的主类，因此允许您指定命令行参数，如 -instances 以便更轻松地扩展应用程序。

                                    -

                                    要将您的Verticle全部部署在这个fat-jar中时，您必须将下边信息写入MANIFEST：

                                    -
                                      -
                                    • Main-Class设置为io.vertx.core.Launcher
                                      • -
                                    • Main-Verticle指定要运行的Main Verticle（Java完全限定类名或脚本文件名）
                                      • -
                                    -

                                    您还可以提供您将传递给 vertx run 的常用命令行参数：

                                    -
                                    java -jar my-verticle-fat.jar -cluster -conf myconf.json
-java -jar my-verticle-fat.jar -cluster -conf myconf.json -cp path/to/dir/conf/cluster_xml
-
                                    -

                                    注意：请参阅官方 Vert.x Examples 仓库中中的 Maven/Gradle 相应示例来了解如何将应用打包成 fat-jar。

                                    -
                                    -

                                    通过 fat jar 运行应用时，默认会执行 run 命令。

                                    -

                                    显示Vert.x的版本

                                    -

                                    若想显示Vert.x的版本，只需执行：

                                    -
                                    vertx version
-

                                    其他命令

                                    -

                                    除了run和version以外，vertx命令行和 Launcher 还提供了其他命令：

                                    -

                                    您可以使用下边命令创建一个bare实例：

                                    -
                                    vertx bare
-# or
-java -jar my-verticle-fat.jar bare
-

                                    您还可以在后台启动应用程序：

                                    -
                                    java -jar my-verticle-fat.jar start -Dvertx-id=my-app-name
-

                                    若my-app-name未设置，将生成一个随机的id，并在命令提示符中打印。您可以将run选项传递给start命令：

                                    -
                                    java -jar my-verticle-fat.jar start -Dvertx-id=my-app-name -cluster
-

                                    一旦在后台启动，可以使用stop命令停止它：

                                    -
                                    java -jar my-verticle-fat.jar stop my-app-name
-

                                    您还可以使用一下方式列出后台启动的Vert.x应用程序：

                                    -
                                    java -jar my-verticle-fat.jar list
-

                                    vertx工具也可以使用start、stop和list命令，start命令支持几个选项：

                                    -
                                      -
                                    • vertx-id：应用程序ID，若未设置，则使用随机UUID
                                      • -
                                    • java-opts：Java虚拟机选项，若未设置，则使用JAVA_OPTS环境变量
                                      • -
                                    • redirect-output：重定向生成的进程输出和错误流到父进程流
                                      • -
                                    -

                                    若选项值包含空白，请不要忘记在“”（双引号）之间包装值。

                                    -

                                    由于start命令产生一个新的进程，传递给JVM的java选项不会被传播，所以您必须使用java-opts来配置JVM（-X，-D...）。若您使用 CLASSPATH 环境变量，请确保路径下包含所有需要的jar（vertx-core、您的jar和所有依赖项）。

                                    -

                                    该命令集是可扩展的，请参考 扩展 Vert.x 启动器 部分。

                                    -

                                    实时重部署

                                    -

                                    在开发时，可以方便在文件更改时实时重新部署应用程序。vertx 命令行工具和更普遍的 Launcher 类提供了这个功能。这里有些例子：

                                    -
                                    vertx run MyVerticle.groovy --redeploy="**/*.groovy" --launcher-class=io.vertx.core.Launcher
-vertx run MyVerticle.groovy --redeploy="**/*.groovy,**/*.rb"  --launcher-class=io.vertx.core.Launcher
-java io.vertx.core.Launcher run org.acme.MyVerticle --redeploy="**/*.class"  --launcher-class=io.vertx.core
-.Launcher -cp ...
-

                                    重新部署过程如下执行。首先，您的应用程序作为后台应用程序启动（使用start命令）。当发现文件更改时，该进程将停止并重新启动该应用、这样可避免泄露。

                                    -

                                    要启用实时重新部署，请将 --redeploy 选项传递给 run 命令。--redeploy 表示要监视的文件集，这个集合可使用 Ant 样式模式（使用 **，* 和 ?），您也可以使用逗号（,）分隔它们来指定多个集合。模式相当于当前工作目录。

                                    -

                                    传递给 run 命令的参数最终会传递给应用程序，可使用 --java-opts 配置JVM虚拟机选项。

                                    -

                                    --launcher-class 选项确定应用程序的主类启动器。它通常是一个 Launcher，单您已使用了您自己的主类。

                                    -

                                    也可以在IDE中使用重部署功能：

                                    -
                                      -
                                    • Eclipse：创建一个运行配置，使用io.vertx.core.Launcher类作为主类。在 Program Arguments 区域（参数选项卡中），写入run your-verticle-fully-qualified-name --redeploy=**/*.java --launcher-class=io.vertx.core.Launcher，您还可以添加其他参数。随着 Eclipse 在保存时会增量编译您的文件，重部署工作会顺利进行。
                                      • -
                                    • IntelliJ IDEA：创建一个运行配置（应用）,将主类设置为io.vertx.core.Launcher。在程序参数中写：run your-verticle-fully-qualified-name --redeploy=**/*.class --launcher-class=io.vertx.core.Launcher。要触发重新部署，您需要显示构造项目或模块（Build -> Make project）。
                                      • -
                                    -

                                    要调试应用程序，请将运行配置创建为远程应用程序，并使用--java-opts配置调试器。每次重新部署后，请勿忘记重新插入(re-plug)调试器，因为它每次都会创建一个新进程。

                                    -

                                    您还可以在重新部署周期中挂接（hook）构建过程：

                                    -
                                    java -jar target/my-fat-jar.jar --redeploy="**/*.java" --on-redeploy="mvn package"
-java -jar build/libs/my-fat-jar.jar --redeploy="src/**/*.java" --on-redeploy='./gradlew shadowJar'
-

                                    "on-redeploy"选项指定在应用程序关闭后和重新启动之前调用的命令。因此，如果更新某些运行时工作，则可以钩住构建工具。例如，您可以启动gulp或grunt来更新您的资源。

                                    -

                                    重新部署功能还支持以下设置：

                                    -
                                      -
                                    • redeploy-scan-period：文件系统检查周期（以毫秒为单位），默认为250ms
                                      • -
                                    • redeploy-grace-period：在2次重新部署之间等待的时间（以毫秒为单位），默认为1000ms
                                      • -
                                    • redeploy-termination-period：停止应用程序后等待的时间（在启动用户命令之前）。这个在Windows上非常有用，因为这个进程并没立即被杀死。时间以毫秒为单位，默认20ms
                                      • -
                                    -

                                    集群管理器

                                    -

                                    在 Vert.x 中，集群管理器可用于各种功能，包括：

                                    -
                                      -
                                    • 对集群中 Vert.x 节点发现和分组
                                      • -
                                    • 维护集群范围中的主题订阅者列表（所以我们可知道哪些节点对哪个Event Bus地址感兴趣）
                                      • -
                                    • 分布式Map的支持
                                      • -
                                    • 分布式锁
                                      • -
                                    • 分布式计数器
                                      • -
                                    -

                                    集群管理器不处理Event Bus节点之间的传输，这是由 Vert.x 直接通过TCP连接完成。

                                    -

                                    Vert.x发行版中使用的默认集群管理器是使用的Hazelcast集群管理器，但是它可以轻松被替换成实现了Vert.x集群管理器接口的不同实现，因为Vert.x集群管理器可替换的。

                                    -

                                    集群管理器必须实现ClusterManager接口，Vert.x在运行时使用Java的服务加载器（Service Loader）功能查找集群管理器，以便在类路径中查找ClusterManager的实例。

                                    -

                                    若您在命令行中使用Vert.x并要使用集群，则应确保Vert.x安装的lib目录包含您的集群管理器jar。

                                    -

                                    若您在 Maven/Gradle 项目使用Vert.x，则只需将集群管理器jar作为项目依赖添加。

                                    -

                                    您也可以以编程的方式在嵌入Vert.x 时使用 setClusterManager 指定集群管理器。

                                    -

                                    日志记录

                                    -

                                    Vert.x使用内置的日志API进行记录日志，默认实现使用JDK（JUL）日志，不需要额外的依赖项。

                                    -

                                    配置JUL日志记录

                                    -

                                    一个JUL日志记录配置文件可以使用普通的JUL方式指定——通过提供一个名为java.util.logging.config.file的系统属性值为您的配置文件。更多关于此部分以及JUL配置文件结构的内容，请参阅JUL日志记录文档。

                                    -

                                    Vert.x还提供了一种更方便的方式指定配置文件，无需设置系统属性。您只需在您的类路径中提供名为vertx-default-jul-logging.properties的JUL配置文件（例如在您的fatjar中），Vert.x将使用该配置文件配置JUL。

                                    -

                                    使用另一个日志框架

                                    -

                                    如果您不希望Vert.x使用JUL记录日志，您可以为其配置另一个日志记录框架，例如Log4J或SLF4J。

                                    -

                                    为此，您应该设置一个名为vertx.logger-delegate-factory-class-name的系统属性，该属性的值是一个实现了 LogDelegateFactory 接口的Java 类名。我们为Log4J（版本1）、Log4J 2和SLF4J提供了预设的实现，类名为：io.vertx.core.logging.Log4jLogDelegateFactory，io.vertx.core.logging.Log4j2LogDelegateFactory和io.vertx.core.logging.SLF4JLogDelegateFactory。如您要使用这些实现，还应确保相关的Log4J或SLF4J的jar在您的类路径上。

                                    -

                                    请注意，提供的Log4J 1代理不支持参数化消息。Log4J 2的代理使用了像SLF4J代理这样的{}语法，JUL代理使用如{x}语法。

                                    -

                                    应用中记录日志

                                    -

                                    Vert.x本身只是一个库，您可以在自己的应用程序使用任何日志库的API来记录日志。

                                    -

                                    但是，若您愿意，也可以使用上述的Vert.x日志记录工具为应用程序记录日志。

                                    -

                                    为此，您需要使用LoggerFactory获取一个Logger对象以记录日志：

                                    -
                                    Logger logger = LoggerFactory.getLogger(className);
-
-logger.info("something happened");
-logger.error("oops!", exception);
-

                                    Netty日志记录

                                    -

                                    配置日志记录时，您也应该关心配置Netty日志记录。

                                    -

                                    Netty不依赖于外部日志配置（例如系统属性），而是根据Netty类可见的日志记录库来实现日志记录：

                                    -
                                      -
                                    • 如SLF4J可见，则优先使用该库
                                      • -
                                    • 否则若Log4j可见，再使用该库
                                      • -
                                    • 否则退回使用java.util.logging
                                      • -
                                    -

                                    可通过设置io.netty.util.internal.logging.InternalLoggerFactory强制Netty使用某个特定实现。

                                    -
                                    // 强制使用Log4j日志记录
-InternalLoggerFactory.setDefaultFactory(Log4JLoggerFactory.INSTANCE);
-

                                    故障排除

                                    -

                                    SLF4J启动警告

                                    -

                                    若您在启动应用程序时看到以下信息：

                                    -
                                    SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
-SLF4J: Defaulting to no-operation (NOP) logger implementation
-SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
-

                                    这意味着您的类路径中有SLF4J-API却没绑定。SLF4J记录的消息将会丢失。您应该将绑定加入您的类路径。参考 SLF4J user manual - Binding with a logging framework at deployment time 选择绑定并配置。

                                    -

                                    请注意，Netty会寻找SLF4-API的jar，并在缺省情况下使用它。

                                    -

                                    对等连接重置

                                    -

                                    若您的日志显示一堆：

                                    -
                                    io.vertx.core.net.impl.ConnectionBase
-SEVERE: java.io.IOException: Connection reset by peer
-

                                    这意味着客户端正在重置HTTP连接，而不是关闭它。此消息还可能表示您没有读取完整的有效负荷（连接在读取完全之前被切断）。

                                    -
                                    -

                                    译者注：通常情况下，这是正常的，无需担心，如果您打开浏览器，按快捷键不停滴刷新页面，就能看到该SEVERE日志。

                                    -
                                    -

                                    主机名解析

                                    -

                                    Vert.x使用地址解析器将主机名解析为IP地址，而不是JVM内置的阻塞解析器。

                                    -

                                    主机名使用以下方式解析为IP地址：

                                    -
                                      -
                                    • 操作系统的hosts文件
                                      • -
                                    • DNS查询服务器列表
                                      • -
                                    -

                                    默认情况下，它将使用环境中系统DNS服务器地址的列表，若该列表无法检索，将使用Google的公共DNS服务器 8.8.8.8 和 8.8.4.4。

                                    -

                                    创建 Vertx 实例时也可配置DNS 服务器：

                                    -
                                    Vertx vertx = Vertx.vertx(new VertxOptions().
-    setAddressResolverOptions(
-        new AddressResolverOptions().
-            addServer("192.168.0.1").
-            addServer("192.168.0.2:40000"))
-);
-
                                    -

                                    DNS 服务器的默认端口为53，当服务器使用不同的端口时，可以使用冒号分隔符设置该端口：192.168.0.2:40000。

                                    -
                                    -

                                    请注意：有时可能需要使用JVM内置解析器。可以在启动的时候加上JVM系统属性 -Dvertx.disableDnsResolver=true 激活该行为。

                                    -
                                    -

                                    故障转移

                                    -

                                    当服务器没有及时回应时，尝试从列表中选择下一个解析器，搜索（数量）的限制由setMaxQueries设置（默认值是4个查询）

                                    -

                                    若解析器在getQueryTimeout毫秒内没有收到正确答案（默认为5秒），DNS查询被视为失败。

                                    -

                                    服务器列表轮询

                                    -

                                    默认情况下，DNS服务器选择使用第一个，其余的服务器用于故障转移。

                                    -

                                    您可以配置 setRotateServers 为 true，让解析器使用轮询选择。它会在服务器之间传播查询负载，并避免所有的查找都找到列表中的第一个服务器。

                                    -

                                    故障转移仍然适用，并将使用列表中的下一个服务器。

                                    -

                                    主机映射

                                    -

                                    操作系统的hosts文件用于对ipaddress执行主机名查找。

                                    -

                                    可替换主机文件：

                                    -
                                    Vertx vertx = Vertx.vertx(new VertxOptions().
-    setAddressResolverOptions(
-        new AddressResolverOptions().
-            setHostsPath("/path/to/hosts"))
-);
-
                                    -

                                    搜索域名

                                    -

                                    默认情况下，解析器将使用环境中的系统DNS搜索域，或者，可提供明确的显示搜索域列表：

                                    -
                                    Vertx vertx = Vertx.vertx(new VertxOptions().
-    setAddressResolverOptions(
-        new AddressResolverOptions().addSearchDomain("foo.com").addSearchDomain("bar.com"))
-);
-
                                    -

                                    当使用搜索域列表时，点数的阈值为1，或从Linux上的/etc/resolv.conf加载，也可使用 setNdots 方法配置特定值。

                                    -

                                    高可用/故障转移

                                    -

                                    Vert.x允许您运行支持高可用（HA，High Availability）的Verticle。这种情况下，当运行Verticle的Vert.x实例突然挂掉时，该Veritlce将迁移到另一个Vert.x 实例。这个Vert.x 实例必须在同一个集群中。

                                    -

                                    自动故障转移

                                    -

                                    当Vert.x启用HA运行时，若一个运行了Verticle的Vert.x 实例失败或挂掉，则此Verticle将自动重新部署到集群中的另一个Vert.x 实例中。我们称这个为 Verticle 故障转移（failover）。

                                    -

                                    若要启用HA模式，在启动 Vert.x 应用的时候需要添加-ha参数到命令行：

                                    -
                                    vertx run my-verticle.js -ha
-

                                    现在开启了HA环境，在集群中需要多添加一个Vert.x 实例，所以假设您已经有另一个已经启动的Vert.x 实例，例如：

                                    -
                                    vertx run my-other-verticle.js -ha
-

                                    如果运行了my-verticle.js的Vert.x 实例现在死了（您可以通过执行kill -9杀死进程来测试），运行my-other-verticle.js的Vert.x 实例将自动重新部署my-verticle.js，所以现在这个Vert.x 实例正在运行两个Verticle。

                                    -
                                    -

                                    请注意：只有当第二个Vert.x 实例可访问对应的 verticle 文件（这里是 my-verticle.js）时，迁移才是可能的。

                                    -

                                    重要提示：请注意，干净地关闭Vert.x实例不会导致故障转移发生，例如：CTRL-C 或 kill -SIGNINT。

                                    -
                                    -

                                    您也可以启动裸的Vert.x 实例 —— 即最初不运行任何Verticle的实例，它们也将为集群中的节点进行故障转移。要启动一个裸实例，您只需做：

                                    -
                                    vertx run -ha
-

                                    当使用-ha开关时，您不需要提供-cluster开关，因为若要使用HA就假定是集群。

                                    -
                                    -

                                    请注意： 根据您的集群配置，可能需要自定义集群管理器配置（默认为Hazelcast）和/或添加集群主机 cluster-host 和集群端口 cluster-port 参数。

                                    -
                                    -

                                    HA组

                                    -

                                    当使用Vert.x运行实例时，还可以选择指定的HA组。HA组表示集群中的逻辑节点组。只有具有相同HA组的节点能执行故障转移。若不指定HA组，则使用默认组__DEFAULT__。

                                    -

                                    要指定一个HA组，您可以在运行该Verticle时使用-hagroup开关。

                                    -
                                    vertx run my-verticle.js -ha -hagroup my-group
-

                                    我们来看一个例子：

                                    -

                                    在第一个终端运行：

                                    -
                                    vertx run my-verticle.js -ha -hagroup g1
-

                                    在第二个终端中，让我们使用相同组运行另一个Verticle：

                                    -
                                    vertx run my-other-verticle.js -ha -hagroup g1
-

                                    最后，在第三个终端中，使用不同组启动另一个Verticle：

                                    -
                                    vertx run yet-another-verticle.js -ha -hagroup g2
-

                                    如果终端1中的实例被杀掉，则它将故障转移到终端2中的实例，而不是具有不同组的终端3中的实例。

                                    -

                                    若终端3中的实例被杀掉，因为这个组中没有其他Vert.x实例，则它不会故障转移。

                                    -

                                    处理网络分区 - Quora

                                    -

                                    高可用HA实现同样支持 Quora（多数派机制）。Quorum 是分布式事务必须获得的最小票数才能被允许在分布式系统中执行操作的一个参数。

                                    -

                                    在启动 Vert.x 实例时，您可以指示它在部署任何HA部署之前需要一个quorum。该上下文环境中，一个 quorum 是集群中特定组的最小节点数。通常您选择 quorum 大小为Q = 1 + N / 2，其中N是组中节点数。若集群中的Q节点少于HA节点，HA部署将被撤销。如果/当 quorum 重新获取时，他们将重新部署。通过这样做您可以防止网络分区，也就是脑裂（split brain）。

                                    -

                                    更多关于Quorum（多数派机制）的信息，请参考 这里。

                                    -

                                    若要使用 quorum 运行Vert.x实例，您可以在命令行中指定-quorum，例如：

                                    -

                                    在第一个终端：

                                    -
                                    vertx run my-verticle.js -ha -quorum 3
-

                                    此时，Vert.x实例将启动但不部署模块（尚未）因为目前集群中只有1个节点，而不是3个。

                                    -

                                    在第二个终端：

                                    -
                                    vertx run my-other-verticle.js -ha -quorum 3
-

                                    此时，Vert.x实例将启动但不部署模块（尚未）因为目前集群中只有2个节点，而不是3个。

                                    -

                                    在第三个控制台，您可以启动另一个Vert.x的实例：

                                    -
                                    vertx run yet-another-verticle.js -ha -quorum 3
-

                                    妙极！—— 我们有三个节点，这是 quorum 设置的值，此时，模块将自动部署在所有实例上。

                                    -

                                    若我们现在关闭或杀死其中一个节点，那么这些模块将在其他节点上自动撤销，因为不再满足 quorum（法定人数）。

                                    -

                                    Quora 也可以与HA组合使用，在这种情况下，每个特定组会解决 Quora。

                                    -

                                    安全注意事项

                                    -

                                    Vert.x 是一个工具包，而不是来强迫您以某种方式做事情的框架。这赋予了开发人员以更强大的能力，同时也伴随着更大的责任（译者注：能力越大，责任越大，小蜘蛛他叔叔说的）。

                                    -

                                    搭配其它工具包，使得编写不安全的应用程序成为可能，因此在开发时需谨慎，尤其是当您将其对公众发布的时候（如在互联网上发布）。

                                    -

                                    Web 应用

                                    -

                                    如果编写Web 应用程序，强烈建议您直接使用Vert.x Web而非直接使用Vert.x Core以提供资源或处理文件上传。

                                    -

                                    Vert.x Web对请求中的路径进行了规范，以防止恶意客户端通过伪造URL来访问Web根目录以外的资源。

                                    -

                                    类似地，对于文件上传Vert.x Web提供上传到磁盘上已知位置的功能，且不依赖客户端提供的文件名，客户端提供的文件名可被恶意伪装成上传到硬盘上的不同位置。

                                    -

                                    Vert.x Core 本身不提供这样的检查，所以这取决于开发者您自身如何实现了。

                                    -

                                    集群模式 Event Bus 流量

                                    -

                                    当在网络上的不同Vert.x 节点之间创建集群模式下的 Event Bus 时，流量将通过未加密报文发送，因此若您有要发送的机密数据，而您的Vert.x 节点不在授信的网络上，请勿使用。

                                    -

                                    标准安全最佳实践

                                    -

                                    任何服务都可能存在潜在的漏洞，无论是使用Vert.x还是任何其他工具包，因此始终遵循安全最佳实践，特别是当您的服务面向公众。

                                    -

                                    例如，您应该始终在DMZ中运行它们，并使用具有受限权限的用户账户，以限制服务受到损害的程度。

                                    -

                                    Vert.x 命令行接口API

                                    -

                                    Vert.x Core提供了一个用于解析传递给程序的命令行参数API。

                                    -

                                    它还可以打印帮助信息——详细说明命令行工具可用的选项。即使这些功能远离Vert.x Core主题，该API也可在 Launcher 类中使用，可以在 fat-jar 和 vertx 命令行工具中使用。另外，它支持多语言（可用于任何支持的语言），并可在Vert.x Shell中使用。

                                    -

                                    Vert.x CLI提供了一个描述命令行界面的模型，同时也是一个解析器，这个解析器可支持不同的语法：

                                    -
                                      -
                                    • 类似POSIX选项（即tar -zxvf foo.tar.gz）
                                      • -
                                    • 类似GNU选项（即du --human-readable --max-depth=1）
                                      • -
                                    • 类似Java属性（即java -Djava.awt.headless=true -Djava.net.useSystemProxies=true Foo）
                                      • -
                                    • 具有附加值的短选项（即gcc -O2 foo.c）
                                      • -
                                    • 单个连字符的长选项（即ant -projecthelp）
                                      • -
                                    -

                                    使用CLI API的三个步骤如下：

                                    -
                                      -
                                    1. 定义命令行接口
                                      2. -
                                    2. 解析用户命令行
                                      3. -
                                    3. 查询/审问
                                      4. -
                                    -

                                    定义阶段

                                    -

                                    每个命令行界面必须定义将要使用的选项和参数集合。它也需要一个名字。CLI API使用 Option 和 Argument 类来描述选项和参数：

                                    -
                                    CLI cli = CLI.create("copy")
-    .setSummary("A command line interface to copy files.")
-    .addOption(new Option()
-        .setLongName("directory")
-        .setShortName("R")
-        .setDescription("enables directory support")
-        .setFlag(true))
-    .addArgument(new Argument()
-        .setIndex(0)
-        .setDescription("The source")
-        .setArgName("source"))
-    .addArgument(new Argument()
-        .setIndex(1)
-        .setDescription("The destination")
-        .setArgName("target"));
-
                                    -

                                    您可以看到，您可以使用CLI.create创建一个新的CLI。传递的字符串是CLI的名称。创建后，您可以设置摘要和描述，摘要的目的是简短（一行），而描述可以包含更多细节。每个选项和参数也使用addArgument和addOption方法添加到CLI对象上。

                                    -

                                    选项

                                    -

                                    Option 是由用户命令行中存在的 键 标识的命令行参数。选项至少必须有一个长名或一个短名。长名称通常使用 -- 前缀，而短名称与单个 - 一起使用。选项可以获取用法中显示的描述（见下文）。选项可以接受0、1或几个值。接受0值的选项是一个标志(flag)，必须使用 setFlag 声明。默认情况下，选项会接受一个值，但是您可以使用 setMultiValued 方法配置该选项接收多个值：

                                    -
                                    CLI cli = CLI.create("some-name")
-    .setSummary("A command line interface illustrating the options valuation.")
-    .addOption(new Option()
-        .setLongName("flag").setShortName("f").setFlag(true).setDescription("a flag"))
-    .addOption(new Option()
-        .setLongName("single").setShortName("s").setDescription("a single-valued option"))
-    .addOption(new Option()
-        .setLongName("multiple").setShortName("m").setMultiValued(true)
-        .setDescription("a multi-valued option"));
-
                                    -

                                    选项可以标记为必填项，在用户命令行中未设置必填选项在解析阶段会引发异常：

                                    -
                                    CLI cli = CLI.create("some-name")
-    .addOption(new Option()
-        .setLongName("mandatory")
-        .setRequired(true)
-        .setDescription("a mandatory option"));
-
                                    -

                                    非必填选项可以具有默认值，如果用户没有在命令行中设置该选项，即将使用该值：

                                    -
                                    CLI cli = CLI.create("some-name")
-    .addOption(new Option()
-        .setLongName("optional")
-        .setDefaultValue("hello")
-        .setDescription("an optional option with a default value"));
-
                                    -

                                    可以使用 setHidden 方法隐藏选项，隐藏选项不在用法中列出，但仍可在用户命令行中使用（针对高级用户）。

                                    -

                                    如果选项值被限制为一个固定集合，您可以设置不同的可接受选项：

                                    -
                                    CLI cli = CLI.create("some-name")
-    .addOption(new Option()
-        .setLongName("color")
-        .setDefaultValue("green")
-        .addChoice("blue").addChoice("red").addChoice("green")
-        .setDescription("a color"));
-
                                    -

                                    也可以从JSON表单中实例化选项。

                                    -

                                    参数

                                    -

                                    和选项不同，参数不具有 键 并由其索引标识。例如，在java com.acme.Foo中，com.acme.Foo是一个参数。

                                    -

                                    参数没有名称，使用基于 0 的索引进行标识。第一个参数的索引为 0：

                                    -
                                    CLI cli = CLI.create("some-name")
-    .addArgument(new Argument()
-        .setIndex(0)
-        .setDescription("the first argument")
-        .setArgName("arg1"))
-    .addArgument(new Argument()
-        .setIndex(1)
-        .setDescription("the second argument")
-        .setArgName("arg2"));
-
                                    -

                                    如果不设置参数索引，则基于声明顺序会自动计算。

                                    -
                                    CLI cli = CLI.create("some-name")
-    // 索引为0
-    .addArgument(new Argument()
-        .setDescription("the first argument")
-        .setArgName("arg1"))
-    // 索引为1
-    .addArgument(new Argument()
-        .setDescription("the second argument")
-        .setArgName("arg2"));
-
                                    -

                                    argName 是可选的，并在消息中使用。

                                    -

                                    相比选项，Argument可以：

                                    - -

                                    参数也可以从JSON表单中实例化。

                                    -

                                    生成 usage 信息

                                    -

                                    一旦您的CLI实例配置好后，您可以生成 usage 信息：

                                    -
                                    CLI cli = CLI.create("copy")
-    .setSummary("A command line interface to copy files.")
-    .addOption(new Option()
-        .setLongName("directory")
-        .setShortName("R")
-        .setDescription("enables directory support")
-        .setFlag(true))
-    .addArgument(new Argument()
-        .setIndex(0)
-        .setDescription("The source")
-        .setArgName("source"))
-    .addArgument(new Argument()
-        .setIndex(0)
-        .setDescription("The destination")
-        .setArgName("target"));
-
-StringBuilder builder = new StringBuilder();
-cli.usage(builder);
-
                                    -

                                    上边生成的 usage 信息如下：

                                    -
                                    Usage: copy [-R] source target
-
-A command line interface to copy files.
-
-  -R,--directory   enables directory support
-

                                    若需要调整 usage 信息，请查阅 UsageMessageFormatter 类的文档。

                                    -

                                    解析阶段

                                    -

                                    一旦您的 CLI 实例配置好后，您可以解析用户命令行来解析每个选项和参数：

                                    -
                                    CommandLine commandLine = cli.parse(userCommandLineArguments);
-
                                    -

                                    parse解析方法返回包含值的CommandLine对象。默认情况下，它验证用户命令行，并检查每个必填选项和参数的设置以及每个选项接收的值的数量。您可以通过传递 false 作为parse的第二个参数来禁用验证。如果要检查参数或选项，即使解析的命令行无效，这也是有用的。

                                    -

                                    您可以使用isValid来检查CommandLine是否有效。

                                    -

                                    查询/审问阶段

                                    -

                                    解析后，您可以从解析方法返回的CommandLine对象中读取选项和参数的值：

                                    -
                                    CommandLine commandLine = cli.parse(userCommandLineArguments);
-String opt = commandLine.getOptionValue("my-option");
-boolean flag = commandLine.isFlagEnabled("my-flag");
-String arg0 = commandLine.getArgumentValue(0);
-
                                    -

                                    您的一个选项可以被标记为“帮助”。如果用户命令行启用“帮助”选项，验证将不会失败，但是可以让您有机会检查用户是否需要帮助：

                                    -
                                    CLI cli = CLI.create("test")
-    .addOption(
-        new Option().setLongName("help").setShortName("h").setFlag(true).setHelp(true))
-    .addOption(
-        new Option().setLongName("mandatory").setRequired(true));
-
-CommandLine line = cli.parse(Collections.singletonList("-h"));
-
-// 解析不会失败，您可以做：
-if (!line.isValid() && line.isAskingForHelp()) {
-  StringBuilder builder = new StringBuilder();
-  cli.usage(builder);
-  stream.print(builder.toString());
-}
-
                                    -

                                    有类型选项和参数

                                    -

                                    描述Option和Argument类是无类型的，这意味着仅读取String值。

                                    -

                                    TypedOption和TypedArgument可以指定一个类型，因此（String）原始值将转换为指定的类型。

                                    -

                                    在CLI定义中使用TypedOption和TypedArgument，而不是Option和Argument。

                                    -
                                    CLI cli = CLI.create("copy")
-    .setSummary("A command line interface to copy files.")
-    .addOption(new TypedOption<Boolean>()
-        .setType(Boolean.class)
-        .setLongName("directory")
-        .setShortName("R")
-        .setDescription("enables directory support")
-        .setFlag(true))
-    .addArgument(new TypedArgument<File>()
-        .setType(File.class)
-        .setIndex(0)
-        .setDescription("The source")
-        .setArgName("source"))
-    .addArgument(new TypedArgument<File>()
-        .setType(File.class)
-        .setIndex(0)
-        .setDescription("The destination")
-        .setArgName("target"));
-
                                    -

                                    然后，您可以按下边方式获取转换的值：

                                    -
                                    CommandLine commandLine = cli.parse(userCommandLineArguments);
-boolean flag = commandLine.getOptionValue("R");
-File source = commandLine.getArgumentValue("source");
-File target = commandLine.getArgumentValue("target");
-
                                    -

                                    Vert.x CLI可以转换的类：

                                    -
                                      -
                                    • 具有单个String参数的构造函数，例如File或JsonObject
                                      • -
                                    • 使用静态的from或fromString方法
                                      • -
                                    • 使用静态valueOf方法，如基础类型和枚举
                                      • -
                                    -

                                    此外，您可以实现自己的转换器（Converter）并指定CLI使用此转换器：

                                    -
                                    CLI cli = CLI.create("some-name")
-    .addOption(new TypedOption<Person>()
-        .setType(Person.class)
-        .setConverter(new PersonConverter())
-        .setLongName("person"));
-
                                    -

                                    对于布尔值，布尔值将被评定为true:on，yes，1，true。

                                    -

                                    若您的一个选项是 enum 类型，则（系统）会自动计算一组选项。

                                    -

                                    使用注解

                                    -

                                    您还可以使用注解定义CLI。在类和 setter 方法上使用注解来定义：

                                    -
                                    @Name("some-name")
-@Summary("some short summary.")
-@Description("some long description")
-public class AnnotatedCli {
-
-  private boolean flag;
-  private String name;
-  private String arg;
-
- @Option(shortName = "f", flag = true)
- public void setFlag(boolean flag) {
-   this.flag = flag;
- }
-
- @Option(longName = "name")
- public void setName(String name) {
-   this.name = name;
- }
-
- @Argument(index = 0)
- public void setArg(String arg) {
-  this.arg = arg;
- }
-}
-
                                    -

                                    注解后，您可以使用以下命令来定义CLI并注入值：

                                    -
                                    CLI cli = CLI.create(AnnotatedCli.class);
-CommandLine commandLine = cli.parse(userCommandLineArguments);
-AnnotatedCli instance = new AnnotatedCli();
-CLIConfigurator.inject(commandLine, instance);
-
                                    -

                                    Vert.x Launcher

                                    -

                                    Vert.x Launcher 在 fat-jar 中作为主类，由 vertx 命令行实用程序调用。它可执行一组命令，如run、bare 和 start等

                                    -

                                    扩展 Vert.x 启动器

                                    -

                                    您可以通过实现自己的 Command 类来扩展命令集（仅限于Java）：

                                    -
                                    @Name("my-command")
-@Summary("A simple hello command.")
-public class MyCommand extends DefaultCommand {
-
-  private String name;
-
-  @Option(longName = "name", required = true)
-  public void setName(String n) {
-    this.name = n;
-  }
-
-  @Override
-  public void run() throws CLIException {
-    System.out.println("Hello " + name);
-  }
-}
-
                                    -

                                    您还需要实现一个 CommandFactory：

                                    -
                                    public class HelloCommandFactory extends DefaultCommandFactory<HelloCommand> {
-  public HelloCommandFactory() {
-   super(HelloCommand.class);
-  }
-}
-
                                    -

                                    然后创建 src/main/resources/META-INF/services/io.vertx.core.spi.launcher.CommandFactory 并且添加一行表示工厂类的完全限定名称：

                                    -
                                    io.vertx.core.launcher.example.HelloCommandFactory
-

                                    构建包含命令的jar。确保包含了SPI文件（META-INF/services/io.vertx.core.spi.launcher.CommandFactory）。

                                    -

                                    然后，将包含该命令的jar放入fat-jar（或包含在其中）的类路径中，或放在Vert.x发行版的lib目录中，您将可以执行：

                                    -
                                    vertx hello vert.x
-java -jar my-fat-jar.jar hello vert.x
-
                                    -

                                    在 fat-jar 中使用启动器

                                    -

                                    要在 fat-jar 中使用 Launcher 类，只需要将 MANIFEST 的 Main-Class 设置为 io.vertx.core.Launcher。另外，将 MANIFEST 中 Main-Verticle 条目设置为您的Main Verticle的名称。

                                    -

                                    默认情况下，它会执行 run 命令。但是，您可以通过设置 MANIFEST 的Main-Command条目来配置默认命令。若在没有命令的情况下启动 fat-jar，则使用默认命令。

                                    -

                                    启动器子类

                                    -

                                    您还可以创建 Launcher 的子类来启动您的应用程序。这个类被设计成易于扩展的。

                                    -

                                    一个 Launcher 子类可以：

                                    - -

                                    启动器和退出代码

                                    -

                                    当您使用 Launcher 类作为主类时，它使用以下退出代码：

                                    -
                                      -
                                    • 若进程顺利结束，或抛出未捕获的错误：0
                                      • -
                                    • 用于通用错误：1
                                      • -
                                    • 若Vert.x无法初始化：11
                                      • -
                                    • 若生成的进程无法启动、发现或停止：12，该错误代码一般由start和stop命令使用
                                      • -
                                    • 若系统配置不符合系统要求（如找不到 java 命令）：14
                                      • -
                                    • 若主Verticle不能被部署：15
                                      • -
                                    -

                                    配置 Vert.x 缓存

                                    -

                                    当 Vert.x 需要从类路径中读取文件（嵌入在 fat-jar 中，类路径中jar文件或其他文件）时，它会把文件复制到缓存目录。背后原因很简单：从 jar 或从输入流读取文件是阻塞的。所以为了避免每次都付出代价，Vert.x 会将文件复制到其缓存目录中，并随后读取该文件。这个行为也可配置。

                                    -

                                    首先，默认情况下，Vert.x 使用 $CWD/.vertx 作为缓存目录，它在此之间创建一个唯一的目录，以避免冲突。可以使用 vertx.cacheDirBase 系统属性配置该位置。如，若当前工作目录不可写（例如在不可变容器上下文环境中），请使用以下命令启动应用程序：

                                    -
                                    vertx run my.Verticle -Dvertx.cacheDirBase=/tmp/vertx-cache
-# 或者
-java -jar my-fat.jar vertx.cacheDirBase=/tmp/vertx-cache
-
                                    -
                                    -

                                    重要提示： 该目录必须是可写的。

                                    -
                                    -

                                    当您编辑资源（如HTML、CSS或JavaScript）时，这种缓存机制可能令人讨厌，因为它仅仅提供文件的第一个版本（因此，若您想重新加载页面，则不会看到您的编辑改变）。要避免此行为，请使用 -Dvertx.disableFileCaching=true 启动应用程序。使用此设置，Vert.x 仍然使用缓存，但始终使用原始源刷新存储在缓存中的版本。因此，如果您编辑从类路径提供的文件并刷新浏览器，Vert.x 会从类路径读取它，将其复制到缓存目录并从中提供。不要在生产环境使用这个设置，它很有可能影响性能。

                                    -

                                    最后，您可以使用-Dvertx.disableFileCPResolving=true完全禁用高速缓存。这个设置不是没有后果的。Vert.x将无法从类路径中读取任何文件（仅从文件系统）。使用此设置时要非常小心。

                                    -
                                    -

                                    结语

                                    -
                                    -
                                    -

                                    原文档更新于2017-03-15 15:54:14 CET

                                    -
                                    - - -
                                    - -
                                    -
                                    -
                                    - -

                                    results matching ""

                                    -
                                      - -
                                      -
                                      - -

                                      No results matching ""

                                      - -
                                      -
                                      -
                                      - -
                                      -
                                      - -
                                      - - - - - - - - - - - - - - -
                                      - - -
                                      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/data/Data.html b/docs/data/Data.html deleted file mode 100644 index f49bbd6..0000000 --- a/docs/data/Data.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - Data Access · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                      -
                                      - - - - - - - - -
                                      - -
                                      - -
                                      - - - - - - - - -
                                      -
                                      - -
                                      -
                                      - -
                                      - -

                                      Vert.x Data Access

                                      - - -
                                      - -
                                      -
                                      -
                                      - -

                                      results matching ""

                                      -
                                        - -
                                        -
                                        - -

                                        No results matching ""

                                        - -
                                        -
                                        -
                                        - -
                                        -
                                        - -
                                        - - - - - - - - - - - - - - -
                                        - - -
                                        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/data/JDBCClient.html b/docs/data/JDBCClient.html deleted file mode 100644 index f676012..0000000 --- a/docs/data/JDBCClient.html +++ /dev/null @@ -1,1221 +0,0 @@ - - - - - - - JDBC Client · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                        -
                                        - - - - - - - - -
                                        - -
                                        - -
                                        - - - - - - - - -
                                        -
                                        - -
                                        -
                                        - -
                                        - -

                                        Vert.x JDBC Client

                                        -
                                        -

                                        原文档：Vert.x JDBC Client

                                        -
                                        -

                                        使用 Vert.x JDBC Client，可以让我们的 Vert.x 应用程序通过异步的方式，与任何支持 JDBC 的数据库进行交互。

                                        -

                                        Vert.x JDBC Client 的接口定义为 JDBCClient。

                                        -

                                        要使用Vert.x JDBC Client，需要添加下面的依赖：

                                        -
                                          -
                                        • Maven (在 pom.xml 文件中):
                                          • -
                                        -
                                        <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-jdbc-client</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                        -
                                          -
                                        • Gradle (在 build.gradle 文件中):
                                          • -
                                        -
                                        compile 'io.vertx:vertx-jdbc-client:3.4.1'
-
                                        -

                                        创建 Vert.x JDBC Client 对象

                                        -

                                        接下来，我们一起来看下创建 Vert.x JDBC Client 对象的几种方式。

                                        -

                                        默认使用共享的数据源

                                        -

                                        大部分情况下，我们希望在不同的 Vert.x JDBC Client 对象之间，共享一个数据源。

                                        -

                                        考虑这样一种情况：我们在部署 Verticle 时，设置了 Verticle 拥有多个实例化的对象，但是我们希望每个 Verticle 实例能够共享同一个数据源，而不是单独为每个 Verticle 实例设置不同的数据源。

                                        -

                                        要解决上面的问题，我们可以这么做：

                                        -
                                        JDBCClient client = JDBCClient.createShared(vertx, config);
-
                                        -

                                        只有在第一次调用 JDBCClient.createShared 方法的时候，才会真正的根据 config 参数创建一个数据源。

                                        -

                                        之后再调用此方法，只会返回一个新的 Vert.x JDBC Client 对象，但使用的是相同的数据源。这时 config 参数也就不再有作用。

                                        -

                                        指定数据源名称

                                        -

                                        我们还可以像下面这样，在创建一个 Vert.x JDBC Client 对象的时候指定数据源的名称：

                                        -
                                        JDBCClient client = JDBCClient.createShared(vertx, config, "MyDataSource");
-
                                        -

                                        如果不同的 Vert.x JDBC client 对象使用了相同的Vert.x 对象和相同的数据源名称，那么它们将共享数据源。

                                        -

                                        同样的（与默认使用共享的数据源），只有在第一次调用JDBCClient.createShared方法的时候，才会真正的根据 config 参数创建一个数据源。

                                        -

                                        之后再调用此方法，只会返回一个新的 Vert.x JDBC Client 对象，但使用的是相同的数据源。这时 config 参数也就不再有作用。

                                        -

                                        当我们希望不同含义的 Vert.x JDBC Client 对象拥有不同的数据源时，可以采用这种方式来创建它的对象。比如它们要与不同的数据源进行交互。

                                        -

                                        创建不共享数据源的 Vert.x JDBC Client 对象

                                        -

                                        在大部分情况下，我们会希望在不同的 Vert.x JDBC Client 对象之间共享数据源。但有时候，却恰恰相反。

                                        -

                                        这时，可以调用 JDBCClient.createNonShared 方法：

                                        -
                                        JDBCClient client = JDBCClient.createNonShared(vertx, config);
-
                                        -

                                        每次调用此方法，就相当于在调用 JDBCClient.createShared 方法时加上了具有唯一名称的数据源参数。

                                        -

                                        指定数据源

                                        -

                                        如果我们已经存在一个数据源，也可以在创建 Vert.x JDBC Client 对象的时候就直接指定它：

                                        -
                                        JDBCClient client = JDBCClient.create(vertx, dataSource);
-
                                        -

                                        关闭客户端

                                        -

                                        我们可以较长时间的持有 Vert.x JDBC Client 对象（比如在 Verticle 的整个生命周期里），可一旦不再使用它后，就应该关闭它。

                                        -

                                        在多个 Vert.x JDBC Client 对象共享数据源的情况下，这个数据源对象维护着一个引用计数器。一旦此数据源最后一个引用关闭后，这个数据源也就关闭了。

                                        -

                                        在 Verticle 中自动关闭

                                        -

                                        我们在 Verticle 中创建的 Vert.x JDBC Client 对象，会在这些 Verticle 卸载（undeploy）的时候自动关闭。

                                        -

                                        获取数据库连接

                                        -

                                        在创建 Vert.x JDBC Client 对象后，我们可以通过 getConnection 方法来获取一个数据库连接。

                                        -

                                        此方法从连接池中获取一个数据库连接，并返回给回调方法：

                                        -
                                        client.getConnection(res -> {
-  if (res.succeeded()) {
-
-    SQLConnection connection = res.result();
-
-    connection.query("SELECT * FROM some_table", res2 -> {
-      if (res2.succeeded()) {
-
-        ResultSet rs = res2.result();
-        // 用结果集results进行其他操作
-      }
-    });
-  } else {
-    // 获取连接失败 - 处理失败的情况
-  }
-});
-
                                        -

                                        获取的这个连接，是接口 SQLConnection 的一个实现。但是 SQLConnection 是一个通用接口，不只是在 Vert.x JDBC Client 中有用到。

                                        -

                                        更多详细内容，可以参考文档 Vert.x Common SQL Interface 。

                                        -

                                        配置参数

                                        -

                                        在 Vert.x JDBC Client 创建或者部署的时候，我们应该把对应的配置参数传给它。

                                        -

                                        常用的配置参数有下面这些：

                                        -
                                          -

                                        • provider_class

                                          -

                                          此参数确定管理数据库连接池的实现类，默认是io.vertx.ext.jdbc.spi.impl.C3P0DataSourceProvider 。如果我们想使用其他的类，可以自己设置这个参数，但参数对应的类，必须实现接口DataSourceProvider。

                                          -
                                          • -

                                        • row_stream_fetch_size

                                          -

                                          为了提升性能，SQLRowStream 设置有内部缓存。默认缓存大小为 128。

                                          -
                                          • -
                                        -

                                        若我们使用的是 Vert.x 默认的 C3P0（DataSourceProvider），可以使用下面的配置参数：

                                        -
                                          -

                                        • url

                                          -

                                          数据库 JDBC 连接地址

                                          -
                                          • -

                                        • driver_class

                                          -

                                          JDBC 驱动

                                          -
                                          • -

                                        • user

                                          -

                                          数据库用户名

                                          -
                                          • -

                                        • password

                                          -

                                          数据库密码

                                          -
                                          • -

                                        • max_pool_size

                                          -

                                          连接池最大连接数，默认15

                                          -
                                          • -

                                        • initial_pool_size

                                          -

                                          连接池初始连接数，默认3

                                          -
                                          • -

                                        • min_pool_size

                                          -

                                          连接池最小连接数

                                          -
                                          • -

                                        • max_statements

                                          -

                                          预处理SQL语句最小缓存数，默认 0

                                          -
                                          • -

                                        • max_statements_per_connection

                                          -

                                          每个数据库连接的最大预处理SQL缓存数，默认0

                                          -
                                          • -

                                        • max_idle_time

                                          -

                                          空闲连接保留时间，默认0 (代表一直保留)

                                          -
                                          • -
                                        -

                                        其它连接池实现：

                                        -
                                          -
                                        • BoneCP
                                          • -
                                        • Hikari
                                          • -
                                        -

                                        类似于 C3P0，上面的连接池也可以通过传递一个 JsonObject 对象来配置参数。考虑这样一种情况，应用程序要运行在一个 Vert.x 环境中，但我们却不想通过 fat jar 的方式来部署，且在没有权限把 JDBC 驱动包加到 Vert.x lib 目录下的时候，建议使用 BoneCP，并在命令行上加上-cp标示。

                                        -

                                        如果想要配置 C3P0 更多的参数，我们可以在 classpath 下添加文件c3p0.properties。

                                        -

                                        例如：

                                        -
                                        JsonObject config = new JsonObject()
-  .put("url", "jdbc:hsqldb:mem:test?shutdown=true")
-  .put("driver_class", "org.hsqldb.jdbcDriver")
-  .put("max_pool_size", 30);
-
-JDBCClient client = JDBCClient.createShared(vertx, config);
-
                                        -

                                        需要注意，Hikari 使用的配置参数不一样：

                                        -
                                          -
                                        • jdbcUrl 数据库 JDBC 连接地址
                                          • -
                                        • driverClassName JDBC 驱动类名
                                          • -
                                        • maximumPoolSize 连接池最大连接数
                                          • -
                                        • username 数据库用户名 (password 数据库密码)
                                          • -
                                        -

                                        可以阅读 Hikari documentation 和 BoneCP documentation 来了解更多关于两个数据源的知识。

                                        -

                                        JDBC 驱动

                                        -

                                        如果使用默认的DataSourceProvider实现类（C3P0实现），我们要把JDBC 驱动jar包放在编译路径下。

                                        -

                                        如果我们的 Vert.x 应用程序打包成 fat jar，要确保 JDBC 驱动包含在里面。如果我们的 Vert.x 应用程序通过 vertx 命令行启动，要确保 JDBC 驱动包在 ${VERTX_HOME}/lib 路径里面。

                                        -

                                        使用不同的连接池时，可能会稍有不一样。

                                        -

                                        数据类型

                                        -

                                        由于 Vert.x 使用 JSON 作为标准的消息格式，这使得客户端在接受数据类型时受到很多限制。我们只能从 JsonObject 获得下面的数据类型：

                                        -
                                          -
                                        • null
                                          • -
                                        • boolean
                                          • -
                                        • number
                                          • -
                                        • string
                                          • -
                                        -

                                        时间类型 (TIME, DATE, TIMESTAMP) 可以自动转换。需要注意的是，我们可以选择性的使用 UUID 的转换。虽然大部分数据库都支持 UUID，可并不是所有都支持，比如说 MySQL 就不支持。这种情况下，建议使用 VARCHAR(36) 类型的字段。对于其他支持 UUID 的数据库来说，使用下面的参数后，可以对 UUID 进行自动类型转换。

                                        -
                                        { "castUUID": true }
-
                                        -

                                        这样，UUID 将会被作为原生类型（译者注：java.util.UUID）来处理。

                                        -

                                        作为 OSGI 应用程序

                                        -

                                        Vert.x JDBC Client 也可以作为 OSGI 应用程序。但是，必须首先部署它所有的依赖。但有些连接池要求必须从 classpath 加载 JDBC 驱动，这样的就不能作为 OSGI 应用程序。

                                        -
                                        -

                                        原文档更新于2017-03-15 15:54:14 CET

                                        - - -
                                        - -
                                        -
                                        -
                                        - -

                                        results matching ""

                                        -
                                          - -
                                          -
                                          - -

                                          No results matching ""

                                          - -
                                          -
                                          -
                                          - -
                                          -
                                          - -
                                          - - - - - - - - - - - - - - -
                                          - - -
                                          - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/data/MongoDBClient.html b/docs/data/MongoDBClient.html deleted file mode 100644 index 33af3f4..0000000 --- a/docs/data/MongoDBClient.html +++ /dev/null @@ -1,1780 +0,0 @@ - - - - - - - MongoDB Client · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                          -
                                          - - - - - - - - -
                                          - -
                                          - -
                                          - - - - - - - - -
                                          -
                                          - -
                                          -
                                          - -
                                          - -

                                          Vert.x MongoDB Client

                                          -
                                          -

                                          原文档：Vert.x MongoDB Client

                                          -
                                          -

                                          组件介绍

                                          -

                                          您的 Vert.x 应用可以使用 Vert.x MongoDB Client（以下简称客户端）来与 MongoDB 进行交互，包括保存，获取，搜索和删除文档。

                                          -

                                          MongoDB 是在 Vert.x 应用进行数据持久化时的最佳选择，因为 MongoDB 天生就是处理 JSON（BSON）格式的文档数据库。

                                          -

                                          特点

                                          -
                                            -
                                          • 完全非阻塞
                                            • -
                                          • 支持自定义编解码器，从而实现 Vert.x JSON 快速序列化和反序列化
                                            • -
                                          • 支持 MongoDB Java 驱动大部分配置项
                                            • -
                                          -

                                          本客户端基于 MongoDB Async Driver。

                                          -

                                          使用 Vert.x MongoDB Client

                                          -

                                          使用此客户端，需要添加下列依赖：

                                          -
                                            -
                                          • Maven (在 pom.xml 文件中):
                                            • -
                                          -
                                          <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-mongo-client</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                          -
                                            -
                                          • Gradle (在 build.gradle 文件中):
                                            • -
                                          -
                                          compile 'io.vertx:vertx-mongo-client:3.4.1'
-
                                          -

                                          创建客户端

                                          -

                                          您有以下几种方式来创建客户端：

                                          -

                                          默认使用共享的连接池

                                          -

                                          大部分情况下，您希望不同的客户端之间共享一个连接池。

                                          -

                                          例如：我们在部署 Verticle 时，设置了 Verticle 拥有多个实例化的对象，但是我们希望每个 Verticle 实例能够共享同一个数据源，而不是单独为每个 Verticle 实例设置不同的数据源。

                                          -

                                          要解决上面的问题，我们可以这么做：

                                          -
                                          MongoClient client = MongoClient.createShared(vertx, config);
-
                                          -

                                          只有在第一次调用 MongoClient.createShared 方法的时候，才会真正的根据 config 参数创建一个数据源。

                                          -

                                          之后再调用此方法，只会返回一个新的客户端对象，但使用的是相同的数据源。这时 config 参数也就不再有作用。

                                          -

                                          指定数据源名称

                                          -

                                          您还可以像下面这样，在创建一个客户端的时候指定数据源的名称：

                                          -
                                          MongoClient client = MongoClient.createShared(vertx, config, "MyPoolName");
-
                                          -

                                          如果不同的客户端对象使用了相同的 Vert.x 对象和相同的数据源名称，那么它们将共享数据源。

                                          -

                                          同样的（与默认使用共享的数据源），只有在第一次调用MongoClient.createShared方法的时候，才会真正的根据 config 参数创建一个数据源。

                                          -

                                          之后再调用此方法，只会返回一个新的客户端对象，但使用的是相同的数据源。这时 config 参数也就不再有作用。

                                          -

                                          当我们希望不同含义的客户端对象拥有不同的数据源时，可以采用这种方式来创建它的对象。比如它们要与不同的数据源进行交互。

                                          -

                                          创建不共享数据源的客户端对象

                                          -

                                          在大部分情况下，我们会希望在不同的客户端对象之间共享数据源。但有时候，却恰恰相反。

                                          -

                                          这时，可以调用 MongoClient.createNonShared 方法：

                                          -
                                          MongoClient client = MongoClient.createNonShared(vertx, config);
-
                                          -

                                          每次调用此方法，就相当于在调用 MongoClient.createShared 方法时加上了具有唯一名称的数据源参数。

                                          -

                                          使用客户端 API

                                          -

                                          MongoClient 接口定义了操作客户端的API 方法。您可以使用 MongoClient 来使用调用 API 方法。

                                          -

                                          保存文档

                                          -

                                          您可以使用 save 方法来保存文档。

                                          -

                                          如果文档中没有 _id 字段，文档会被保存。若有，将执行 upserted。Upserted 意思是，如果此文档不存在，就保存此文档，此文档存在就更新。

                                          -

                                          如果文档没有 _id 字段，回调方法中可以获得保存后生成的 id 。

                                          -

                                          例如：

                                          -
                                          JsonObject document = new JsonObject().put("title", "The Hobbit");
-
-mongoClient.save("books", document, res -> {
-
-  if (res.succeeded()) {
-
-    String id = res.result();
-    System.out.println("Saved book with id " + id);
-
-  } else {
-    res.cause().printStackTrace();
-  }
-
-});
-
                                          -

                                          下面的例子，文档已有 _id ：

                                          -
                                          JsonObject document = new JsonObject().put("title", "The Hobbit").put("_id", "123244");
-
-mongoClient.save("books", document, res -> {
-
-  if (res.succeeded()) {
-
-    // ...
-
-  } else {
-    res.cause().printStackTrace();
-  }
-
-});
-
                                          -

                                          插入文档

                                          -

                                          您可以使用 insert 方法来插入文档。

                                          -

                                          如果被插入的文档没有包含 id，回调方法中可以获得保存后生成的 id 。

                                          -
                                          JsonObject document = new JsonObject().put("title", "The Hobbit");
-
-mongoClient.insert("books", document, res -> {
-
-  if (res.succeeded()) {
-
-    String id = res.result();
-    System.out.println("Inserted book with id " + id);
-
-  } else {
-    res.cause().printStackTrace();
-  }
-
-});
-
                                          -

                                          如果被插入的文档包含 id，但是此 id 代表的文档已经存在，插入就会失败：

                                          -
                                          JsonObject document = new JsonObject().put("title", "The Hobbit").put("_id", "123244");
-
-mongoClient.insert("books", document, res -> {
-
-  if (res.succeeded()) {
-
-    //...
-
-  } else {
-
-    // Will fail if the book with that id already exists.
-  }
-
-});
-
                                          -

                                          更新文档

                                          -

                                          您可以使用 update 方法来更新文档（译者注：建议使用 updateCollection 方法或者 updateCollectionWithOptions 方法）。

                                          -

                                          此方法可以更新集合（译者注：MongoDB 中的集合概念对应 SQL 中的数据库表）中的一个或多个文档。其中 update 参数的 JSON 对象，必须包含 Update Operators ，因为由它决定更新的方式。

                                          -

                                          其中 query 参数决定更新集合中的哪个文档。

                                          -

                                          例如更新 books 集合中的一个文档：

                                          -
                                          JsonObject query = new JsonObject().put("title", "The Hobbit");
-
-// Set the author field
-JsonObject update = new JsonObject().put("$set", new JsonObject().put("author", "J. R. R. Tolkien"));
-
-mongoClient.update("books", query, update, res -> {
-
-  if (res.succeeded()) {
-
-    System.out.println("Book updated !");
-
-  } else {
-
-    res.cause().printStackTrace();
-  }
-
-});
-
                                          -

                                          您可以使用 updateWithOptions 方法。

                                          -

                                          如果要指定 update 操作到底是 upsert（upsert 意思是，如果此文档不存在，就保存此文档；此文档存在就更新）或者仅仅只更新，请使用 updateWithOptions 方法并传递参数 UpdateOptions.

                                          -

                                          参数 UpdateOptions 有以下选项：

                                          -
                                            -

                                          • multi

                                            -

                                            若设置为 true，则可以更新多个文档

                                            -
                                            • -

                                          • upsert

                                            -

                                            若设置为 true，则可以在没有查询到要更新的文档时，新增该文档

                                            -
                                            • -

                                          • writeConcern

                                            -

                                            写操作的可靠性（译者注：源码中是用 writeOption 枚举类型来代表的）

                                            -
                                            • -
                                          -
                                          //译者注：MongoDB 默认写操作级别是 WriteOption.ACKNOWLEDGED
-
-JsonObject query = new JsonObject().put("title", "The Hobbit");
-
-// Set the author field
-JsonObject update = new JsonObject().put("$set", new JsonObject().put("author", "J. R. R. Tolkien"));
-
-UpdateOptions options = new UpdateOptions().setMulti(true);
-
-mongoClient.updateWithOptions("books", query, update, options, res -> {
-
-  if (res.succeeded()) {
-
-    System.out.println("Book updated !");
-
-  } else {
-
-    res.cause().printStackTrace();
-  }
-
-});
-
                                          -

                                          替换文档

                                          -

                                          您可以使用 replace 方法来替换文档

                                          -

                                          replace 方法和 update 方法类似，但是并不需要 update 中的 UpdateOptions 参数。因为 replace 方法替换的是 query 参数找到的整个文档。

                                          -

                                          例如替换 books 集合中的一个文档：

                                          -
                                          JsonObject query = new JsonObject().put("title", "The Hobbit");
-
-JsonObject replace = new JsonObject().put("title", "The Lord of the Rings").put("author", "J. R. R. Tolkien");
-
-mongoClient.replace("books", query, replace, res -> {
-
-  if (res.succeeded()) {
-
-    System.out.println("Book replaced !");
-
-  } else {
-
-    res.cause().printStackTrace();
-
-  }
-
-});
-
                                          -

                                          查找文档

                                          -

                                          您可以使用 find 方法查找文档。

                                          -

                                          其中 query 参数用来匹配集合中的文档。

                                          -

                                          例如匹配所有文档：

                                          -
                                          JsonObject query = new JsonObject();
-
-mongoClient.find("books", query, res -> {
-
-  if (res.succeeded()) {
-
-    for (JsonObject json : res.result()) {
-
-      System.out.println(json.encodePrettily());
-
-    }
-
-  } else {
-
-    res.cause().printStackTrace();
-
-  }
-
-});
-
                                          -

                                          又例如匹配 books 集合中某一个作者的所有文档：

                                          -
                                          JsonObject query = new JsonObject().put("author", "J. R. R. Tolkien");
-
-mongoClient.find("books", query, res -> {
-
-  if (res.succeeded()) {
-
-    for (JsonObject json : res.result()) {
-
-      System.out.println(json.encodePrettily());
-
-    }
-
-  } else {
-
-    res.cause().printStackTrace();
-
-  }
-
-});
-
                                          -

                                          查询的结果包装成了 JSON 对象的 List 集合。

                                          -

                                          如果您需要指定返回哪些域，又或者需要指定返回的数据条数，可以使用 findWithOptions 方法，在参数 FindOptions 中指定这些查询要求。

                                          -

                                          FindOptions 中可以设置以下参数：

                                          -
                                            -

                                          • fields

                                            -

                                            指定返回哪些域。默认值为 null ，意味着返回所有域。

                                            -
                                            • -

                                          • sort

                                            -

                                            指定排序字段。默认为 null。

                                            -
                                            • -

                                          • limit

                                            -

                                            指定返回的数据条数。默认值为 -1，意味着返回所有数据。

                                            -
                                            • -

                                          • skip

                                            -

                                            表示返回的结果，跳过的数据行数。默认值为 0 。

                                            -
                                            • -
                                          -
                                          JsonObject query = new JsonObject().put("author", "J. R. R. Tolkien");
-
-mongoClient.findBatch("book", query, res -> {
-
-  if (res.succeeded()) {
-
-    if (res.result() == null) {
-
-      System.out.println("End of research");
-
-    } else {
-
-      System.out.println("Found doc: " + res.result().encodePrettily());
-
-    }
-
-  } else {
-
-    res.cause().printStackTrace();
-
-  }
-});
-
                                          -

                                          所有返回的结果，都可以在回调方法中得到。

                                          -

                                          查询单个文档

                                          -

                                          要查询单个文档，您可以使用 findOne 方法。

                                          -

                                          这有点类似 find 方法，但是仅仅返回 find 方法查询到的第一条数据。

                                          -

                                          删除文档

                                          -

                                          您可以使用 removeDocuments 方法来删除文档。

                                          -

                                          其中 query 参数决定了要删除集合中的哪些文档。

                                          -

                                          例如删除作者为 Tolkien 的所有文档：

                                          -
                                          JsonObject query = new JsonObject().put("author", "J. R. R. Tolkien");
-
-mongoClient.remove("books", query, res -> {
-
-  if (res.succeeded()) {
-
-    System.out.println("Never much liked Tolkien stuff!");
-
-  } else {
-
-    res.cause().printStackTrace();
-
-  }
-});
-
                                          -

                                          删除单个文档

                                          -

                                          您可以使用 removeDocument 方法来删除单个文档。

                                          -

                                          这有点类似 removeDocuments 方法，但是 removeDocument 方法只返回匹配到的第一个文档。

                                          -

                                          文档计数

                                          -

                                          您可以使用 count 方法来计算文档数量。

                                          -

                                          例如计算作者为 Tolkien 的书的数量，结果包装在回调方法中。

                                          -
                                          JsonObject query = new JsonObject().put("author", "J. R. R. Tolkien");
-
-mongoClient.count("books", query, res -> {
-
-  if (res.succeeded()) {
-
-    long num = res.result();
-
-  } else {
-
-    res.cause().printStackTrace();
-
-  }
-});
-
                                          -

                                          管理 MongoDB 集合

                                          -

                                          MongoDB 的所有文档数据都存储在集合中。

                                          -

                                          您可以使用 getCollections 方法来获得所有的集合：

                                          -
                                          mongoClient.getCollections(res -> {
-
-  if (res.succeeded()) {
-
-    List<String> collections = res.result();
-
-  } else {
-
-    res.cause().printStackTrace();
-
-  }
-});
-
                                          -

                                          您也可以使用 createCollection 方法来创建一个新的集合：

                                          -
                                          mongoClient.createCollection("mynewcollectionr", res -> {
-
-  if (res.succeeded()) {
-
-    // Created ok!
-
-  } else {
-
-    res.cause().printStackTrace();
-
-  }
-});
-
                                          -

                                          您也可以使用 dropCollection 方法来删除文档

                                          -
                                          -

                                          请注意：删除一个集合将会删除集合中所有的文档！

                                          -
                                          -
                                          mongoClient.dropCollection("mynewcollectionr", res -> {
-
-  if (res.succeeded()) {
-
-    // Dropped ok!
-
-  } else {
-
-    res.cause().printStackTrace();
-
-  }
-});
-
                                          -

                                          执行 MongoDB 其他命令

                                          -

                                          您可以使用 runCommand 方法来执行任何 MongoDB 命令。

                                          -

                                          使用这种方式，可以发挥出 MongoDB 更多优点，比如使用 MapReduce。更多详情，请参考说明文档 Commands。

                                          -

                                          例如执行 aggregate（译者注：聚合）命令。请注意，命令的名称要做为 runCommand 方法的一个参数，并且同时也必须包含在包装命令的 JSON 参数中。这么做是因为 JSON 不是有序的，但 BSON 却是，而且 MongoDB 期望 BSON 参数的第一个键值对是命令的名称。所以，为了明确 JSON 中的哪个键值对是命令名称，我们也就必须把命令名称单独设置为一个参数：

                                          -
                                          JsonObject command = new JsonObject()
-  .put("aggregate", "collection_name")
-  .put("pipeline", new JsonArray());
-
-mongoClient.runCommand("aggregate", command, res -> {
-  if (res.succeeded()) {
-    JsonArray resArr = res.result().getJsonArray("result");
-    // etc
-  } else {
-    res.cause().printStackTrace();
-  }
-});
-
                                          -

                                          MongoDB 扩展的 JSON 支持

                                          -

                                          目前，MongoDB 只支持 date，oid 和 binary 类型（请参考：http://docs.mongodb.org/manual/reference/mongodb-extended-json ）

                                          -

                                          例如插入含有 date 类型字段的文档：

                                          -
                                          JsonObject document = new JsonObject().put("title", "The Hobbit")
-  //ISO-8601 date
-  .put("publicationDate", new JsonObject().put("$date", "1937-09-21T00:00:00+00:00"));
-
-mongoService.save("publishedBooks", document, res -> {
-
-  if (res.succeeded()) {
-
-    String id = res.result();
-
-    mongoService.findOne("publishedBooks", new JsonObject().put("_id", id), null, res2 -> {
-      if (res2.succeeded()) {
-
-        System.out.println("To retrieve ISO-8601 date : "
-                + res2.result().getJsonObject("publicationDate").getString("$date"));
-
-      } else {
-        res2.cause().printStackTrace();
-      }
-    });
-
-  } else {
-    res.cause().printStackTrace();
-  }
-
-});
-
                                          -

                                          例如插入含有 binary 类型字段的文档以及读取这个字段

                                          -
                                          byte[] binaryObject = new byte[40];
-
-JsonObject document = new JsonObject()
-        .put("name", "Alan Turing")
-        .put("binaryStuff", new JsonObject().put("$binary", binaryObject));
-
-mongoService.save("smartPeople", document, res -> {
-
-  if (res.succeeded()) {
-
-    String id = res.result();
-
-    mongoService.findOne("smartPeople", new JsonObject().put("_id", id), null, res2 -> {
-      if(res2.succeeded()) {
-
-        byte[] reconstitutedBinaryObject = res2.result().getJsonObject("binaryStuff").getBinary("$binary");
-        //This could now be de-serialized into an object in real life
-      } else {
-        res2.cause().printStackTrace();
-      }
-    });
-
-  } else {
-    res.cause().printStackTrace();
-  }
-
-});
-
                                          -

                                          例如保存一个 base 64 编码的字符串，将这个字符串作为 binary 字段插入。并且读取这个字段：

                                          -
                                          String base64EncodedString = "a2FpbHVhIGlzIHRoZSAjMSBiZWFjaCBpbiB0aGUgd29ybGQ=";
-
-JsonObject document = new JsonObject()
-        .put("name", "Alan Turing")
-        .put("binaryStuff", new JsonObject().put("$binary", base64EncodedString));
-
-mongoService.save("smartPeople", document, res -> {
-
-  if (res.succeeded()) {
-
-    String id = res.result();
-
-    mongoService.findOne("smartPeople", new JsonObject().put("_id", id), null, res2 -> {
-      if(res2.succeeded()) {
-
-        String reconstitutedBase64EncodedString = res2.result().getJsonObject("binaryStuff").getString("$binary");
-        //This could now converted back to bytes from the base 64 string
-      } else {
-        res2.cause().printStackTrace();
-      }
-    });
-
-  } else {
-    res.cause().printStackTrace();
-  }
-
-});
-
                                          -

                                          例如插入一个 object ID 并且读取它：

                                          -
                                          String individualId = new ObjectId().toHexString();
-
-JsonObject document = new JsonObject()
-        .put("name", "Stephen Hawking")
-        .put("individualId", new JsonObject().put("$oid", individualId));
-
-mongoService.save("smartPeople", document, res -> {
-
-  if (res.succeeded()) {
-
-    String id = res.result();
-
-    mongoService.findOne("smartPeople", new JsonObject().put("_id", id), null, res2 -> {
-      if(res2.succeeded()) {
-        String reconstitutedIndividualId = res2.result().getJsonObject("individualId").getString("$oid");
-      } else {
-        res2.cause().printStackTrace();
-      }
-    });
-
-  } else {
-    res.cause().printStackTrace();
-  }
-
-});
-
                                          -

                                          例如获取 distinct 后的值：

                                          -
                                          JsonObject document = new JsonObject().put("title", "The Hobbit");
-
-mongoClient.save("books", document, res -> {
-
-  if (res.succeeded()) {
-
-    mongoClient.distinct("books", "title", String.class.getName(), res2 -> {
-      System.out.println("Title is : " + res2.result().getJsonArray(0));
-    });
-
-  } else {
-    res.cause().printStackTrace();
-  }
-
-});
-
                                          -

                                          例如获取批量模式下 distinct 的值：

                                          -
                                          JsonObject document = new JsonObject().put("title", "The Hobbit");
-
-mongoClient.save("books", document, res -> {
-
-  if (res.succeeded()) {
-
-    mongoClient.distinctBatch("books", "title", String.class.getName(), res2 -> {
-      System.out.println("Title is : " + res2.result().getString("title"));
-    });
-
-  } else {
-    res.cause().printStackTrace();
-  }
-
-});
-
                                          -

                                          客户端参数配置

                                          -

                                          此客户端把配置参数放在 JSON 对象中。

                                          -

                                          此客户端支持以下这些参数：

                                          -
                                            -

                                          • db_name

                                            -

                                            使用的 mongoDB 实例的数据库名称。默认是 default_db

                                            -
                                            • -

                                          • useObjectId

                                            -

                                            此参数用来支持 ObjectId 的持久化和检索。如果设置为 true ，将会在集合的文档中，以 16 进制的字符串来保存 MongoDB 的 ObjectId 类型的字段。而且在设置为 true 后，可以让文档基于创建时间排序（译者注：前4个字节用来存储创建的时的时间戳，精确到秒）。您也可以通过使用 ObjectId::getDate() 方法，从这个 16进制的字符串中导出创建时间。若您选择其他类型作为 _id ，则设置此参数为 false 。如果您保存的文档中，没有设置 _id 字段的值，将会默认的生成 16进制的字符串作为 _id 。此参数默认为 false。

                                            -
                                            • -
                                          -

                                          此客户端尝试着支持驱动所支持的大多数参数配置。有两种配置方式，一种是连接字符串，另一种是驱动配置选项。

                                          -
                                          -

                                          请注意：如果使用了字符串连接的方式，此客户端将会忽略所有配置选项。

                                          -
                                          -
                                            -

                                          • connection_string

                                            -

                                            连接字符串，指的是创建客户端的字符串，例如：mongodb://localhost:27017 。有关连接字符串格式的更多信息，请参考驱动程序文档。

                                            -
                                            • -
                                          -

                                          驱动配置的具体选项

                                          -
                                          {
-  // Single Cluster Settings
-  "host" : "127.0.0.1", // string
-  "port" : 27017,      // int
-
-  // Multiple Cluster Settings
-  "hosts" : [
-    {
-      "host" : "cluster1", // string
-      "port" : 27000       // int
-    },
-    {
-      "host" : "cluster2", // string
-      "port" : 28000       // int
-    },
-    ...
-  ],
-  "replicaSet" :  "foo",    // string
-  "serverSelectionTimeoutMS" : 30000, // long
-
-  // Connection Pool Settings
-  "maxPoolSize" : 50,                // int
-  "minPoolSize" : 25,                // int
-  "maxIdleTimeMS" : 300000,          // long
-  "maxLifeTimeMS" : 3600000,         // long
-  "waitQueueMultiple"  : 10,         // int
-  "waitQueueTimeoutMS" : 10000,      // long
-  "maintenanceFrequencyMS" : 2000,   // long
-  "maintenanceInitialDelayMS" : 500, // long
-
-  // Credentials / Auth
-  "username"   : "john",     // string
-  "password"   : "passw0rd", // string
-  "authSource" : "some.db"   // string
-  // Auth mechanism
-  "authMechanism"     : "GSSAPI",        // string
-  "gssapiServiceName" : "myservicename", // string
-
-  // Socket Settings
-  "connectTimeoutMS" : 300000, // int
-  "socketTimeoutMS"  : 100000, // int
-  "sendBufferSize"    : 8192,  // int
-  "receiveBufferSize" : 8192,  // int
-  "keepAlive" : true           // boolean
-
-  // Heartbeat socket settings
-  "heartbeat.socket" : {
-  "connectTimeoutMS" : 300000, // int
-  "socketTimeoutMS"  : 100000, // int
-  "sendBufferSize"    : 8192,  // int
-  "receiveBufferSize" : 8192,  // int
-  "keepAlive" : true           // boolean
-  }
-
-  // Server Settings
-  "heartbeatFrequencyMS" :    1000 // long
-  "minHeartbeatFrequencyMS" : 500 // long
-}
-
                                          -

                                          驱动参数说明

                                          -
                                            -

                                          • host

                                            -

                                            mongoDB 实例运行的地址。默认是 127.0.0.1。 如果设置了 hosts 参数，就会忽略host 参数

                                            -
                                            • -

                                          • port

                                            -

                                            mongoDB 实例监听的端口。默认是 27017。如果设置了 hosts 参数，就会忽略 port 参数

                                            -
                                            • -

                                          • hosts

                                            -

                                            表示支持 MongoDB 集群（分片／复制）的一组地址和端口

                                            -
                                            • -

                                          • host

                                            -

                                            集群中某个运行实例的地址

                                            -
                                            • -

                                          • port

                                            -

                                            集群中某个运行实例监听的端口

                                            -
                                            • -

                                          • replicaSet

                                            -

                                            某个 mongoDB 实例作为副本集的名称

                                            -
                                            • -

                                          • serverSelectionTimeoutMS

                                            -

                                            驱动选择服务器的最大时间，单位毫秒

                                            -
                                            • -

                                          • maxPoolSize

                                            -

                                            连接池最大连接数。默认为 100

                                            -
                                            • -

                                          • minPoolSize

                                            -

                                            连接池最小连接数。默认为 100

                                            -
                                            • -

                                          • maxIdleTimeMS

                                            -

                                            连接池的连接最大空闲时间。默认为 0，表示一直存在

                                            -
                                            • -

                                          • maxLifeTimeMS

                                            -

                                            连接池的连接最大存活时间。默认为 0，表示永远存活。

                                            -
                                            • -

                                          • waitQueueMultiple

                                            -

                                            连接池中最大等待连接数。默认为 500

                                            -
                                            • -

                                          • waitQueueTimeoutMS

                                            -

                                            线程等待作为连接的最长等待时间。默认为 120000（2分钟）

                                            -
                                            • -

                                          • maintenanceFrequencyMS

                                            -

                                            维护任务进行循环检查连接的时间间隔（译者注：维护任务会定时检查连接的状态，直到连接池剩下最小连接数）。默认为 0

                                            -
                                            • -

                                          • maintenanceInitialDelayMS

                                            -

                                            连接池启动后，维护任务第一次启动的时间。默认为 0。

                                            -
                                            • -

                                          • username

                                            -

                                            授权的用户名。默认为 null（意味着不需要授权）

                                            -
                                            • -

                                          • password

                                            -

                                            授权的密码

                                            -
                                            • -

                                          • authSource

                                            -

                                            与授权用户关联的数据库名称。默认值为 db_name

                                            -
                                            • -

                                          • authMechanism

                                            -

                                            所使用的授权认证机制。请参考 Authentication 来获取更多信息。

                                            -
                                            • -

                                          • gssapiServiceName

                                            -

                                            当使用 GSSAPI 的授权机制时，所使用的 Kerberos 服务名。

                                            -
                                            • -

                                          • connectTimeoutMS

                                            -

                                            打开连接超时的时间，单位毫秒。默认为10000（10 秒）

                                            -
                                            • -

                                          • socketTimeoutMS

                                            -

                                            在 socket 上接收或者发送超时的时间。默认为 0 ，意味着永远不超时（译者注：这是客户端的超时时间。如果一个 insert 达到了 socketTimeoutMS， 将无法得知服务器是否已写入）。

                                            -
                                            • -

                                          • sendBufferSize

                                            -

                                            设置 socket 发送缓冲区大小（SO_SNDBUF）。默认为 0，这将使用操作系统默认大小。

                                            -
                                            • -

                                          • receiveBufferSize

                                            -

                                            设置 socket 接收缓冲区大小（SO_RCVBUF）。默认为 0，这将使用操作系统默认大小。

                                            -
                                            • -

                                          • keepAlive

                                            -

                                            设置是否复用 socket（SO_KEEPALIVE）连接。默认为 false

                                            -
                                            • -

                                          • heartbeat.socket

                                            -

                                            配置集群监视器监控 MongoDB 集群的 socket 连接情况的参数

                                            -
                                            • -

                                          • heartbeatFrequencyMS

                                            -

                                            集群监视器访问每个集群服务器的频率。默认为 5000 （5s）

                                            -
                                            • -

                                          • minHeartbeatFrequencyMS

                                            -

                                            最小心跳频率。默认为 1000 （1s）

                                            -
                                            • -
                                          -
                                          -

                                          请注意：上面提到的各类参数的默认值，都是 MongoDB Java 驱动的默认值。请参考驱动文档来获取最新信息。

                                          -
                                          -
                                          -
                                          -

                                          原文档更新于 2017-03-15 15:54:14 CET

                                          -
                                          - - -
                                          - -
                                          -
                                          -
                                          - -

                                          results matching ""

                                          -
                                            - -
                                            -
                                            - -

                                            No results matching ""

                                            - -
                                            -
                                            -
                                            - -
                                            -
                                            - -
                                            - - - - - - - - - - - - - - -
                                            - - -
                                            - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/data/MySQL&PostgreSQLClient.html b/docs/data/MySQL&PostgreSQLClient.html deleted file mode 100644 index 5b66d49..0000000 --- a/docs/data/MySQL&PostgreSQLClient.html +++ /dev/null @@ -1,1205 +0,0 @@ - - - - - - - MySQL/PostgreSQL Client · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                            -
                                            - - - - - - - - -
                                            - -
                                            - -
                                            - - - - - - - - -
                                            -
                                            - -
                                            -
                                            - -
                                            - -

                                            Vert.x MySQL/PostgreSQL Client

                                            -
                                            -

                                            原文档：Vert.x MySQL/PostgreSQL client

                                            -
                                            -

                                            此异步 MySQL/PostgreSQL 客户端给需要与 MySQL 或 PostgreSQL 数据库交互的 Vert.x 应用提供了相应的接口。

                                            -

                                            Vert.x MySQL/PostgreSQL Client（以下简称客户端）底层实现基于 Mauricio Linhares 写的异步驱动 postgresql-async。此组件让 Vert.x 应用能够以异步、非阻塞的方式访问 MySQL 或者 PostgreSQL 数据库。

                                            -

                                            使用 Vert.x MySQL/PostgreSQL 客户端

                                            -

                                            这部分内容阐述了如何在您的应用中配置 Vert.x MySQL/PostgreSQL 客户端。

                                            -

                                            在常规应用中

                                            -

                                            要使用 Vert.x MySQL / PostgreSQL 客户端，您需要把下面的 jar 包加入 CLASSPATH:

                                            - -

                                            所有这些都可以从 Maven 中心库下载。

                                            -

                                            在打包成 fat jar 的应用中

                                            -

                                            如果您使用 Maven 或者 Gradle 构建 Fat-jar 应用，只需要加入下面的依赖：

                                            -
                                              -
                                            • Maven (在 pom.xml 文件中):
                                              • -
                                            -
                                            <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-mysql-postgresql-client</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                            -
                                              -
                                            • Gradle (在 build.gradle 文件中):
                                              • -
                                            -
                                            compile 'io.vertx:vertx-mysql-postgresql-client:3.4.1'
-
                                            -

                                            在使用 Vert.x 环境的应用中

                                            -

                                            如果您使用 Vert.x 环境，需要把上面列出的 jar 包加入到 $VERTX_HOME/lib 路径下。

                                            -

                                            或者，您可以编辑位于 $VERTX_HOME 路径下的vertx-stack.json 文件，并且设置 vertx-mysql-postgresql-client 的依赖为 "included": true。完成后，执行命令：vertx resolve --dir=lib --stack= ./vertx-stack.json，就会下载此客户端及它的依赖。

                                            -

                                            创建客户端对象

                                            -

                                            有几种方式来创建客户端，我们一起来看下。

                                            -

                                            使用默认共享连接池

                                            -

                                            大部分情况下，您都将希望不同的客户端实例（AsyncSQLClient）共享一个连接池。

                                            -

                                            考虑这样一种情况：您在部署 Verticle 时，设置了 Verticle 拥有多个实例化的对象，但是您希望每个 Verticle 实例能够共享同一个数据源，而不是单独为每个 Verticle 实例设置不同的数据源。

                                            -

                                            要解决上面的问题，您可以这么做：

                                            -
                                            JsonObject mySQLClientConfig = new JsonObject().put("host", "mymysqldb.mycompany");
-AsyncSQLClient mySQLClient = MySQLClient.createShared(vertx, mySQLClientConfig);
-
-// 创建一个 PostgreSQL 客户端
-
-JsonObject postgreSQLClientConfig = new JsonObject().put("host", "mypostgresqldb.mycompany");
-AsyncSQLClient postgreSQLClient = PostgreSQLClient.createShared(vertx, postgreSQLClientConfig);
-
                                            -

                                            只有在第一次调用 MySQLClient.createShared 或者 PostgreSQLClient.createShared 方法的时候，才会真正地根据 config 参数创建一个数据源。

                                            -

                                            之后再调用此方法，只会返回一个新的客户端实例，但使用的是相同的数据源。这时 config 参数也就不再有作用。

                                            -

                                            指定数据源名称

                                            -

                                            您还可以像下面这样，在创建一个客户端实例的时候指定数据源的名称：

                                            -
                                            JsonObject mySQLClientConfig = new JsonObject().put("host", "mymysqldb.mycompany");
-AsyncSQLClient mySQLClient = MySQLClient.createShared(vertx, mySQLClientConfig, "MySQLPool1");
-
-// To create a PostgreSQL client:
-
-JsonObject postgreSQLClientConfig = new JsonObject().put("host", "mypostgresqldb.mycompany");
-AsyncSQLClient postgreSQLClient = PostgreSQLClient.createShared(vertx, postgreSQLClientConfig, "PostgreSQLPool1");
-
                                            -

                                            如果不同的客户端对象使用了相同的 Vert.x 对象和相同的数据源名称，那么它们将共享数据源。

                                            -

                                            只有在第一次调用 MySQLClient.createShared 或者 PostgreSQLClient.createShared 方法的时候，才会真正的根据 config 参数创建一个数据源。

                                            -

                                            之后再调用此方法，只会返回一个新的客户端对象，但使用的是相同的数据源。这时 config 参数也就不再有作用。

                                            -

                                            当我们希望不同含义的客户端对象拥有不同的数据源时，可以采用这种方式来创建它的对象，比如它们要与不同的数据库进行交互。

                                            -

                                            创建不共享数据源的客户端对象

                                            -

                                            在大部分情况下，我们会希望在不同的客户端实例之间共享数据源。但有时候，却恰恰相反。

                                            -

                                            这时，可以调用MySQLClient.createNonShared 或者PostgreSQLClient.createNonShared 方法：

                                            -
                                            JsonObject mySQLClientConfig = new JsonObject().put("host", "mymysqldb.mycompany");
-AsyncSQLClient mySQLClient = MySQLClient.createNonShared(vertx, mySQLClientConfig);
-
-// 创建 PostgreSQL 客户端
-
-JsonObject postgreSQLClientConfig = new JsonObject().put("host", "mypostgresqldb.mycompany");
-AsyncSQLClient postgreSQLClient = PostgreSQLClient.createNonShared(vertx, postgreSQLClientConfig);
-
                                            -

                                            每次调用此方法，就相当于在调用 MySQLClient.createShared 或者 PostgreSQLClient.createShared 方法时加上了具有唯一名称的数据源参数。

                                            -

                                            关闭客户端

                                            -

                                            您可以较长时间的持有客户端对象（比如在 Verticle 的整个生命周期里），可一旦不再使用，就应该使用 close(handler) 或者 close() 方法来关闭它。

                                            -

                                            获取数据库连接

                                            -

                                            您可以使用 getConnection 方法来获得数据库连接。

                                            -

                                            此方法从连接池中获取一个数据库连接，并返回给回调方法：

                                            -
                                            client.getConnection(res -> {
-  if (res.succeeded()) {
-
-    SQLConnection connection = res.result();
-
-    // 获得一个连接
-
-  } else {
-    // 获取连接失败 - 处理异常
-  }
-});
-
                                            -

                                            一旦您用完一个数据库连接后，请确保关闭它。

                                            -

                                            获取的连接，是接口 SQLConnection 的一个实现。但是 SQLConnection 是一个通用接口，不只是在此客户端中有用到。

                                            -

                                            您可以在 Vert.x Common SQL Interface 文档 中了解如何去使用它。

                                            -

                                            日期和时间戳

                                            -

                                            只要您从数据库从获取时间格式的数据，此客户端都将会隐式将它们转换成 ISO 8601（yyyy-MM-ddTHH:mm:ss.SSS）格式的字符串。MySQL 会舍弃毫秒项，所以您会看到 .000。

                                            -

                                            最后插入的数据id

                                            -

                                            在表中插入新数据时，您也许希望获得数据库的自增长id。JDBC API 通常都会让您从数据库连接中得到最后一个插入的 id。在 MySQL 中，可以按照 JDBC API 描述的方式获得最后插入的 id，而在 PostgreSQL 中，您可以使用 RETURNING clause。您可以选择使用其中的一个 query 方法来获取返回的列。

                                            -

                                            存储过程

                                            -

                                            call 和 callWithParams 方法目前暂未实现。

                                            -

                                            配置参数

                                            -

                                            PostgreSql 和 MySql 客户端的配置参数一样：

                                            -
                                            {
-  "host" : <主机地址>,
-  "port" : <端口>,
-  "maxPoolSize" : <最大连接数>,
-  "username" : <用户名>,
-  "password" : <密码>,
-  "database" : <数据库名称>,
-  "charset" : <编码>,
-  "queryTimeout" : <查询超时时间-毫秒>
-}
-
                                            -
                                              -

                                            • host

                                              -

                                              数据库主机地址，默认为 localhost。

                                              -
                                              • -

                                            • port

                                              -

                                              数据库端口，PostgreSQL 默认为 5432，MySQL 默认为 3306 。

                                              -
                                              • -

                                            • maxPoolSize

                                              -

                                              最大连接数。默认为 10。

                                              -
                                              • -

                                            • username

                                              -

                                              数据库用户名，PostgreSQL 默认为 postgres ，MySQL 默认为 root 。

                                              -
                                              • -

                                            • password

                                              -

                                              数据库密码，默认不设置。

                                              -
                                              • -

                                            • database

                                              -

                                              数据库名称，默认为 testdb。

                                              -
                                              • -

                                            • charset

                                              -

                                              编码格式，默认为 UTF-8。

                                              -
                                              • -

                                            • queryTimeout

                                              -

                                              查询超时时间（毫秒），默认为 10000 (= 10秒)。

                                              -
                                              • -
                                            -
                                            -
                                            -

                                            原文档更新于2017-03-15 15:54:14 CET

                                            -
                                            - - -
                                            - -
                                            -
                                            -
                                            - -

                                            results matching ""

                                            -
                                              - -
                                              -
                                              - -

                                              No results matching ""

                                              - -
                                              -
                                              -
                                              - -
                                              -
                                              - -
                                              - - - - - - - - - - - - - - -
                                              - - -
                                              - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/data/RedisClient.html b/docs/data/RedisClient.html deleted file mode 100644 index 4ba73ab..0000000 --- a/docs/data/RedisClient.html +++ /dev/null @@ -1,1221 +0,0 @@ - - - - - - - Redis Client · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                              -
                                              - - - - - - - - -
                                              - -
                                              - -
                                              - - - - - - - - -
                                              -
                                              - -
                                              -
                                              - -
                                              - -

                                              Vert.x Redis

                                              -
                                              -

                                              原文档：Vert.x Redis

                                              -
                                              -

                                              Vert.x Redis Client 是 Vert.x 配套的 Redis 客户端实现。

                                              -

                                              您可以通过 Vert.x Redis Client 来对 Redis 中的数据进行保存、获取、搜索和删除。Redis 是一个基于BSD协议开源的高性能Key-Value数据库。它可以存储字符串、哈希(hashes)、列表、无序集合(sets)和有序集合(sorted sets)，所以通常被用做结构化数据存储服务器。要使用本组件，您必须有一个运行中的 Redis 实例。

                                              -

                                              Redis 有着丰富的 API，总结如下：

                                              -
                                                -
                                              • Cluster - 与集群相关的命令。要使用这些命令，Redis 服务器的版本必须 >=3.0.0
                                                • -
                                              • Connection - 切换 DB、建立连接、断开连接、授权相关的命令
                                                • -
                                              • Hashes - 操作 hash 相关的命令
                                                • -
                                              • HyperLogLog - 使用 HyperLogLog 算法来快速计算元素基数的相关命令
                                                • -
                                              • Keys - 操作 Redis key 的相关命令
                                                • -
                                              • List - 操作 List 的相关命令
                                                • -
                                              • Pub/Sub - 发布／订阅模式的消息队列相关命令
                                                • -
                                              • Scripting - 解释运行 Lua 脚本的相关命令
                                                • -
                                              • Server - 管理 Redis 服务器的相关命令
                                                • -
                                              • Sets - 操作无序集合的相关命令
                                                • -
                                              • Sorted Sets - 操作有序集合的相关命令
                                                • -
                                              • Strings - 操作字符串的相关命令
                                                • -
                                              • Transactions - 处理事务的相关命令
                                                • -
                                              -

                                              使用 Vert.x Redis

                                              -

                                              要使用 Vert.x Redis 客户端，需要添加下列依赖：

                                              -
                                                -
                                              • Maven (在 pom.xml 文件中):
                                                • -
                                              -
                                              <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-redis-client</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                              -
                                                -
                                              • Gradle (在 build.gradle 文件中):
                                                • -
                                              -
                                              compile 'io.vertx:vertx-redis-client:3.4.1'
-
                                              -

                                              连接 Redis 服务器

                                              -

                                              要连接到 Redis 服务器，需要配置一些参数。配置参数包装在 RedisOptions 对象中，有以下这些参数：

                                              -
                                                -
                                              • host: 默认是 localhost
                                                • -
                                              • port: 默认是 6379
                                                • -
                                              • encoding: 默认是 UTF-8
                                                • -
                                              • tcpKeepAlive: 默认是 true
                                                • -
                                              • tcpNoDelay: 默认是 true
                                                • -
                                              -

                                              例如：

                                              -
                                              RedisOptions config = new RedisOptions()
-    .setHost("127.0.0.1");
-
-RedisClient redis = RedisClient.create(vertx, config);
-
                                              -

                                              Vert.x Redis 客户端在连接 Redis 服务器失败时，会尝试重连。所以，如果您连接的 Redis 服务器需要授权，或者您连接的 Redis 服务器的 DB 不是默认 DB，您需要提供授权的密码，或者 DB 的 ID，配置参数如下：

                                              -
                                                -
                                              • auth
                                                • -
                                              • select
                                                • -
                                              -

                                              如果您不这样做，而是手动调用 auth 或者 select 方法，那么当出现 socket 错误的时候，Vert.x Redis 客户端将不知道如何修复错误。

                                              -

                                              执行命令

                                              -

                                              当使用 Vert.x Redis 客户端连接到 Redis 服务器后，就可以使用 Vert.x Redis 客户端执行 Redis 命令。Vert.x Redis 客户端为执行 Redis 命令提供了一套十分简洁的 API，省去了手写命令的麻烦。例如，如果想通过 key 获得 value的话，可以这样：

                                              -
                                              RedisClient redis = RedisClient.create(vertx, new RedisOptions());
-
-redis.get("mykey", res -> {
-  if (res.succeeded()) {
-    // so something...
-  }
-});
-
                                              -

                                              要想了解更多 Redis 命令，请参考 Redis 官方文档。

                                              -

                                              发布／订阅模式

                                              -

                                              Redis 支持发布／订阅模式的消息队列。需要注意，一旦一个 Redis 连接被注册为订阅者时，此连接将不能再执行其他命令，直到这个连接使用取消订阅者的命令。

                                              -

                                              可以这样注册一个订阅者：

                                              -
                                              vertx.eventBus().<JsonObject>consumer("io.vertx.redis.channel1", received -> {
-  // 操作接收到的消息
-  JsonObject value = received.body().getJsonObject("value");
-  // value 是一个包含下面数据的 JSON 对象
-  // channel - 发布消息的 channel
-  // pattern - 若您使用匹配符来匹配消息 channel，Pattern 代表的是匹配符
-  // message - 发布的消息载体
-});
-
-RedisClient redis = RedisClient.create(vertx, new RedisOptions());
-
-redis.subscribe("channel1", res -> {
-    if (res.succeeded()) {
-        // so something...
-    }
-});
-
                                              -

                                              发布消息：

                                              -
                                              RedisClient redis = RedisClient.create(vertx, new RedisOptions());
-
-redis.publish("channel1", "Hello World!", res -> {
-    if (res.succeeded()) {
-        // so something...
-    }
-});
-
                                              -

                                              更简洁的 hash 命令

                                              -

                                              大部分 Redis 命令使用单个字符串或者字符串数组来作为参数，并且返回的也是单个字符串或者字符串数组。不过在处理 hash 值时，有其他一些更简洁的方式。

                                              -

                                              hgetall 命令

                                              -

                                              hgetall 命令返回的结果将被转换成 JSON 对象。这样，您就可以使用 JSON 的语法来进行交互，这在与 Event Bus 通信时十分方便。

                                              -

                                              mset 命令

                                              -

                                              您可以向 mset 命令传入一个 JSON 对象以在 hash 中设置多个值。需要注意 key 和 value 都将被转换成字符串。

                                              -
                                              {
-  keyName: "value",
-  otherKeyName: "other value"
-}
-
                                              -

                                              msetnx 命令

                                              -

                                              您可以向 msetnx 命令传入一个 JSON 对象以在 hash 中设置多个值（译者注：msetnx 命令，必须当且仅当所有给定 key 都不存在）。需要注意 key 和 value 都将被转换成字符串。

                                              -
                                              {
-  keyName: "value",
-  otherKeyName: "other value"
-}
-
                                              -

                                              hmset 命令

                                              -

                                              您可以向 hmset 命令传入一个 JSON 对象以在 hash 中设置多个值（译者注：hmset 命令，如果给定 key 不存在，将创建新的 key）。需要注意 key 和 value 都将被转换成字符串。

                                              -
                                              {
-  keyName: "value",
-  otherKeyName: "other value"
-}
-
                                              -

                                              zadd 命令

                                              -

                                              调用 zaddMany 方法可以同时向有序集合中添加多个member。需要注意 key 和 value 都将被转换成字符串。

                                              -
                                              -

                                              译者注：在 Vert.x Redis Client 中，zadd 方法和 zaddMany 方法都对应 Redis 中的 zadd 命令。不同之处在于，zaddMany 方法可以添加多个 score-member。

                                              -

                                              译者注：实际在 zaddMany 方法中，传入的是 Map<String, Double> 类型的参数。

                                              -
                                              -
                                              {
-  score: "member",
-  otherScore: "other member"
-}
-
                                              -

                                              服务器信息

                                              -

                                              为让返回的服务器信息易于操作，Vert.x Redis 客户端将会把服务器信息转换成利于理解的 JSON 格式。格式为：JSON 对象的每个部分都包装着属于着这部分的属性。不在这个部分的属性，将会以其他的顶级对象部分展现：

                                              -
                                              {
-  server: {
-    redis_version: "2.5.13",
-    redis_git_sha1: "2812b945",
-    redis_git_dirty: "0",
-    os: "Linux 2.6.32.16-linode28 i686",
-    arch_bits: "32",
-    multiplexing_api: "epoll",
-    gcc_version: "4.4.1",
-    process_id: "8107",
-    ...
-  },
-  memory: {...},
-  client: {...},
-  ...
-}
-
                                              -

                                              Eval 和 Evalsha 命令

                                              -

                                              eval 和 evalsha 命令十分特殊，因为它们可以返回任意类型。Vert.x 基于 Java 语言，而 Java 是强类型语言，并且我们又要避免使用 Object 类型，这使得返回任意类型变得比较困难。避免使用 Object 类型的原因是因为 Vert.x 也是多语言的，而不同语言之间的类型转换实现起来十分的复杂和困难。所以，我们会用 JsonArray 来包装 eval 和 evalsha 命令的返回值，即便是像下面这样简单的脚本：

                                              -
                                              return 10
-
                                              -

                                              执行上面的脚本，将返回一个 JsonArray 对象，且下标为 0 的值为 10。

                                              -
                                              -
                                              -

                                              原文档更新于2017-03-15 15:54:14 CET

                                              -
                                              - - -
                                              - -
                                              -
                                              -
                                              - -

                                              results matching ""

                                              -
                                                - -
                                                -
                                                - -

                                                No results matching ""

                                                - -
                                                -
                                                -
                                                - -
                                                -
                                                - -
                                                - - - - - - - - - - - - - - -
                                                - - -
                                                - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/data/SQLCommon.html b/docs/data/SQLCommon.html deleted file mode 100644 index 6801766..0000000 --- a/docs/data/SQLCommon.html +++ /dev/null @@ -1,1343 +0,0 @@ - - - - - - - SQL Common · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                -
                                                - - - - - - - - -
                                                - -
                                                - -
                                                - - - - - - - - -
                                                -
                                                - -
                                                -
                                                - -
                                                - -

                                                Vert.x Common SQL Interface

                                                -
                                                -

                                                原文档：Vert.x Common SQL interface

                                                -
                                                -

                                                Vert.x Common SQL Interface组件定义了 Vert.x 与各种 SQL 服务交互的方法。

                                                -

                                                您必须通过使用特定的 SQL 服务（例如 JDBC/MySQL/PostgreSQL）的接口来获取数据库连接。

                                                -

                                                要使用此组件，需要添加下列依赖：

                                                -
                                                  -
                                                • Maven (在 pom.xml文件中):
                                                  • -
                                                -
                                                <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-sql-common</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                -
                                                  -
                                                • Gradle (在 build.gradle 文件中):
                                                  • -
                                                -
                                                compile 'io.vertx:vertx-sql-common:3.4.1'
-
                                                -

                                                SQL 连接

                                                -

                                                我们用 SQLConnection 接口来表示数据库连接（译者注：此接口中包含各种基本的操作方法）。

                                                -

                                                自动提交

                                                -

                                                当您获取的数据库连接，其自动提交选项（auto commit）默认设置为 true。这意味着您的每个操作都将在单独的事务中有效执行。

                                                -

                                                如果您希望在同一个事务中执行多个操作，就应该使用 setAutoCommit 方法设置自动提交为false。

                                                -

                                                当操作完成时，回调方法将会被执行：

                                                -
                                                connection.setAutoCommit(false, res -> {
-  if (res.succeeded()) {
-    // 成功！
-  } else {
-    // 失败!
-  }
-});
-
                                                -

                                                执行查询

                                                -

                                                您可以使用 query 方法执行查询操作。

                                                -

                                                查询语句（原生SQL）传给数据库时，不会经过任何修改。

                                                -

                                                当查询结束时，将执行回调方法处理结果。查询结果包装在 ResultSet 中。

                                                -
                                                connection.query("SELECT ID, FNAME, LNAME, SHOE_SIZE from PEOPLE", res -> {
-  if (res.succeeded()) {
-    // 获得 result set
-    ResultSet resultSet = res.result();
-  } else {
-    // 失败!
-  }
-});
-
                                                -

                                                ResultSet 类代表查询结果。

                                                -

                                                您可以通过 getColumnNames 方法获得查询结果的列名 List 集合，实际的结果集可以通过 getResults 方法获得。结果集被包装成了一组 JsonArray 列表，其中的每个元素代表一行结果。

                                                -
                                                List<String> columnNames = resultSet.getColumnNames();
-
-List<JsonArray> results = resultSet.getResults();
-
-for (JsonArray row : results) {
-
-  String id = row.getString(0);
-  String fName = row.getString(1);
-  String lName = row.getString(2);
-  int shoeSize = row.getInteger(3);
-
-}
-
                                                -

                                                您还可以使用 getRows 方法来获得被包装成了 JSON 对象列表（List<JsonObject>）的结果集，这样能让 API 的操作更简单些。但要注意的是，查询出的结果集中可能会出现重复的列名。若遇到这样的情况，您应该选择使用 getResults 方法。

                                                -

                                                下面是将结果集作为 JsonObject 进行迭代的例子：

                                                -
                                                List<JsonObject> rows = resultSet.getRows();
-
-for (JsonObject row : rows) {
-
-  String id = row.getString("ID");
-  String fName = row.getString("FNAME");
-  String lName = row.getString("LNAME");
-  int shoeSize = row.getInteger("SHOE_SIZE");
-
-}
-
                                                -

                                                预编译查询

                                                -

                                                您可以使用 queryWithParams 方法执行预编译查询（prepared statement queries）。此方法接受含参数占位符的SQL查询语句以及 JsonArray 对象（用于传递参数）或参数值。

                                                -
                                                String query = "SELECT ID, FNAME, LNAME, SHOE_SIZE from PEOPLE WHERE LNAME=? AND SHOE_SIZE > ?";
-JsonArray params = new JsonArray().add("Fox").add(9);
-
-connection.queryWithParams(query, params, res -> {
-
-  if (res.succeeded()) {
-    // 获得 result set
-    ResultSet resultSet = res.result();
-  } else {
-    // 失败!
-  }
-});
-
                                                -

                                                执行 INSERT/UPDATE/DELETE 语句

                                                -

                                                您可以使用 update 方法来执行更新数据库的操作（包括增、删、改）。

                                                -

                                                更新语句（原生SQL）传给数据库时，不会经过任何处理。

                                                -

                                                当更新结束时，将执行回调方法处理结果。更新结果包装在 UpdateResult 对象中。

                                                -

                                                您可以通过 getUpdated 方法获得更新的数据条数，并且如果更新操作有生成主键，可以通过 getKeys方法获得对应的主键。

                                                -
                                                connection.update("INSERT INTO PEOPLE VALUES (null, 'john', 'smith', 9)", res -> {
-  if (res.succeeded()) {
-
-    UpdateResult result = res.result();
-    System.out.println("Updated no. of rows: " + result.getUpdated());
-    System.out.println("Generated keys: " + result.getKeys());
-
-  } else {
-    // Failed!
-  }
-});
-
                                                -

                                                预编译更新

                                                -

                                                您可以使用 updateWithParams 方法来执行预编译更新（prepared statement updates）。此方法接受含参数占位符的SQL更新语句以及 JsonArray 对象（用于传递参数）或参数值。

                                                -
                                                String update = "UPDATE PEOPLE SET SHOE_SIZE = 10 WHERE LNAME=?";
-JsonArray params = new JsonArray().add("Fox");
-
-connection.updateWithParams(update, params, res -> {
-
-  if (res.succeeded()) {
-
-    UpdateResult updateResult = res.result();
-
-    System.out.println("No. of rows updated: " + updateResult.getUpdated());
-
-  } else {
-
-    // Failed!
-
-  }
-});
-
                                                -

                                                可调用语句

                                                -

                                                您可以使用 callWithParams 方法来执行可调用语句（callable statements），例如 SQL 函数或者存储过程。此方法接受以下参数：

                                                -
                                                  -
                                                • 可调用语句。可以使用标准 JDBC 格式 { call func_proc_name() }，也可以选择使用占位符传参数的形式，例如：{ call func_proc_name(?, ?) }
                                                  • -
                                                • 输入参数集（params），JsonArray 类型
                                                  • -
                                                • 包含输出类型的输出结果集（output），JsonArray 类型，例如：[null, 'VARCHAR']
                                                  • -
                                                • 对应的回调函数（resultHandler）
                                                  • -
                                                -

                                                请注意，输出结果集的 JsonArray 的下标和输入参数的 JsonArray 同样重要。如果第二个参数代表输出结果集，那么应该设置结果集的 JsonArray 的第一个元素为 null。

                                                -

                                                有些 SQL 函数只使用 return 关键字返回输出结果集，这时可以这样调用：

                                                -
                                                String func = "{ call one_hour_ago() }";
-
-connection.call(func, res -> {
-
-  if (res.succeeded()) {
-    ResultSet result = res.result();
-  } else {
-    // Failed!
-  }
-});
-
                                                -

                                                但是当您使用存储过程时，还是需要使用它的参数来返回结果集。如果一个存储过程没有返回值的话，可以像下面这样调用：

                                                -
                                                String func = "{ call new_customer(?, ?) }";
-
-connection.callWithParams(func, new JsonArray().add("John").add("Doe"), null, res -> {
-
-  if (res.succeeded()) {
-    // 成功!
-  } else {
-    // 失败!
-  }
-});
-
                                                -

                                                但是如果存储过程有返回值的话，需要像下面这样调用：

                                                -
                                                String func = "{ call customer_lastname(?, ?) }";
-
-connection.callWithParams(func, new JsonArray().add("John"), new JsonArray().addNull().add("VARCHAR"), res -> {
-
-  if (res.succeeded()) {
-    ResultSet result = res.result();
-  } else {
-    // 失败!
-  }
-});
-
                                                -

                                                请注意：输入输出参数的下标必须匹配 ? 的下标，并且输出结果集元素的值必须是结果集类型的字符串表示。

                                                -

                                                为避免歧义，实现类需要遵循以下规则（译者注：可参考 Vert.x JDBC Client 的实现源码 JDBCStatementHelper.fillStatement(statement, in, out)）：

                                                -
                                                  -
                                                • 当 IN 参数的元素是 NOT NULL 时，此元素将被注册为输入参数
                                                  • -
                                                • 当 IN 参数的元素是 null 时，将进一步去检查 OUT 参数的元素值，再做判断
                                                  • -
                                                • 若当 IN 参数的元素是 null，且 OUT 参数的元素值不是 null 时，OUT 参数的元素值将被注册为输出参数
                                                  • -
                                                • 若当 IN 参数的元素是 null，且 OUT 参数的元素值也是 null 时， IN 参数的元素将被当作 NULL 值传入存储过程
                                                  • -
                                                -

                                                注册为 OUT 的参数，设置成了 ResultSet 的 output 属性。

                                                -

                                                批量操作

                                                -

                                                Vert.x SQL 公共接口定义了3种批量操作的方法：

                                                - -

                                                批量操作能执行一组 SQL 语句（List 类型），例如：

                                                -
                                                List<String> batch = new ArrayList<>();
-batch.add("INSERT INTO emp (NAME) VALUES ('JOE')");
-batch.add("INSERT INTO emp (NAME) VALUES ('JANE')");
-
-connection.batch(batch, res -> {
-  if (res.succeeded()) {
-    List<Integer> result = res.result();
-  } else {
-    // 失败!
-  }
-});
-
                                                -

                                                预编译或者调用语句将会根据参数列表，来重复使用 SQL 语句，例如：

                                                -
                                                List<JsonArray> batch = new ArrayList<>();
-batch.add(new JsonArray().add("joe"));
-batch.add(new JsonArray().add("jane"));
-
-connection.batchWithParams("INSERT INTO emp (name) VALUES (?)", batch, res -> {
-  if (res.succeeded()) {
-    List<Integer> result = res.result();
-  } else {
-    // Failed!
-  }
-});
-
                                                -

                                                执行其他操作

                                                -

                                                若需要执行其他数据库操作，例如您可以使用 execute 方法来执行 CREATE TABLE 语句。

                                                -

                                                SQL语句传给数据库时，不会经过任何处理。操作结束时将调用回调方法。

                                                -
                                                String sql = "CREATE TABLE PEOPLE (ID int generated by default as identity (start with 1 increment by 1) not null," +
-  "FNAME varchar(255), LNAME varchar(255), SHOE_SIZE int);";
-
-connection.execute(sql, execute -> {
-  if (execute.succeeded()) {
-    System.out.println("Table created !");
-  } else {
-    // 失败!
-  }
-});
-
                                                -

                                                返回多个结果集

                                                -

                                                某些情况下，您的查询语句可能返回多个结果集 ResultSet，此时，返回的结果集会被转成纯 JSON，并且为了保持稳定性，下一个 ResultSet 被作为当前 ResultSet 的 next 属性链接着。一种简单的遍历所有结果集的方式如下：

                                                -
                                                while (rs != null) {
-  // do something with the result set...
-
-  // next step
-  rs = rs.getNext();
-}
-
                                                -

                                                Streaming

                                                -

                                                在处理大数据结果集时，不建议使用上面提到的API，而是使用数据流（stream data）的方式。因为它能够避免把所有的返回值加载到内存中，而且得到的 JSON 格式的数据也能够一行行的处理，例如：

                                                -
                                                connection.queryStream("SELECT * FROM large_table", stream -> {
-  if (stream.succeeded()) {
-    stream.result().handler(row -> {
-      // 处理 row...
-    });
-  }
-});
-
                                                -

                                                您还可以控制 Stream 何时停止，何时恢复，何时结束。对于查询返回多个结果集的情况，您应该使用 ended event 来获得下一个结果集。如果有，Stream 将会得到新的结果集，若没有，将会调用结束方法。

                                                -
                                                connection.queryStream("SELECT * FROM large_table; SELECT * FROM other_table", stream -> {
-  if (stream.succeeded()) {
-    SQLRowStream sqlRowStream = stream.result();
-
-    sqlRowStream
-      .resultSetClosedHandler(v -> {
-        // 如果有新的结果集，将会重启 stream
-        sqlRowStream.moreResults();
-      })
-      .handler(row -> {
-        // 处理row
-      })
-      .endHandler(v -> {
-        // 没有新的结果集需要处理
-      });
-  }
-});
-
                                                -

                                                使用事务

                                                -

                                                要使用事务，首先要用 setAutoCommit 方法设置 auto-commit 为 false。

                                                -

                                                然后您就可以执行在同一个事务中的操作，在需要提交事务时，调用 commit 方法；在需要回滚时，调用 rollback 方法。

                                                -

                                                一旦 commit/rollback 方法执行结束，将会调用回调方法。然后下一个事务也将自动开始。

                                                -
                                                connection.commit(res -> {
-  if (res.succeeded()) {
-    // 事物提交成功!
-  } else {
-    // 事物提交失败!
-  }
-});
-
                                                -

                                                关闭连接

                                                -

                                                您在用完连接后，必须使用 close 方法把连接返回给连接池。

                                                -
                                                -
                                                -

                                                原文档更新于2017-03-15 15:54:14 CET

                                                -
                                                - - -
                                                - -
                                                -
                                                -
                                                - -

                                                results matching ""

                                                -
                                                  - -
                                                  -
                                                  - -

                                                  No results matching ""

                                                  - -
                                                  -
                                                  -
                                                  - -
                                                  -
                                                  - -
                                                  - - - - - - - - - - - - - - -
                                                  - - -
                                                  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/devops/Devops.html b/docs/devops/Devops.html deleted file mode 100644 index dec74f8..0000000 --- a/docs/devops/Devops.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - Devops · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                  -
                                                  - - - - - - - - -
                                                  - -
                                                  - -
                                                  - - - - - - - - -
                                                  -
                                                  - -
                                                  -
                                                  - -
                                                  - -

                                                  Vert.x Devops

                                                  - - -
                                                  - -
                                                  -
                                                  -
                                                  - -

                                                  results matching ""

                                                  -
                                                    - -
                                                    -
                                                    - -

                                                    No results matching ""

                                                    - -
                                                    -
                                                    -
                                                    - -
                                                    -
                                                    - -
                                                    - - - - - - - - - - - - - - -
                                                    - - -
                                                    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/devops/Docker.html b/docs/devops/Docker.html deleted file mode 100644 index 6b737dd..0000000 --- a/docs/devops/Docker.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - Docker · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                    -
                                                    - - - - - - - - -
                                                    - -
                                                    - -
                                                    - - - - - - - - -
                                                    -
                                                    - -
                                                    -
                                                    - -
                                                    - -

                                                    Vert.x Docker

                                                    - - -
                                                    - -
                                                    -
                                                    -
                                                    - -

                                                    results matching ""

                                                    -
                                                      - -
                                                      -
                                                      - -

                                                      No results matching ""

                                                      - -
                                                      -
                                                      -
                                                      - -
                                                      -
                                                      - -
                                                      - - - - - - - - - - - - - - -
                                                      - - -
                                                      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/devops/HealthCheck.md b/docs/devops/HealthCheck.md deleted file mode 100644 index 76b2df6..0000000 --- a/docs/devops/HealthCheck.md +++ /dev/null @@ -1 +0,0 @@ -# Vert.x Health Check diff --git a/docs/devops/MetricsUsingDropwizard.html b/docs/devops/MetricsUsingDropwizard.html deleted file mode 100644 index 13f8928..0000000 --- a/docs/devops/MetricsUsingDropwizard.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - Metrics Using Dropwizard · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                      -
                                                      - - - - - - - - -
                                                      - -
                                                      - -
                                                      - - - - - - - - -
                                                      -
                                                      - -
                                                      -
                                                      - -
                                                      - -

                                                      Vert.x Metrics Using Dropwizard

                                                      - - -
                                                      - -
                                                      -
                                                      -
                                                      - -

                                                      results matching ""

                                                      -
                                                        - -
                                                        -
                                                        - -

                                                        No results matching ""

                                                        - -
                                                        -
                                                        -
                                                        - -
                                                        -
                                                        - -
                                                        - - - - - - - - - - - - - - -
                                                        - - -
                                                        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/devops/MetricsUsingHawkular.html b/docs/devops/MetricsUsingHawkular.html deleted file mode 100644 index 505e0f9..0000000 --- a/docs/devops/MetricsUsingHawkular.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - Metrics Using Hawkular · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                        -
                                                        - - - - - - - - -
                                                        - -
                                                        - -
                                                        - - - - - - - - -
                                                        -
                                                        - -
                                                        -
                                                        - -
                                                        - -

                                                        Vert.x Metrics Using Hawkular

                                                        - - -
                                                        - -
                                                        -
                                                        -
                                                        - -

                                                        results matching ""

                                                        -
                                                          - -
                                                          -
                                                          - -

                                                          No results matching ""

                                                          - -
                                                          -
                                                          -
                                                          - -
                                                          -
                                                          - -
                                                          - - - - - - - - - - - - - - -
                                                          - - -
                                                          - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/devops/Shell.html b/docs/devops/Shell.html deleted file mode 100644 index c3e4e72..0000000 --- a/docs/devops/Shell.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - Shell · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                          -
                                                          - - - - - - - - -
                                                          - -
                                                          - -
                                                          - - - - - - - - -
                                                          -
                                                          - -
                                                          -
                                                          - -
                                                          - -

                                                          Vert.x Shell

                                                          - - -
                                                          - -
                                                          -
                                                          -
                                                          - -

                                                          results matching ""

                                                          -
                                                            - -
                                                            -
                                                            - -

                                                            No results matching ""

                                                            - -
                                                            -
                                                            -
                                                            - -
                                                            -
                                                            - -
                                                            - - - - - - - - - - - - - - -
                                                            - - -
                                                            - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/devops/StackManager.html b/docs/devops/StackManager.html deleted file mode 100644 index d829864..0000000 --- a/docs/devops/StackManager.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - Stack Manager · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                            -
                                                            - - - - - - - - -
                                                            - -
                                                            - -
                                                            - - - - - - - - -
                                                            -
                                                            - -
                                                            -
                                                            - -
                                                            - -

                                                            Vert.x Stack Manager

                                                            - - -
                                                            - -
                                                            -
                                                            -
                                                            - -

                                                            results matching ""

                                                            -
                                                              - -
                                                              -
                                                              - -

                                                              No results matching ""

                                                              - -
                                                              -
                                                              -
                                                              - -
                                                              -
                                                              - -
                                                              - - - - - - - - - - - - - - -
                                                              - - -
                                                              - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/eventbusbridge/CamelBridge.html b/docs/eventbusbridge/CamelBridge.html deleted file mode 100644 index 9cede09..0000000 --- a/docs/eventbusbridge/CamelBridge.html +++ /dev/null @@ -1,1053 +0,0 @@ - - - - - - - Camel Bridge · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                              -
                                                              - - - - - - - - -
                                                              - -
                                                              - -
                                                              - - - - - - - - -
                                                              -
                                                              - -
                                                              -
                                                              - -
                                                              - -

                                                              Vert.x Camel Bridge

                                                              - - -
                                                              - -
                                                              -
                                                              -
                                                              - -

                                                              results matching ""

                                                              -
                                                                - -
                                                                -
                                                                - -

                                                                No results matching ""

                                                                - -
                                                                -
                                                                -
                                                                - -
                                                                -
                                                                - -
                                                                - - - - - - - - - - -
                                                                - - -
                                                                - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/eventbusbridge/TCPEventbusBridge.html b/docs/eventbusbridge/TCPEventbusBridge.html deleted file mode 100644 index 5d558de..0000000 --- a/docs/eventbusbridge/TCPEventbusBridge.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - TCP Eventbus Bridge · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                -
                                                                - - - - - - - - -
                                                                - -
                                                                - -
                                                                - - - - - - - - -
                                                                -
                                                                - -
                                                                -
                                                                - -
                                                                - -

                                                                Vert.x TCP Eventbus Bridge

                                                                - - -
                                                                - -
                                                                -
                                                                -
                                                                - -

                                                                results matching ""

                                                                -
                                                                  - -
                                                                  -
                                                                  - -

                                                                  No results matching ""

                                                                  - -
                                                                  -
                                                                  -
                                                                  - -
                                                                  -
                                                                  - -
                                                                  - - - - - - - - - - - - - - -
                                                                  - - -
                                                                  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/gitbook/fonts/fontawesome/FontAwesome.otf b/docs/gitbook/fonts/fontawesome/FontAwesome.otf deleted file mode 100644 index d4de13e832d567ff29c5b4e9561b8c370348cc9c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 124988 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ÐT?>-5aYhU|+1c>&YMpPK5x#-mbV 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'NS^o{z1ZKlHsAybrl=JE7AP369ntV%vB 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 CDx5C> diff --git a/docs/gitbook/fonts/fontawesome/fontawesome-webfont.eot b/docs/gitbook/fonts/fontawesome/fontawesome-webfont.eot deleted file mode 100644 index c7b00d2ba8896fd29de846b19f89fcf0d56ad152..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 76518 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%0DyT{kunD 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⋙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 z - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/docs/gitbook/fonts/fontawesome/fontawesome-webfont.ttf b/docs/gitbook/fonts/fontawesome/fontawesome-webfont.ttf deleted file mode 100644 index f221e50a2ef60738ba30932d834530cdfe55cb3e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 152796 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

                                                                  =v_rA!CPE#mM^4@)}X7qf;At+v)G*FZd&; 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 ALjV8( diff --git a/docs/gitbook/fonts/fontawesome/fontawesome-webfont.woff b/docs/gitbook/fonts/fontawesome/fontawesome-webfont.woff deleted file mode 100644 index 6e7483cf61b490c08ed644d6ef802c69472eb247..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 90412 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%0Ded40&XED0GYFoIh+AV*?9!MR5pBW?X_8Bp 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 IH>08b4`|GD*#H0l diff --git a/docs/gitbook/fonts/fontawesome/fontawesome-webfont.woff2 b/docs/gitbook/fonts/fontawesome/fontawesome-webfont.woff2 deleted file mode 100644 index 7eb74fd127ee5eddf3b95fee6a20dc1684b0963b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 71896 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≠dR0E9ICQ{-tcR;@{R^I5P#1GUH!p=-{c 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 diff --git a/docs/gitbook/gitbook-plugin-fontsettings/fontsettings.js b/docs/gitbook/gitbook-plugin-fontsettings/fontsettings.js deleted file mode 100644 index ff7be71..0000000 --- a/docs/gitbook/gitbook-plugin-fontsettings/fontsettings.js +++ /dev/null @@ -1,240 +0,0 @@ -require(['gitbook', 'jquery'], function(gitbook, $) { - // Configuration - var MAX_SIZE = 4, - MIN_SIZE = 0, - BUTTON_ID; - - // Current fontsettings state - var fontState; - - // Default themes - var THEMES = [ - { - config: 'white', - text: 'White', - id: 0 - }, - { - config: 'sepia', - text: 'Sepia', - id: 1 - }, - { - config: 'night', - text: 'Night', - id: 2 - } - ]; - - // Default font families - var FAMILIES = [ - { - config: 'serif', - text: 'Serif', - id: 0 - }, - { - config: 'sans', - text: 'Sans', - id: 1 - } - ]; - - // Return configured themes - function getThemes() { - return THEMES; - } - - // Modify configured themes - function setThemes(themes) { - THEMES = themes; - updateButtons(); - } - - // Return configured font families - function getFamilies() { - return FAMILIES; - } - - // Modify configured font families - function setFamilies(families) { - FAMILIES = families; - updateButtons(); - } - - // Save current font settings - function saveFontSettings() { - gitbook.storage.set('fontState', fontState); - update(); - } - - // Increase font size - function enlargeFontSize(e) { - e.preventDefault(); - if (fontState.size >= MAX_SIZE) return; - - fontState.size++; - saveFontSettings(); - } - - // Decrease font size - function reduceFontSize(e) { - e.preventDefault(); - if (fontState.size <= MIN_SIZE) return; - - fontState.size--; - saveFontSettings(); - } - - // Change font family - function changeFontFamily(configName, e) { - if (e && e instanceof Event) { - e.preventDefault(); - } - - var familyId = getFontFamilyId(configName); - fontState.family = familyId; - saveFontSettings(); - } - - // Change type of color theme - function changeColorTheme(configName, e) { - if (e && e instanceof Event) { - e.preventDefault(); - } - - var $book = gitbook.state.$book; - - // Remove currently applied color theme - if (fontState.theme !== 0) - $book.removeClass('color-theme-'+fontState.theme); - - // Set new color theme - var themeId = getThemeId(configName); - fontState.theme = themeId; - if (fontState.theme !== 0) - $book.addClass('color-theme-'+fontState.theme); - - saveFontSettings(); - } - - // Return the correct id for a font-family config key - // Default to first font-family - function getFontFamilyId(configName) { - // Search for plugin configured font family - var configFamily = $.grep(FAMILIES, function(family) { - return family.config == configName; - })[0]; - // Fallback to default font family - return (!!configFamily)? configFamily.id : 0; - } - - // Return the correct id for a theme config key - // Default to first theme - function getThemeId(configName) { - // Search for plugin configured theme - var configTheme = $.grep(THEMES, function(theme) { - return theme.config == configName; - })[0]; - // Fallback to default theme - return (!!configTheme)? configTheme.id : 0; - } - - function update() { - var $book = gitbook.state.$book; - - $('.font-settings .font-family-list li').removeClass('active'); - $('.font-settings .font-family-list li:nth-child('+(fontState.family+1)+')').addClass('active'); - - $book[0].className = $book[0].className.replace(/\bfont-\S+/g, ''); - $book.addClass('font-size-'+fontState.size); - $book.addClass('font-family-'+fontState.family); - - if(fontState.theme !== 0) { - $book[0].className = $book[0].className.replace(/\bcolor-theme-\S+/g, ''); - $book.addClass('color-theme-'+fontState.theme); - } - } - - function init(config) { - // Search for plugin configured font family - var configFamily = getFontFamilyId(config.family), - configTheme = getThemeId(config.theme); - - // Instantiate font state object - fontState = gitbook.storage.get('fontState', { - size: config.size || 2, - family: configFamily, - theme: configTheme - }); - - update(); - } - - function updateButtons() { - // Remove existing fontsettings buttons - if (!!BUTTON_ID) { - gitbook.toolbar.removeButton(BUTTON_ID); - } - - // Create buttons in toolbar - BUTTON_ID = gitbook.toolbar.createButton({ - icon: 'fa fa-font', - label: 'Font Settings', - className: 'font-settings', - dropdown: [ - [ - { - text: 'A', - className: 'font-reduce', - onClick: reduceFontSize - }, - { - text: 'A', - className: 'font-enlarge', - onClick: enlargeFontSize - } - ], - $.map(FAMILIES, function(family) { - family.onClick = function(e) { - return changeFontFamily(family.config, e); - }; - - return family; - }), - $.map(THEMES, function(theme) { - theme.onClick = function(e) { - return changeColorTheme(theme.config, e); - }; - - return theme; - }) - ] - }); - } - - // Init configuration at start - gitbook.events.bind('start', function(e, config) { - var opts = config.fontsettings; - - // Generate buttons at start - updateButtons(); - - // Init current settings - init(opts); - }); - - // Expose API - gitbook.fontsettings = { - enlargeFontSize: enlargeFontSize, - reduceFontSize: reduceFontSize, - setTheme: changeColorTheme, - setFamily: changeFontFamily, - getThemes: getThemes, - setThemes: setThemes, - getFamilies: getFamilies, - setFamilies: setFamilies - }; -}); - - diff --git a/docs/gitbook/gitbook-plugin-fontsettings/website.css b/docs/gitbook/gitbook-plugin-fontsettings/website.css deleted file mode 100644 index 26591fe..0000000 --- a/docs/gitbook/gitbook-plugin-fontsettings/website.css +++ /dev/null @@ -1,291 +0,0 @@ -/* - * Theme 1 - */ -.color-theme-1 .dropdown-menu { - background-color: #111111; - border-color: #7e888b; -} -.color-theme-1 .dropdown-menu .dropdown-caret .caret-inner { - border-bottom: 9px solid #111111; -} -.color-theme-1 .dropdown-menu .buttons { - border-color: #7e888b; -} -.color-theme-1 .dropdown-menu .button { - color: #afa790; -} -.color-theme-1 .dropdown-menu .button:hover { - color: #73553c; -} -/* - * Theme 2 - */ -.color-theme-2 .dropdown-menu { - background-color: #2d3143; - border-color: #272a3a; -} -.color-theme-2 .dropdown-menu .dropdown-caret .caret-inner { - border-bottom: 9px solid #2d3143; -} -.color-theme-2 .dropdown-menu .buttons { - border-color: #272a3a; -} -.color-theme-2 .dropdown-menu .button { - color: #62677f; -} -.color-theme-2 .dropdown-menu .button:hover { - color: #f4f4f5; -} -.book .book-header .font-settings .font-enlarge { - line-height: 30px; - font-size: 1.4em; -} -.book .book-header .font-settings .font-reduce { - line-height: 30px; - font-size: 1em; -} -.book.color-theme-1 .book-body { - color: #704214; - background: #f3eacb; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section { - background: #f3eacb; -} -.book.color-theme-2 .book-body { - color: #bdcadb; - background: #1c1f2b; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section { - background: #1c1f2b; -} -.book.font-size-0 .book-body .page-inner section { - font-size: 1.2rem; -} -.book.font-size-1 .book-body .page-inner section { - font-size: 1.4rem; -} -.book.font-size-2 .book-body .page-inner section { - font-size: 1.6rem; -} -.book.font-size-3 .book-body .page-inner section { - font-size: 2.2rem; -} -.book.font-size-4 .book-body .page-inner section { - font-size: 4rem; -} -.book.font-family-0 { - font-family: Georgia, serif; -} -.book.font-family-1 { - font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal { - color: #704214; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal a { - color: inherit; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h1, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h2, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h3, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h4, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h5, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h6 { - color: inherit; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h1, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h2 { - border-color: inherit; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h6 { - color: inherit; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal hr { - background-color: inherit; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal blockquote { - border-color: inherit; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code { - background: #fdf6e3; - color: #657b83; - border-color: #f8df9c; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal .highlight { - background-color: inherit; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table th, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table td { - border-color: #f5d06c; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table tr { - color: inherit; - background-color: #fdf6e3; - border-color: #444444; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table tr:nth-child(2n) { - background-color: #fbeecb; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal { - color: #bdcadb; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal a { - color: #3eb1d0; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h1, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h2, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h3, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h4, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h5, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h6 { - color: #fffffa; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h1, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h2 { - border-color: #373b4e; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h6 { - color: #373b4e; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal hr { - background-color: #373b4e; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal blockquote { - border-color: #373b4e; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code { - color: #9dbed8; - background: #2d3143; - border-color: #2d3143; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal .highlight { - background-color: #282a39; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table th, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table td { - border-color: #3b3f54; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table tr { - color: #b6c2d2; - background-color: #2d3143; - border-color: #3b3f54; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table tr:nth-child(2n) { - background-color: #35394b; -} -.book.color-theme-1 .book-header { - color: #afa790; - background: transparent; -} -.book.color-theme-1 .book-header .btn { - color: #afa790; -} -.book.color-theme-1 .book-header .btn:hover { - color: #73553c; - background: none; -} -.book.color-theme-1 .book-header h1 { - color: #704214; -} -.book.color-theme-2 .book-header { - color: #7e888b; - background: transparent; -} -.book.color-theme-2 .book-header .btn { - color: #3b3f54; -} -.book.color-theme-2 .book-header .btn:hover { - color: #fffff5; - background: none; -} -.book.color-theme-2 .book-header h1 { - color: #bdcadb; -} -.book.color-theme-1 .book-body .navigation { - color: #afa790; -} -.book.color-theme-1 .book-body .navigation:hover { - color: #73553c; -} -.book.color-theme-2 .book-body .navigation { - color: #383f52; -} -.book.color-theme-2 .book-body .navigation:hover { - color: #fffff5; -} -/* - * Theme 1 - */ -.book.color-theme-1 .book-summary { - color: #afa790; - background: #111111; - border-right: 1px solid rgba(0, 0, 0, 0.07); -} -.book.color-theme-1 .book-summary .book-search { - background: transparent; -} -.book.color-theme-1 .book-summary .book-search input, -.book.color-theme-1 .book-summary .book-search input:focus { - border: 1px solid transparent; -} -.book.color-theme-1 .book-summary ul.summary li.divider { - background: #7e888b; - box-shadow: none; -} -.book.color-theme-1 .book-summary ul.summary li i.fa-check { - color: #33cc33; -} -.book.color-theme-1 .book-summary ul.summary li.done > a { - color: #877f6a; -} -.book.color-theme-1 .book-summary ul.summary li a, -.book.color-theme-1 .book-summary ul.summary li span { - color: #877f6a; - background: transparent; - font-weight: normal; -} -.book.color-theme-1 .book-summary ul.summary li.active > a, -.book.color-theme-1 .book-summary ul.summary li a:hover { - color: #704214; - background: transparent; - font-weight: normal; -} -/* - * Theme 2 - */ -.book.color-theme-2 .book-summary { - color: #bcc1d2; - background: #2d3143; - border-right: none; -} -.book.color-theme-2 .book-summary .book-search { - background: transparent; -} -.book.color-theme-2 .book-summary .book-search input, -.book.color-theme-2 .book-summary .book-search input:focus { - border: 1px solid transparent; -} -.book.color-theme-2 .book-summary ul.summary li.divider { - background: #272a3a; - box-shadow: none; -} -.book.color-theme-2 .book-summary ul.summary li i.fa-check { - color: #33cc33; -} -.book.color-theme-2 .book-summary ul.summary li.done > a { - color: #62687f; -} -.book.color-theme-2 .book-summary ul.summary li a, -.book.color-theme-2 .book-summary ul.summary li span { - color: #c1c6d7; - background: transparent; - font-weight: 600; -} -.book.color-theme-2 .book-summary ul.summary li.active > a, -.book.color-theme-2 .book-summary ul.summary li a:hover { - color: #f4f4f5; - background: #252737; - font-weight: 600; -} diff --git a/docs/gitbook/gitbook-plugin-highlight/ebook.css b/docs/gitbook/gitbook-plugin-highlight/ebook.css deleted file mode 100644 index cecaaab..0000000 --- a/docs/gitbook/gitbook-plugin-highlight/ebook.css +++ /dev/null @@ -1,135 +0,0 @@ -pre, -code { - /* http://jmblog.github.io/color-themes-for-highlightjs */ - /* Tomorrow Comment */ - /* Tomorrow Red */ - /* Tomorrow Orange */ - /* Tomorrow Yellow */ - /* Tomorrow Green */ - /* Tomorrow Aqua */ - /* Tomorrow Blue */ - /* Tomorrow Purple */ -} -pre .hljs-comment, -code .hljs-comment, -pre .hljs-title, -code .hljs-title { - color: #8e908c; -} -pre .hljs-variable, -code .hljs-variable, -pre .hljs-attribute, -code .hljs-attribute, -pre .hljs-tag, -code .hljs-tag, -pre .hljs-regexp, -code .hljs-regexp, -pre .hljs-deletion, -code .hljs-deletion, -pre .ruby .hljs-constant, -code .ruby .hljs-constant, -pre .xml .hljs-tag .hljs-title, -code .xml .hljs-tag .hljs-title, -pre .xml .hljs-pi, -code .xml .hljs-pi, -pre .xml .hljs-doctype, -code .xml .hljs-doctype, -pre .html .hljs-doctype, -code .html .hljs-doctype, -pre .css .hljs-id, -code .css .hljs-id, -pre .css .hljs-class, -code .css .hljs-class, -pre .css .hljs-pseudo, -code .css .hljs-pseudo { - color: #c82829; -} -pre .hljs-number, -code .hljs-number, -pre .hljs-preprocessor, -code .hljs-preprocessor, -pre .hljs-pragma, -code .hljs-pragma, -pre .hljs-built_in, -code .hljs-built_in, -pre .hljs-literal, -code .hljs-literal, -pre .hljs-params, -code .hljs-params, -pre .hljs-constant, -code .hljs-constant { - color: #f5871f; -} -pre .ruby .hljs-class .hljs-title, -code .ruby .hljs-class .hljs-title, -pre .css .hljs-rules .hljs-attribute, -code .css .hljs-rules .hljs-attribute { - color: #eab700; -} -pre .hljs-string, -code .hljs-string, -pre .hljs-value, -code .hljs-value, -pre .hljs-inheritance, -code .hljs-inheritance, -pre .hljs-header, -code .hljs-header, -pre .hljs-addition, -code .hljs-addition, -pre .ruby .hljs-symbol, -code .ruby .hljs-symbol, -pre .xml .hljs-cdata, -code .xml .hljs-cdata { - color: #718c00; -} -pre .css .hljs-hexcolor, -code .css .hljs-hexcolor { - color: #3e999f; -} -pre .hljs-function, -code .hljs-function, -pre .python .hljs-decorator, -code .python .hljs-decorator, -pre .python .hljs-title, -code .python .hljs-title, -pre .ruby .hljs-function .hljs-title, -code .ruby .hljs-function .hljs-title, -pre .ruby .hljs-title .hljs-keyword, -code .ruby .hljs-title .hljs-keyword, -pre .perl .hljs-sub, -code .perl .hljs-sub, -pre .javascript .hljs-title, -code .javascript .hljs-title, -pre .coffeescript .hljs-title, -code .coffeescript .hljs-title { - color: #4271ae; -} -pre .hljs-keyword, -code .hljs-keyword, -pre .javascript .hljs-function, -code .javascript .hljs-function { - color: #8959a8; -} -pre .hljs, -code .hljs { - display: block; - background: white; - color: #4d4d4c; - padding: 0.5em; -} -pre .coffeescript .javascript, -code .coffeescript .javascript, -pre .javascript .xml, -code .javascript .xml, -pre .tex .hljs-formula, -code .tex .hljs-formula, -pre .xml .javascript, -code .xml .javascript, -pre .xml .vbscript, -code .xml .vbscript, -pre .xml .css, -code .xml .css, -pre .xml .hljs-cdata, -code .xml .hljs-cdata { - opacity: 0.5; -} diff --git a/docs/gitbook/gitbook-plugin-highlight/website.css b/docs/gitbook/gitbook-plugin-highlight/website.css deleted file mode 100644 index 6674448..0000000 --- a/docs/gitbook/gitbook-plugin-highlight/website.css +++ /dev/null @@ -1,434 +0,0 @@ -.book .book-body .page-wrapper .page-inner section.normal pre, -.book .book-body .page-wrapper .page-inner section.normal code { - /* http://jmblog.github.com/color-themes-for-google-code-highlightjs */ - /* Tomorrow Comment */ - /* Tomorrow Red */ - /* Tomorrow Orange */ - /* Tomorrow Yellow */ - /* Tomorrow Green */ - /* Tomorrow Aqua */ - /* Tomorrow Blue */ - /* Tomorrow Purple */ -} -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-comment, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-comment, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-title { - color: #8e908c; -} -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-variable, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-variable, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-attribute, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-attribute, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-tag, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-tag, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-regexp, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-regexp, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-deletion, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-deletion, -.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-constant, -.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-constant, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-tag .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-tag .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-pi, -.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-pi, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-doctype, -.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-doctype, -.book .book-body .page-wrapper .page-inner section.normal pre .html .hljs-doctype, -.book .book-body .page-wrapper .page-inner section.normal code .html .hljs-doctype, -.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-id, -.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-id, -.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-class, -.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-class, -.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-pseudo, -.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-pseudo { - color: #c82829; -} -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-number, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-number, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-pragma, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-pragma, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-built_in, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-built_in, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-literal, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-literal, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-params, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-params, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-constant, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-constant { - color: #f5871f; -} -.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-class .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-class .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-rules .hljs-attribute, -.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-rules .hljs-attribute { - color: #eab700; -} -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-string, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-string, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-value, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-value, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-inheritance, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-inheritance, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-header, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-header, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-addition, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-addition, -.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-symbol, -.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-symbol, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, -.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { - color: #718c00; -} -.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-hexcolor, -.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-hexcolor { - color: #3e999f; -} -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-function, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-function, -.book .book-body .page-wrapper .page-inner section.normal pre .python .hljs-decorator, -.book .book-body .page-wrapper .page-inner section.normal code .python .hljs-decorator, -.book .book-body .page-wrapper .page-inner section.normal pre .python .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal code .python .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-function .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-function .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-title .hljs-keyword, -.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-title .hljs-keyword, -.book .book-body .page-wrapper .page-inner section.normal pre .perl .hljs-sub, -.book .book-body .page-wrapper .page-inner section.normal code .perl .hljs-sub, -.book .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal pre .coffeescript .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal code .coffeescript .hljs-title { - color: #4271ae; -} -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-keyword, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-keyword, -.book .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-function, -.book .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-function { - color: #8959a8; -} -.book .book-body .page-wrapper .page-inner section.normal pre .hljs, -.book .book-body .page-wrapper .page-inner section.normal code .hljs { - display: block; - background: white; - color: #4d4d4c; - padding: 0.5em; -} -.book .book-body .page-wrapper .page-inner section.normal pre .coffeescript .javascript, -.book .book-body .page-wrapper .page-inner section.normal code .coffeescript .javascript, -.book .book-body .page-wrapper .page-inner section.normal pre .javascript .xml, -.book .book-body .page-wrapper .page-inner section.normal code .javascript .xml, -.book .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, -.book .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .javascript, -.book .book-body .page-wrapper .page-inner section.normal code .xml .javascript, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .vbscript, -.book .book-body .page-wrapper .page-inner section.normal code .xml .vbscript, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .css, -.book .book-body .page-wrapper .page-inner section.normal code .xml .css, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, -.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { - opacity: 0.5; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code { - /* - -Orginal Style from ethanschoonover.com/solarized (c) Jeremy Hull - -*/ - /* Solarized Green */ - /* Solarized Cyan */ - /* Solarized Blue */ - /* Solarized Yellow */ - /* Solarized Orange */ - /* Solarized Red */ - /* Solarized Violet */ -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs { - display: block; - padding: 0.5em; - background: #fdf6e3; - color: #657b83; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-comment, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-comment, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-template_comment, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-template_comment, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .diff .hljs-header, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .diff .hljs-header, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-doctype, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-doctype, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-pi, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-pi, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .lisp .hljs-string, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .lisp .hljs-string, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-javadoc, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-javadoc { - color: #93a1a1; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-keyword, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-keyword, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-winutils, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-winutils, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .method, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .method, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-addition, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-addition, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-tag, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .css .hljs-tag, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-request, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-request, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-status, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-status, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .nginx .hljs-title, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .nginx .hljs-title { - color: #859900; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-number, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-number, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-command, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-command, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-string, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-string, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-tag .hljs-value, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-tag .hljs-value, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-rules .hljs-value, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-rules .hljs-value, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-phpdoc, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-phpdoc, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-regexp, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-regexp, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-hexcolor, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-hexcolor, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-link_url, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-link_url { - color: #2aa198; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-title, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-title, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-localvars, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-localvars, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-chunk, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-chunk, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-decorator, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-decorator, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-built_in, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-built_in, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-identifier, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-identifier, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .vhdl .hljs-literal, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .vhdl .hljs-literal, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-id, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-id, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-function, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .css .hljs-function { - color: #268bd2; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-attribute, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-attribute, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-variable, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-variable, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .lisp .hljs-body, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .lisp .hljs-body, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .smalltalk .hljs-number, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .smalltalk .hljs-number, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-constant, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-constant, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-class .hljs-title, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-class .hljs-title, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-parent, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-parent, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .haskell .hljs-type, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .haskell .hljs-type, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-link_reference, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-link_reference { - color: #b58900; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor .hljs-keyword, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor .hljs-keyword, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-pragma, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-pragma, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-shebang, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-shebang, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-symbol, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-symbol, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-symbol .hljs-string, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-symbol .hljs-string, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .diff .hljs-change, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .diff .hljs-change, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-special, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-special, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-attr_selector, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-attr_selector, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-subst, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-subst, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-cdata, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-cdata, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .clojure .hljs-title, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .clojure .hljs-title, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-pseudo, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .css .hljs-pseudo, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-header, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-header { - color: #cb4b16; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-deletion, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-deletion, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-important, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-important { - color: #dc322f; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-link_label, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-link_label { - color: #6c71c4; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula { - background: #eee8d5; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code { - /* Tomorrow Night Bright Theme */ - /* Original theme - https://github.com/chriskempson/tomorrow-theme */ - /* http://jmblog.github.com/color-themes-for-google-code-highlightjs */ - /* Tomorrow Comment */ - /* Tomorrow Red */ - /* Tomorrow Orange */ - /* Tomorrow Yellow */ - /* Tomorrow Green */ - /* Tomorrow Aqua */ - /* Tomorrow Blue */ - /* Tomorrow Purple */ -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-comment, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-comment, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-title { - color: #969896; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-variable, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-variable, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-attribute, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-attribute, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-tag, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-tag, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-regexp, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-regexp, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-deletion, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-deletion, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-constant, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-constant, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-tag .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-tag .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-pi, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-pi, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-doctype, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-doctype, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .html .hljs-doctype, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .html .hljs-doctype, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-id, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-id, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-class, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-class, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-pseudo, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-pseudo { - color: #d54e53; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-number, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-number, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-pragma, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-pragma, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-built_in, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-built_in, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-literal, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-literal, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-params, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-params, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-constant, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-constant { - color: #e78c45; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-class .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-class .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-rules .hljs-attribute, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-rules .hljs-attribute { - color: #e7c547; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-string, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-string, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-value, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-value, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-inheritance, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-inheritance, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-header, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-header, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-addition, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-addition, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-symbol, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-symbol, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { - color: #b9ca4a; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-hexcolor, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-hexcolor { - color: #70c0b1; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-function, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-function, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .python .hljs-decorator, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .python .hljs-decorator, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .python .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .python .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-function .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-function .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-title .hljs-keyword, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-title .hljs-keyword, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .perl .hljs-sub, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .perl .hljs-sub, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .coffeescript .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .coffeescript .hljs-title { - color: #7aa6da; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-keyword, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-keyword, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-function, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-function { - color: #c397d8; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs { - display: block; - background: black; - color: #eaeaea; - padding: 0.5em; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .coffeescript .javascript, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .coffeescript .javascript, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .javascript .xml, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .javascript .xml, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .javascript, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .javascript, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .vbscript, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .vbscript, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .css, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .css, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { - opacity: 0.5; -} diff --git a/docs/gitbook/gitbook-plugin-lunr/lunr.min.js b/docs/gitbook/gitbook-plugin-lunr/lunr.min.js deleted file mode 100644 index 6aa6bc7..0000000 --- a/docs/gitbook/gitbook-plugin-lunr/lunr.min.js +++ /dev/null @@ -1,7 +0,0 @@ -/** - * lunr - http://lunrjs.com - A bit like Solr, but much smaller and not as bright - 0.5.12 - * Copyright (C) 2015 Oliver Nightingale - * MIT Licensed - * @license - */ -!function(){var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.5.12",t.utils={},t.utils.warn=function(t){return function(e){t.console&&console.warn&&console.warn(e)}}(this),t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var t=Array.prototype.slice.call(arguments),e=t.pop(),n=t;if("function"!=typeof e)throw new TypeError("last argument must be a function");n.forEach(function(t){this.hasHandler(t)||(this.events[t]=[]),this.events[t].push(e)},this)},t.EventEmitter.prototype.removeListener=function(t,e){if(this.hasHandler(t)){var n=this.events[t].indexOf(e);this.events[t].splice(n,1),this.events[t].length||delete this.events[t]}},t.EventEmitter.prototype.emit=function(t){if(this.hasHandler(t)){var e=Array.prototype.slice.call(arguments,1);this.events[t].forEach(function(t){t.apply(void 0,e)})}},t.EventEmitter.prototype.hasHandler=function(t){return t in this.events},t.tokenizer=function(t){return arguments.length&&null!=t&&void 0!=t?Array.isArray(t)?t.map(function(t){return t.toLowerCase()}):t.toString().trim().toLowerCase().split(/[\s\-]+/):[]},t.Pipeline=function(){this._stack=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in this.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[e.label]=e},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.registeredFunctions[e];if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._stack.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._stack.indexOf(e);if(-1==i)throw new Error("Cannot find existingFn");i+=1,this._stack.splice(i,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._stack.indexOf(e);if(-1==i)throw new Error("Cannot find existingFn");this._stack.splice(i,0,n)},t.Pipeline.prototype.remove=function(t){var e=this._stack.indexOf(t);-1!=e&&this._stack.splice(e,1)},t.Pipeline.prototype.run=function(t){for(var e=[],n=t.length,i=this._stack.length,o=0;n>o;o++){for(var r=t[o],s=0;i>s&&(r=this._stack[s](r,o,t),void 0!==r);s++);void 0!==r&&e.push(r)}return e},t.Pipeline.prototype.reset=function(){this._stack=[]},t.Pipeline.prototype.toJSON=function(){return this._stack.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Vector=function(){this._magnitude=null,this.list=void 0,this.length=0},t.Vector.Node=function(t,e,n){this.idx=t,this.val=e,this.next=n},t.Vector.prototype.insert=function(e,n){this._magnitude=void 0;var i=this.list;if(!i)return this.list=new t.Vector.Node(e,n,i),this.length++;if(en.idx?n=n.next:(i+=e.val*n.val,e=e.next,n=n.next);return i},t.Vector.prototype.similarity=function(t){return this.dot(t)/(this.magnitude()*t.magnitude())},t.SortedSet=function(){this.length=0,this.elements=[]},t.SortedSet.load=function(t){var e=new this;return e.elements=t,e.length=t.length,e},t.SortedSet.prototype.add=function(){var t,e;for(t=0;t1;){if(r===t)return o;t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o]}return r===t?o:-1},t.SortedSet.prototype.locationFor=function(t){for(var e=0,n=this.elements.length,i=n-e,o=e+Math.floor(i/2),r=this.elements[o];i>1;)t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o];return r>t?o:t>r?o+1:void 0},t.SortedSet.prototype.intersect=function(e){for(var n=new t.SortedSet,i=0,o=0,r=this.length,s=e.length,a=this.elements,h=e.elements;;){if(i>r-1||o>s-1)break;a[i]!==h[o]?a[i]h[o]&&o++:(n.add(a[i]),i++,o++)}return n},t.SortedSet.prototype.clone=function(){var e=new t.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},t.SortedSet.prototype.union=function(t){var e,n,i;return this.length>=t.length?(e=this,n=t):(e=t,n=this),i=e.clone(),i.add.apply(i,n.toArray()),i},t.SortedSet.prototype.toJSON=function(){return this.toArray()},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.Store,this.tokenStore=new t.TokenStore,this.corpusTokens=new t.SortedSet,this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var t=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,t)},t.Index.prototype.off=function(t,e){return this.eventEmitter.removeListener(t,e)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;return n._fields=e.fields,n._ref=e.ref,n.documentStore=t.Store.load(e.documentStore),n.tokenStore=t.TokenStore.load(e.tokenStore),n.corpusTokens=t.SortedSet.load(e.corpusTokens),n.pipeline=t.Pipeline.load(e.pipeline),n},t.Index.prototype.field=function(t,e){var e=e||{},n={name:t,boost:e.boost||1};return this._fields.push(n),this},t.Index.prototype.ref=function(t){return this._ref=t,this},t.Index.prototype.add=function(e,n){var i={},o=new t.SortedSet,r=e[this._ref],n=void 0===n?!0:n;this._fields.forEach(function(n){var r=this.pipeline.run(t.tokenizer(e[n.name]));i[n.name]=r,t.SortedSet.prototype.add.apply(o,r)},this),this.documentStore.set(r,o),t.SortedSet.prototype.add.apply(this.corpusTokens,o.toArray());for(var s=0;s0&&(i=1+Math.log(this.documentStore.length/n)),this._idfCache[e]=i},t.Index.prototype.search=function(e){var n=this.pipeline.run(t.tokenizer(e)),i=new t.Vector,o=[],r=this._fields.reduce(function(t,e){return t+e.boost},0),s=n.some(function(t){return this.tokenStore.has(t)},this);if(!s)return[];n.forEach(function(e,n,s){var a=1/s.length*this._fields.length*r,h=this,l=this.tokenStore.expand(e).reduce(function(n,o){var r=h.corpusTokens.indexOf(o),s=h.idf(o),l=1,u=new t.SortedSet;if(o!==e){var c=Math.max(3,o.length-e.length);l=1/Math.log(c)}return r>-1&&i.insert(r,a*s*l),Object.keys(h.tokenStore.get(o)).forEach(function(t){u.add(t)}),n.union(u)},new t.SortedSet);o.push(l)},this);var a=o.reduce(function(t,e){return t.intersect(e)});return a.map(function(t){return{ref:t,score:i.similarity(this.documentVector(t))}},this).sort(function(t,e){return e.score-t.score})},t.Index.prototype.documentVector=function(e){for(var n=this.documentStore.get(e),i=n.length,o=new t.Vector,r=0;i>r;r++){var s=n.elements[r],a=this.tokenStore.get(s)[e].tf,h=this.idf(s);o.insert(this.corpusTokens.indexOf(s),a*h)}return o},t.Index.prototype.toJSON=function(){return{version:t.version,fields:this._fields,ref:this._ref,documentStore:this.documentStore.toJSON(),tokenStore:this.tokenStore.toJSON(),corpusTokens:this.corpusTokens.toJSON(),pipeline:this.pipeline.toJSON()}},t.Index.prototype.use=function(t){var e=Array.prototype.slice.call(arguments,1);e.unshift(this),t.apply(this,e)},t.Store=function(){this.store={},this.length=0},t.Store.load=function(e){var n=new this;return n.length=e.length,n.store=Object.keys(e.store).reduce(function(n,i){return n[i]=t.SortedSet.load(e.store[i]),n},{}),n},t.Store.prototype.set=function(t,e){this.has(t)||this.length++,this.store[t]=e},t.Store.prototype.get=function(t){return this.store[t]},t.Store.prototype.has=function(t){return t in this.store},t.Store.prototype.remove=function(t){this.has(t)&&(delete this.store[t],this.length--)},t.Store.prototype.toJSON=function(){return{store:this.store,length:this.length}},t.stemmer=function(){var t={ational:"ate",tional:"tion",enci:"ence",anci:"ance",izer:"ize",bli:"ble",alli:"al",entli:"ent",eli:"e",ousli:"ous",ization:"ize",ation:"ate",ator:"ate",alism:"al",iveness:"ive",fulness:"ful",ousness:"ous",aliti:"al",iviti:"ive",biliti:"ble",logi:"log"},e={icate:"ic",ative:"",alize:"al",iciti:"ic",ical:"ic",ful:"",ness:""},n="[^aeiou]",i="[aeiouy]",o=n+"[^aeiouy]*",r=i+"[aeiou]*",s="^("+o+")?"+r+o,a="^("+o+")?"+r+o+"("+r+")?$",h="^("+o+")?"+r+o+r+o,l="^("+o+")?"+i,u=new RegExp(s),c=new RegExp(h),f=new RegExp(a),d=new RegExp(l),p=/^(.+?)(ss|i)es$/,m=/^(.+?)([^s])s$/,v=/^(.+?)eed$/,y=/^(.+?)(ed|ing)$/,g=/.$/,S=/(at|bl|iz)$/,w=new RegExp("([^aeiouylsz])\\1$"),x=new RegExp("^"+o+i+"[^aeiouwxy]$"),k=/^(.+?[^aeiou])y$/,b=/^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/,E=/^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/,_=/^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/,F=/^(.+?)(s|t)(ion)$/,O=/^(.+?)e$/,P=/ll$/,N=new RegExp("^"+o+i+"[^aeiouwxy]$"),T=function(n){var i,o,r,s,a,h,l;if(n.length<3)return n;if(r=n.substr(0,1),"y"==r&&(n=r.toUpperCase()+n.substr(1)),s=p,a=m,s.test(n)?n=n.replace(s,"$1$2"):a.test(n)&&(n=n.replace(a,"$1$2")),s=v,a=y,s.test(n)){var T=s.exec(n);s=u,s.test(T[1])&&(s=g,n=n.replace(s,""))}else if(a.test(n)){var T=a.exec(n);i=T[1],a=d,a.test(i)&&(n=i,a=S,h=w,l=x,a.test(n)?n+="e":h.test(n)?(s=g,n=n.replace(s,"")):l.test(n)&&(n+="e"))}if(s=k,s.test(n)){var T=s.exec(n);i=T[1],n=i+"i"}if(s=b,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+t[o])}if(s=E,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+e[o])}if(s=_,a=F,s.test(n)){var T=s.exec(n);i=T[1],s=c,s.test(i)&&(n=i)}else if(a.test(n)){var T=a.exec(n);i=T[1]+T[2],a=c,a.test(i)&&(n=i)}if(s=O,s.test(n)){var T=s.exec(n);i=T[1],s=c,a=f,h=N,(s.test(i)||a.test(i)&&!h.test(i))&&(n=i)}return s=P,a=c,s.test(n)&&a.test(n)&&(s=g,n=n.replace(s,"")),"y"==r&&(n=r.toLowerCase()+n.substr(1)),n};return T}(),t.Pipeline.registerFunction(t.stemmer,"stemmer"),t.stopWordFilter=function(e){return e&&t.stopWordFilter.stopWords[e]!==e?e:void 0},t.stopWordFilter.stopWords={a:"a",able:"able",about:"about",across:"across",after:"after",all:"all",almost:"almost",also:"also",am:"am",among:"among",an:"an",and:"and",any:"any",are:"are",as:"as",at:"at",be:"be",because:"because",been:"been",but:"but",by:"by",can:"can",cannot:"cannot",could:"could",dear:"dear",did:"did","do":"do",does:"does",either:"either","else":"else",ever:"ever",every:"every","for":"for",from:"from",get:"get",got:"got",had:"had",has:"has",have:"have",he:"he",her:"her",hers:"hers",him:"him",his:"his",how:"how",however:"however",i:"i","if":"if","in":"in",into:"into",is:"is",it:"it",its:"its",just:"just",least:"least",let:"let",like:"like",likely:"likely",may:"may",me:"me",might:"might",most:"most",must:"must",my:"my",neither:"neither",no:"no",nor:"nor",not:"not",of:"of",off:"off",often:"often",on:"on",only:"only",or:"or",other:"other",our:"our",own:"own",rather:"rather",said:"said",say:"say",says:"says",she:"she",should:"should",since:"since",so:"so",some:"some",than:"than",that:"that",the:"the",their:"their",them:"them",then:"then",there:"there",these:"these",they:"they","this":"this",tis:"tis",to:"to",too:"too",twas:"twas",us:"us",wants:"wants",was:"was",we:"we",were:"were",what:"what",when:"when",where:"where",which:"which","while":"while",who:"who",whom:"whom",why:"why",will:"will","with":"with",would:"would",yet:"yet",you:"you",your:"your"},t.Pipeline.registerFunction(t.stopWordFilter,"stopWordFilter"),t.trimmer=function(t){var e=t.replace(/^\W+/,"").replace(/\W+$/,"");return""===e?void 0:e},t.Pipeline.registerFunction(t.trimmer,"trimmer"),t.TokenStore=function(){this.root={docs:{}},this.length=0},t.TokenStore.load=function(t){var e=new this;return e.root=t.root,e.length=t.length,e},t.TokenStore.prototype.add=function(t,e,n){var n=n||this.root,i=t[0],o=t.slice(1);return i in n||(n[i]={docs:{}}),0===o.length?(n[i].docs[e.ref]=e,void(this.length+=1)):this.add(o,e,n[i])},t.TokenStore.prototype.has=function(t){if(!t)return!1;for(var e=this.root,n=0;no;o++){for(var r=t[o],s=0;i>s&&(r=this._stack[s](r,o,t),void 0!==r);s++);void 0!==r&&e.push(r)}return e},t.Pipeline.prototype.reset=function(){this._stack=[]},t.Pipeline.prototype.toJSON=function(){return this._stack.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Vector=function(){this._magnitude=null,this.list=void 0,this.length=0},t.Vector.Node=function(t,e,n){this.idx=t,this.val=e,this.next=n},t.Vector.prototype.insert=function(e,n){this._magnitude=void 0;var i=this.list;if(!i)return this.list=new t.Vector.Node(e,n,i),this.length++;if(en.idx?n=n.next:(i+=e.val*n.val,e=e.next,n=n.next);return i},t.Vector.prototype.similarity=function(t){return this.dot(t)/(this.magnitude()*t.magnitude())},t.SortedSet=function(){this.length=0,this.elements=[]},t.SortedSet.load=function(t){var e=new this;return e.elements=t,e.length=t.length,e},t.SortedSet.prototype.add=function(){var t,e;for(t=0;t1;){if(r===t)return o;t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o]}return r===t?o:-1},t.SortedSet.prototype.locationFor=function(t){for(var e=0,n=this.elements.length,i=n-e,o=e+Math.floor(i/2),r=this.elements[o];i>1;)t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o];return r>t?o:t>r?o+1:void 0},t.SortedSet.prototype.intersect=function(e){for(var n=new t.SortedSet,i=0,o=0,r=this.length,s=e.length,a=this.elements,h=e.elements;;){if(i>r-1||o>s-1)break;a[i]!==h[o]?a[i]h[o]&&o++:(n.add(a[i]),i++,o++)}return n},t.SortedSet.prototype.clone=function(){var e=new t.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},t.SortedSet.prototype.union=function(t){var e,n,i;return this.length>=t.length?(e=this,n=t):(e=t,n=this),i=e.clone(),i.add.apply(i,n.toArray()),i},t.SortedSet.prototype.toJSON=function(){return this.toArray()},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.Store,this.tokenStore=new t.TokenStore,this.corpusTokens=new t.SortedSet,this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var t=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,t)},t.Index.prototype.off=function(t,e){return this.eventEmitter.removeListener(t,e)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;return n._fields=e.fields,n._ref=e.ref,n.documentStore=t.Store.load(e.documentStore),n.tokenStore=t.TokenStore.load(e.tokenStore),n.corpusTokens=t.SortedSet.load(e.corpusTokens),n.pipeline=t.Pipeline.load(e.pipeline),n},t.Index.prototype.field=function(t,e){var e=e||{},n={name:t,boost:e.boost||1};return this._fields.push(n),this},t.Index.prototype.ref=function(t){return this._ref=t,this},t.Index.prototype.add=function(e,n){var i={},o=new t.SortedSet,r=e[this._ref],n=void 0===n?!0:n;this._fields.forEach(function(n){var r=this.pipeline.run(t.tokenizer(e[n.name]));i[n.name]=r,t.SortedSet.prototype.add.apply(o,r)},this),this.documentStore.set(r,o),t.SortedSet.prototype.add.apply(this.corpusTokens,o.toArray());for(var s=0;s0&&(i=1+Math.log(this.documentStore.length/n)),this._idfCache[e]=i},t.Index.prototype.search=function(e){var n=this.pipeline.run(t.tokenizer(e)),i=new t.Vector,o=[],r=this._fields.reduce(function(t,e){return t+e.boost},0),s=n.some(function(t){return this.tokenStore.has(t)},this);if(!s)return[];n.forEach(function(e,n,s){var a=1/s.length*this._fields.length*r,h=this,l=this.tokenStore.expand(e).reduce(function(n,o){var r=h.corpusTokens.indexOf(o),s=h.idf(o),l=1,u=new t.SortedSet;if(o!==e){var c=Math.max(3,o.length-e.length);l=1/Math.log(c)}return r>-1&&i.insert(r,a*s*l),Object.keys(h.tokenStore.get(o)).forEach(function(t){u.add(t)}),n.union(u)},new t.SortedSet);o.push(l)},this);var a=o.reduce(function(t,e){return t.intersect(e)});return a.map(function(t){return{ref:t,score:i.similarity(this.documentVector(t))}},this).sort(function(t,e){return e.score-t.score})},t.Index.prototype.documentVector=function(e){for(var n=this.documentStore.get(e),i=n.length,o=new t.Vector,r=0;i>r;r++){var s=n.elements[r],a=this.tokenStore.get(s)[e].tf,h=this.idf(s);o.insert(this.corpusTokens.indexOf(s),a*h)}return o},t.Index.prototype.toJSON=function(){return{version:t.version,fields:this._fields,ref:this._ref,documentStore:this.documentStore.toJSON(),tokenStore:this.tokenStore.toJSON(),corpusTokens:this.corpusTokens.toJSON(),pipeline:this.pipeline.toJSON()}},t.Index.prototype.use=function(t){var e=Array.prototype.slice.call(arguments,1);e.unshift(this),t.apply(this,e)},t.Store=function(){this.store={},this.length=0},t.Store.load=function(e){var n=new this;return n.length=e.length,n.store=Object.keys(e.store).reduce(function(n,i){return n[i]=t.SortedSet.load(e.store[i]),n},{}),n},t.Store.prototype.set=function(t,e){this.has(t)||this.length++,this.store[t]=e},t.Store.prototype.get=function(t){return this.store[t]},t.Store.prototype.has=function(t){return t in this.store},t.Store.prototype.remove=function(t){this.has(t)&&(delete this.store[t],this.length--)},t.Store.prototype.toJSON=function(){return{store:this.store,length:this.length}},t.stemmer=function(){var t={ational:"ate",tional:"tion",enci:"ence",anci:"ance",izer:"ize",bli:"ble",alli:"al",entli:"ent",eli:"e",ousli:"ous",ization:"ize",ation:"ate",ator:"ate",alism:"al",iveness:"ive",fulness:"ful",ousness:"ous",aliti:"al",iviti:"ive",biliti:"ble",logi:"log"},e={icate:"ic",ative:"",alize:"al",iciti:"ic",ical:"ic",ful:"",ness:""},n="[^aeiou]",i="[aeiouy]",o=n+"[^aeiouy]*",r=i+"[aeiou]*",s="^("+o+")?"+r+o,a="^("+o+")?"+r+o+"("+r+")?$",h="^("+o+")?"+r+o+r+o,l="^("+o+")?"+i,u=new RegExp(s),c=new RegExp(h),f=new RegExp(a),d=new RegExp(l),p=/^(.+?)(ss|i)es$/,m=/^(.+?)([^s])s$/,v=/^(.+?)eed$/,y=/^(.+?)(ed|ing)$/,g=/.$/,S=/(at|bl|iz)$/,w=new RegExp("([^aeiouylsz])\\1$"),x=new RegExp("^"+o+i+"[^aeiouwxy]$"),k=/^(.+?[^aeiou])y$/,b=/^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/,E=/^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/,_=/^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/,F=/^(.+?)(s|t)(ion)$/,O=/^(.+?)e$/,P=/ll$/,N=new RegExp("^"+o+i+"[^aeiouwxy]$"),T=function(n){var i,o,r,s,a,h,l;if(n.length<3)return n;if(r=n.substr(0,1),"y"==r&&(n=r.toUpperCase()+n.substr(1)),s=p,a=m,s.test(n)?n=n.replace(s,"$1$2"):a.test(n)&&(n=n.replace(a,"$1$2")),s=v,a=y,s.test(n)){var T=s.exec(n);s=u,s.test(T[1])&&(s=g,n=n.replace(s,""))}else if(a.test(n)){var T=a.exec(n);i=T[1],a=d,a.test(i)&&(n=i,a=S,h=w,l=x,a.test(n)?n+="e":h.test(n)?(s=g,n=n.replace(s,"")):l.test(n)&&(n+="e"))}if(s=k,s.test(n)){var T=s.exec(n);i=T[1],n=i+"i"}if(s=b,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+t[o])}if(s=E,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+e[o])}if(s=_,a=F,s.test(n)){var T=s.exec(n);i=T[1],s=c,s.test(i)&&(n=i)}else if(a.test(n)){var T=a.exec(n);i=T[1]+T[2],a=c,a.test(i)&&(n=i)}if(s=O,s.test(n)){var T=s.exec(n);i=T[1],s=c,a=f,h=N,(s.test(i)||a.test(i)&&!h.test(i))&&(n=i)}return s=P,a=c,s.test(n)&&a.test(n)&&(s=g,n=n.replace(s,"")),"y"==r&&(n=r.toLowerCase()+n.substr(1)),n};return T}(),t.Pipeline.registerFunction(t.stemmer,"stemmer"),t.stopWordFilter=function(e){return e&&t.stopWordFilter.stopWords[e]!==e?e:void 0},t.stopWordFilter.stopWords={a:"a",able:"able",about:"about",across:"across",after:"after",all:"all",almost:"almost",also:"also",am:"am",among:"among",an:"an",and:"and",any:"any",are:"are",as:"as",at:"at",be:"be",because:"because",been:"been",but:"but",by:"by",can:"can",cannot:"cannot",could:"could",dear:"dear",did:"did","do":"do",does:"does",either:"either","else":"else",ever:"ever",every:"every","for":"for",from:"from",get:"get",got:"got",had:"had",has:"has",have:"have",he:"he",her:"her",hers:"hers",him:"him",his:"his",how:"how",however:"however",i:"i","if":"if","in":"in",into:"into",is:"is",it:"it",its:"its",just:"just",least:"least",let:"let",like:"like",likely:"likely",may:"may",me:"me",might:"might",most:"most",must:"must",my:"my",neither:"neither",no:"no",nor:"nor",not:"not",of:"of",off:"off",often:"often",on:"on",only:"only",or:"or",other:"other",our:"our",own:"own",rather:"rather",said:"said",say:"say",says:"says",she:"she",should:"should",since:"since",so:"so",some:"some",than:"than",that:"that",the:"the",their:"their",them:"them",then:"then",there:"there",these:"these",they:"they","this":"this",tis:"tis",to:"to",too:"too",twas:"twas",us:"us",wants:"wants",was:"was",we:"we",were:"were",what:"what",when:"when",where:"where",which:"which","while":"while",who:"who",whom:"whom",why:"why",will:"will","with":"with",would:"would",yet:"yet",you:"you",your:"your"},t.Pipeline.registerFunction(t.stopWordFilter,"stopWordFilter"),t.trimmer=function(t){var e=t.replace(/^\W+/,"").replace(/\W+$/,"");return""===e?void 0:e},t.Pipeline.registerFunction(t.trimmer,"trimmer"),t.TokenStore=function(){this.root={docs:{}},this.length=0},t.TokenStore.load=function(t){var e=new this;return e.root=t.root,e.length=t.length,e},t.TokenStore.prototype.add=function(t,e,n){var n=n||this.root,i=t[0],o=t.slice(1);return i in n||(n[i]={docs:{}}),0===o.length?(n[i].docs[e.ref]=e,void(this.length+=1)):this.add(o,e,n[i])},t.TokenStore.prototype.has=function(t){if(!t)return!1;for(var e=this.root,n=0;n element for each result - res.results.forEach(function(res) { - var $li = $('

                                                                • ', { - 'class': 'search-results-item' - }); - - var $title = $('

                                                                  '); - - var $link = $('', { - 'href': gitbook.state.basePath + '/' + res.url, - 'text': res.title - }); - - var content = res.body.trim(); - if (content.length > MAX_DESCRIPTION_SIZE) { - content = content.slice(0, MAX_DESCRIPTION_SIZE).trim()+'...'; - } - var $content = $('

                                                                  ').html(content); - - $link.appendTo($title); - $title.appendTo($li); - $content.appendTo($li); - $li.appendTo($searchList); - }); - } - - function launchSearch(q) { - // Add class for loading - $body.addClass('with-search'); - $body.addClass('search-loading'); - - // Launch search query - throttle(gitbook.search.query(q, 0, MAX_RESULTS) - .then(function(results) { - displayResults(results); - }) - .always(function() { - $body.removeClass('search-loading'); - }), 1000); - } - - function closeSearch() { - $body.removeClass('with-search'); - $bookSearchResults.removeClass('open'); - } - - function launchSearchFromQueryString() { - var q = getParameterByName('q'); - if (q && q.length > 0) { - // Update search input - $searchInput.val(q); - - // Launch search - launchSearch(q); - } - } - - function bindSearch() { - // Bind DOM - $searchInput = $('#book-search-input input'); - $bookSearchResults = $('#book-search-results'); - $searchList = $bookSearchResults.find('.search-results-list'); - $searchTitle = $bookSearchResults.find('.search-results-title'); - $searchResultsCount = $searchTitle.find('.search-results-count'); - $searchQuery = $searchTitle.find('.search-query'); - - // Launch query based on input content - function handleUpdate() { - var q = $searchInput.val(); - - if (q.length == 0) { - closeSearch(); - } - else { - launchSearch(q); - } - } - - // Detect true content change in search input - // Workaround for IE < 9 - var propertyChangeUnbound = false; - $searchInput.on('propertychange', function(e) { - if (e.originalEvent.propertyName == 'value') { - handleUpdate(); - } - }); - - // HTML5 (IE9 & others) - $searchInput.on('input', function(e) { - // Unbind propertychange event for IE9+ - if (!propertyChangeUnbound) { - $(this).unbind('propertychange'); - propertyChangeUnbound = true; - } - - handleUpdate(); - }); - - // Push to history on blur - $searchInput.on('blur', function(e) { - // Update history state - if (usePushState) { - var uri = updateQueryString('q', $(this).val()); - history.pushState({ path: uri }, null, uri); - } - }); - } - - gitbook.events.on('page.change', function() { - bindSearch(); - closeSearch(); - - // Launch search based on query parameter - if (gitbook.search.isInitialized()) { - launchSearchFromQueryString(); - } - }); - - gitbook.events.on('search.ready', function() { - bindSearch(); - - // Launch search from query param at start - launchSearchFromQueryString(); - }); - - function getParameterByName(name) { - var url = window.location.href; - name = name.replace(/[\[\]]/g, '\\$&'); - var regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)', 'i'), - results = regex.exec(url); - if (!results) return null; - if (!results[2]) return ''; - return decodeURIComponent(results[2].replace(/\+/g, ' ')); - } - - function updateQueryString(key, value) { - value = encodeURIComponent(value); - - var url = window.location.href; - var re = new RegExp('([?&])' + key + '=.*?(&|#|$)(.*)', 'gi'), - hash; - - if (re.test(url)) { - if (typeof value !== 'undefined' && value !== null) - return url.replace(re, '$1' + key + '=' + value + '$2$3'); - else { - hash = url.split('#'); - url = hash[0].replace(re, '$1$3').replace(/(&|\?)$/, ''); - if (typeof hash[1] !== 'undefined' && hash[1] !== null) - url += '#' + hash[1]; - return url; - } - } - else { - if (typeof value !== 'undefined' && value !== null) { - var separator = url.indexOf('?') !== -1 ? '&' : '?'; - hash = url.split('#'); - url = hash[0] + separator + key + '=' + value; - if (typeof hash[1] !== 'undefined' && hash[1] !== null) - url += '#' + hash[1]; - return url; - } - else - return url; - } - } -}); diff --git a/docs/gitbook/gitbook-plugin-sharing/buttons.js b/docs/gitbook/gitbook-plugin-sharing/buttons.js deleted file mode 100644 index 709a4e4..0000000 --- a/docs/gitbook/gitbook-plugin-sharing/buttons.js +++ /dev/null @@ -1,90 +0,0 @@ -require(['gitbook', 'jquery'], function(gitbook, $) { - var SITES = { - 'facebook': { - 'label': 'Facebook', - 'icon': 'fa fa-facebook', - 'onClick': function(e) { - e.preventDefault(); - window.open('http://www.facebook.com/sharer/sharer.php?s=100&p[url]='+encodeURIComponent(location.href)); - } - }, - 'twitter': { - 'label': 'Twitter', - 'icon': 'fa fa-twitter', - 'onClick': function(e) { - e.preventDefault(); - window.open('http://twitter.com/home?status='+encodeURIComponent(document.title+' '+location.href)); - } - }, - 'google': { - 'label': 'Google+', - 'icon': 'fa fa-google-plus', - 'onClick': function(e) { - e.preventDefault(); - window.open('https://plus.google.com/share?url='+encodeURIComponent(location.href)); - } - }, - 'weibo': { - 'label': 'Weibo', - 'icon': 'fa fa-weibo', - 'onClick': function(e) { - e.preventDefault(); - window.open('http://service.weibo.com/share/share.php?content=utf-8&url='+encodeURIComponent(location.href)+'&title='+encodeURIComponent(document.title)); - } - }, - 'instapaper': { - 'label': 'Instapaper', - 'icon': 'fa fa-instapaper', - 'onClick': function(e) { - e.preventDefault(); - window.open('http://www.instapaper.com/text?u='+encodeURIComponent(location.href)); - } - }, - 'vk': { - 'label': 'VK', - 'icon': 'fa fa-vk', - 'onClick': function(e) { - e.preventDefault(); - window.open('http://vkontakte.ru/share.php?url='+encodeURIComponent(location.href)); - } - } - }; - - - - gitbook.events.bind('start', function(e, config) { - var opts = config.sharing; - - // Create dropdown menu - var menu = $.map(opts.all, function(id) { - var site = SITES[id]; - - return { - text: site.label, - onClick: site.onClick - }; - }); - - // Create main button with dropdown - if (menu.length > 0) { - gitbook.toolbar.createButton({ - icon: 'fa fa-share-alt', - label: 'Share', - position: 'right', - dropdown: [menu] - }); - } - - // Direct actions to share - $.each(SITES, function(sideId, site) { - if (!opts[sideId]) return; - - gitbook.toolbar.createButton({ - icon: site.icon, - label: site.text, - position: 'right', - onClick: site.onClick - }); - }); - }); -}); diff --git a/docs/gitbook/gitbook.js b/docs/gitbook/gitbook.js deleted file mode 100644 index 10000c7..0000000 --- a/docs/gitbook/gitbook.js +++ /dev/null @@ -1,4 +0,0 @@ -!function e(t,n,r){function o(s,a){if(!n[s]){if(!t[s]){var u="function"==typeof require&&require;if(!a&&u)return u(s,!0);if(i)return i(s,!0);var c=new Error("Cannot find module '"+s+"'");throw c.code="MODULE_NOT_FOUND",c}var l=n[s]={exports:{}};t[s][0].call(l.exports,function(e){var n=t[s][1][e];return o(n?n:e)},l,l.exports,e,t,n,r)}return n[s].exports}for(var i="function"==typeof require&&require,s=0;s0&&t-1 in e)}function o(e,t,n){return de.isFunction(t)?de.grep(e,function(e,r){return!!t.call(e,r,e)!==n}):t.nodeType?de.grep(e,function(e){return e===t!==n}):"string"!=typeof t?de.grep(e,function(e){return se.call(t,e)>-1!==n}):je.test(t)?de.filter(t,e,n):(t=de.filter(t,e),de.grep(e,function(e){return se.call(t,e)>-1!==n&&1===e.nodeType}))}function i(e,t){for(;(e=e[t])&&1!==e.nodeType;);return e}function s(e){var t={};return de.each(e.match(qe)||[],function(e,n){t[n]=!0}),t}function a(e){return e}function u(e){throw e}function c(e,t,n){var r;try{e&&de.isFunction(r=e.promise)?r.call(e).done(t).fail(n):e&&de.isFunction(r=e.then)?r.call(e,t,n):t.call(void 0,e)}catch(e){n.call(void 0,e)}}function l(){te.removeEventListener("DOMContentLoaded",l),e.removeEventListener("load",l),de.ready()}function f(){this.expando=de.expando+f.uid++}function p(e){return"true"===e||"false"!==e&&("null"===e?null:e===+e+""?+e:Ie.test(e)?JSON.parse(e):e)}function h(e,t,n){var r;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(Pe,"-$&").toLowerCase(),n=e.getAttribute(r),"string"==typeof n){try{n=p(n)}catch(e){}Re.set(e,t,n)}else n=void 0;return n}function d(e,t,n,r){var o,i=1,s=20,a=r?function(){return r.cur()}:function(){return de.css(e,t,"")},u=a(),c=n&&n[3]||(de.cssNumber[t]?"":"px"),l=(de.cssNumber[t]||"px"!==c&&+u)&&$e.exec(de.css(e,t));if(l&&l[3]!==c){c=c||l[3],n=n||[],l=+u||1;do i=i||".5",l/=i,de.style(e,t,l+c);while(i!==(i=a()/u)&&1!==i&&--s)}return n&&(l=+l||+u||0,o=n[1]?l+(n[1]+1)*n[2]:+n[2],r&&(r.unit=c,r.start=l,r.end=o)),o}function g(e){var t,n=e.ownerDocument,r=e.nodeName,o=Ue[r];return o?o:(t=n.body.appendChild(n.createElement(r)),o=de.css(t,"display"),t.parentNode.removeChild(t),"none"===o&&(o="block"),Ue[r]=o,o)}function m(e,t){for(var n,r,o=[],i=0,s=e.length;i-1)o&&o.push(i);else if(c=de.contains(i.ownerDocument,i),s=v(f.appendChild(i),"script"),c&&y(s),n)for(l=0;i=s[l++];)Ve.test(i.type||"")&&n.push(i);return f}function b(){return!0}function w(){return!1}function T(){try{return te.activeElement}catch(e){}}function C(e,t,n,r,o,i){var s,a;if("object"==typeof t){"string"!=typeof n&&(r=r||n,n=void 0);for(a in t)C(e,a,n,r,t[a],i);return e}if(null==r&&null==o?(o=n,r=n=void 0):null==o&&("string"==typeof n?(o=r,r=void 0):(o=r,r=n,n=void 0)),o===!1)o=w;else if(!o)return e;return 1===i&&(s=o,o=function(e){return de().off(e),s.apply(this,arguments)},o.guid=s.guid||(s.guid=de.guid++)),e.each(function(){de.event.add(this,t,o,r,n)})}function j(e,t){return de.nodeName(e,"table")&&de.nodeName(11!==t.nodeType?t:t.firstChild,"tr")?e.getElementsByTagName("tbody")[0]||e:e}function k(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function E(e){var t=rt.exec(e.type);return t?e.type=t[1]:e.removeAttribute("type"),e}function S(e,t){var n,r,o,i,s,a,u,c;if(1===t.nodeType){if(Fe.hasData(e)&&(i=Fe.access(e),s=Fe.set(t,i),c=i.events)){delete s.handle,s.events={};for(o in c)for(n=0,r=c[o].length;n1&&"string"==typeof d&&!pe.checkClone&&nt.test(d))return e.each(function(n){var i=e.eq(n);g&&(t[0]=d.call(this,n,i.html())),A(i,t,r,o)});if(p&&(i=x(t,e[0].ownerDocument,!1,e,o),s=i.firstChild,1===i.childNodes.length&&(i=s),s||o)){for(a=de.map(v(i,"script"),k),u=a.length;f=0&&nC.cacheLength&&delete e[t.shift()],e[n+" "]=r}var t=[];return e}function r(e){return e[$]=!0,e}function o(e){var t=L.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function i(e,t){for(var n=e.split("|"),r=n.length;r--;)C.attrHandle[n[r]]=t}function s(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)for(;n=n.nextSibling;)if(n===t)return-1;return e?1:-1}function a(e){return function(t){var n=t.nodeName.toLowerCase();return"input"===n&&t.type===e}}function u(e){return function(t){var n=t.nodeName.toLowerCase();return("input"===n||"button"===n)&&t.type===e}}function c(e){return function(t){return"form"in t?t.parentNode&&t.disabled===!1?"label"in t?"label"in t.parentNode?t.parentNode.disabled===e:t.disabled===e:t.isDisabled===e||t.isDisabled!==!e&&je(t)===e:t.disabled===e:"label"in t&&t.disabled===e}}function l(e){return r(function(t){return t=+t,r(function(n,r){for(var o,i=e([],n.length,t),s=i.length;s--;)n[o=i[s]]&&(n[o]=!(r[o]=n[o]))})})}function f(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}function p(){}function h(e){for(var t=0,n=e.length,r="";t1?function(t,n,r){for(var o=e.length;o--;)if(!e[o](t,n,r))return!1;return!0}:e[0]}function m(e,n,r){for(var o=0,i=n.length;o-1&&(r[c]=!(s[c]=f))}}else x=v(x===s?x.splice(d,x.length):x),i?i(null,s,x,u):K.apply(s,x)})}function x(e){for(var t,n,r,o=e.length,i=C.relative[e[0].type],s=i||C.relative[" "],a=i?1:0,u=d(function(e){return e===t},s,!0),c=d(function(e){return ee(t,e)>-1},s,!0),l=[function(e,n,r){var o=!i&&(r||n!==A)||((t=n).nodeType?u(e,n,r):c(e,n,r));return t=null,o}];a1&&g(l),a>1&&h(e.slice(0,a-1).concat({value:" "===e[a-2].type?"*":""})).replace(ae,"$1"),n,a0,i=e.length>0,s=function(r,s,a,u,c){var l,f,p,h=0,d="0",g=r&&[],m=[],y=A,x=r||i&&C.find.TAG("*",c),b=B+=null==y?1:Math.random()||.1,w=x.length;for(c&&(A=s===L||s||c);d!==w&&null!=(l=x[d]);d++){if(i&&l){for(f=0,s||l.ownerDocument===L||(O(l),a=!F);p=e[f++];)if(p(l,s||L,a)){u.push(l);break}c&&(B=b)}o&&((l=!p&&l)&&h--,r&&g.push(l))}if(h+=d,o&&d!==h){for(f=0;p=n[f++];)p(g,m,s,a);if(r){if(h>0)for(;d--;)g[d]||m[d]||(m[d]=Q.call(u));m=v(m)}K.apply(u,m),c&&!r&&m.length>0&&h+n.length>1&&t.uniqueSort(u)}return c&&(B=b,A=y),g};return o?r(s):s}var w,T,C,j,k,E,S,N,A,q,D,O,L,H,F,R,I,P,M,$="sizzle"+1*new Date,W=e.document,B=0,_=0,U=n(),z=n(),X=n(),V=function(e,t){return e===t&&(D=!0),0},G={}.hasOwnProperty,Y=[],Q=Y.pop,J=Y.push,K=Y.push,Z=Y.slice,ee=function(e,t){for(var n=0,r=e.length;n+~]|"+ne+")"+ne+"*"),le=new RegExp("="+ne+"*([^\\]'\"]*?)"+ne+"*\\]","g"),fe=new RegExp(ie),pe=new RegExp("^"+re+"$"),he={ID:new RegExp("^#("+re+")"),CLASS:new RegExp("^\\.("+re+")"),TAG:new RegExp("^("+re+"|[*])"),ATTR:new RegExp("^"+oe),PSEUDO:new RegExp("^"+ie),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+ne+"*(even|odd|(([+-]|)(\\d*)n|)"+ne+"*(?:([+-]|)"+ne+"*(\\d+)|))"+ne+"*\\)|)","i"),bool:new RegExp("^(?:"+te+")$","i"),needsContext:new RegExp("^"+ne+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+ne+"*((?:-\\d)?\\d*)"+ne+"*\\)|)(?=[^-]|$)","i")},de=/^(?:input|select|textarea|button)$/i,ge=/^h\d$/i,me=/^[^{]+\{\s*\[native \w/,ve=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ye=/[+~]/,xe=new RegExp("\\\\([\\da-f]{1,6}"+ne+"?|("+ne+")|.)","ig"),be=function(e,t,n){var r="0x"+t-65536;return r!==r||n?t:r<0?String.fromCharCode(r+65536):String.fromCharCode(r>>10|55296,1023&r|56320)},we=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,Te=function(e,t){return t?"\0"===e?"�":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},Ce=function(){O()},je=d(function(e){return e.disabled===!0&&("form"in e||"label"in e)},{dir:"parentNode",next:"legend"});try{K.apply(Y=Z.call(W.childNodes),W.childNodes),Y[W.childNodes.length].nodeType}catch(e){K={apply:Y.length?function(e,t){J.apply(e,Z.call(t))}:function(e,t){for(var n=e.length,r=0;e[n++]=t[r++];);e.length=n-1}}}T=t.support={},k=t.isXML=function(e){var t=e&&(e.ownerDocument||e).documentElement;return!!t&&"HTML"!==t.nodeName},O=t.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:W;return r!==L&&9===r.nodeType&&r.documentElement?(L=r,H=L.documentElement,F=!k(L),W!==L&&(n=L.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",Ce,!1):n.attachEvent&&n.attachEvent("onunload",Ce)),T.attributes=o(function(e){return e.className="i",!e.getAttribute("className")}),T.getElementsByTagName=o(function(e){return e.appendChild(L.createComment("")),!e.getElementsByTagName("*").length}),T.getElementsByClassName=me.test(L.getElementsByClassName),T.getById=o(function(e){return H.appendChild(e).id=$,!L.getElementsByName||!L.getElementsByName($).length}),T.getById?(C.filter.ID=function(e){var t=e.replace(xe,be);return function(e){return e.getAttribute("id")===t}},C.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&F){var n=t.getElementById(e);return n?[n]:[]}}):(C.filter.ID=function(e){var t=e.replace(xe,be);return function(e){var n="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return n&&n.value===t}},C.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&F){var n,r,o,i=t.getElementById(e);if(i){if(n=i.getAttributeNode("id"),n&&n.value===e)return[i];for(o=t.getElementsByName(e),r=0;i=o[r++];)if(n=i.getAttributeNode("id"),n&&n.value===e)return[i]}return[]}}),C.find.TAG=T.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):T.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],o=0,i=t.getElementsByTagName(e);if("*"===e){for(;n=i[o++];)1===n.nodeType&&r.push(n);return r}return i},C.find.CLASS=T.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&F)return t.getElementsByClassName(e)},I=[],R=[],(T.qsa=me.test(L.querySelectorAll))&&(o(function(e){H.appendChild(e).innerHTML="",e.querySelectorAll("[msallowcapture^='']").length&&R.push("[*^$]="+ne+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||R.push("\\["+ne+"*(?:value|"+te+")"),e.querySelectorAll("[id~="+$+"-]").length||R.push("~="),e.querySelectorAll(":checked").length||R.push(":checked"),e.querySelectorAll("a#"+$+"+*").length||R.push(".#.+[+~]")}),o(function(e){e.innerHTML="";var t=L.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&R.push("name"+ne+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&R.push(":enabled",":disabled"),H.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&R.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),R.push(",.*:")})),(T.matchesSelector=me.test(P=H.matches||H.webkitMatchesSelector||H.mozMatchesSelector||H.oMatchesSelector||H.msMatchesSelector))&&o(function(e){T.disconnectedMatch=P.call(e,"*"),P.call(e,"[s!='']:x"),I.push("!=",ie)}),R=R.length&&new RegExp(R.join("|")),I=I.length&&new RegExp(I.join("|")),t=me.test(H.compareDocumentPosition),M=t||me.test(H.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)for(;t=t.parentNode;)if(t===e)return!0;return!1},V=t?function(e,t){if(e===t)return D=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n?n:(n=(e.ownerDocument||e)===(t.ownerDocument||t)?e.compareDocumentPosition(t):1,1&n||!T.sortDetached&&t.compareDocumentPosition(e)===n?e===L||e.ownerDocument===W&&M(W,e)?-1:t===L||t.ownerDocument===W&&M(W,t)?1:q?ee(q,e)-ee(q,t):0:4&n?-1:1)}:function(e,t){if(e===t)return D=!0,0;var n,r=0,o=e.parentNode,i=t.parentNode,a=[e],u=[t];if(!o||!i)return e===L?-1:t===L?1:o?-1:i?1:q?ee(q,e)-ee(q,t):0;if(o===i)return s(e,t);for(n=e;n=n.parentNode;)a.unshift(n);for(n=t;n=n.parentNode;)u.unshift(n);for(;a[r]===u[r];)r++;return r?s(a[r],u[r]):a[r]===W?-1:u[r]===W?1:0},L):L},t.matches=function(e,n){return t(e,null,null,n)},t.matchesSelector=function(e,n){if((e.ownerDocument||e)!==L&&O(e),n=n.replace(le,"='$1']"),T.matchesSelector&&F&&!X[n+" "]&&(!I||!I.test(n))&&(!R||!R.test(n)))try{var r=P.call(e,n);if(r||T.disconnectedMatch||e.document&&11!==e.document.nodeType)return r}catch(e){}return t(n,L,null,[e]).length>0},t.contains=function(e,t){return(e.ownerDocument||e)!==L&&O(e),M(e,t)},t.attr=function(e,t){(e.ownerDocument||e)!==L&&O(e);var n=C.attrHandle[t.toLowerCase()],r=n&&G.call(C.attrHandle,t.toLowerCase())?n(e,t,!F):void 0;return void 0!==r?r:T.attributes||!F?e.getAttribute(t):(r=e.getAttributeNode(t))&&r.specified?r.value:null},t.escape=function(e){return(e+"").replace(we,Te)},t.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},t.uniqueSort=function(e){var t,n=[],r=0,o=0;if(D=!T.detectDuplicates,q=!T.sortStable&&e.slice(0),e.sort(V),D){for(;t=e[o++];)t===e[o]&&(r=n.push(o));for(;r--;)e.splice(n[r],1)}return q=null,e},j=t.getText=function(e){var t,n="",r=0,o=e.nodeType;if(o){if(1===o||9===o||11===o){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=j(e)}else if(3===o||4===o)return e.nodeValue}else for(;t=e[r++];)n+=j(t);return n},C=t.selectors={cacheLength:50,createPseudo:r,match:he,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(xe,be),e[3]=(e[3]||e[4]||e[5]||"").replace(xe,be),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||t.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&t.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return he.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&fe.test(n)&&(t=E(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(xe,be).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=U[e+" "];return t||(t=new RegExp("(^|"+ne+")"+e+"("+ne+"|$)"))&&U(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(e,n,r){return function(o){var i=t.attr(o,e);return null==i?"!="===n:!n||(i+="","="===n?i===r:"!="===n?i!==r:"^="===n?r&&0===i.indexOf(r):"*="===n?r&&i.indexOf(r)>-1:"$="===n?r&&i.slice(-r.length)===r:"~="===n?(" "+i.replace(se," ")+" ").indexOf(r)>-1:"|="===n&&(i===r||i.slice(0,r.length+1)===r+"-"))}},CHILD:function(e,t,n,r,o){var i="nth"!==e.slice(0,3),s="last"!==e.slice(-4),a="of-type"===t;return 1===r&&0===o?function(e){return!!e.parentNode}:function(t,n,u){var c,l,f,p,h,d,g=i!==s?"nextSibling":"previousSibling",m=t.parentNode,v=a&&t.nodeName.toLowerCase(),y=!u&&!a,x=!1;if(m){if(i){for(;g;){for(p=t;p=p[g];)if(a?p.nodeName.toLowerCase()===v:1===p.nodeType)return!1;d=g="only"===e&&!d&&"nextSibling"}return!0}if(d=[s?m.firstChild:m.lastChild],s&&y){for(p=m,f=p[$]||(p[$]={}),l=f[p.uniqueID]||(f[p.uniqueID]={}),c=l[e]||[],h=c[0]===B&&c[1],x=h&&c[2],p=h&&m.childNodes[h];p=++h&&p&&p[g]||(x=h=0)||d.pop();)if(1===p.nodeType&&++x&&p===t){l[e]=[B,h,x];break}}else if(y&&(p=t,f=p[$]||(p[$]={}),l=f[p.uniqueID]||(f[p.uniqueID]={}),c=l[e]||[],h=c[0]===B&&c[1],x=h),x===!1)for(;(p=++h&&p&&p[g]||(x=h=0)||d.pop())&&((a?p.nodeName.toLowerCase()!==v:1!==p.nodeType)||!++x||(y&&(f=p[$]||(p[$]={}),l=f[p.uniqueID]||(f[p.uniqueID]={}),l[e]=[B,x]),p!==t)););return x-=o,x===r||x%r===0&&x/r>=0}}},PSEUDO:function(e,n){var o,i=C.pseudos[e]||C.setFilters[e.toLowerCase()]||t.error("unsupported pseudo: "+e);return i[$]?i(n):i.length>1?(o=[e,e,"",n],C.setFilters.hasOwnProperty(e.toLowerCase())?r(function(e,t){for(var r,o=i(e,n),s=o.length;s--;)r=ee(e,o[s]),e[r]=!(t[r]=o[s])}):function(e){return i(e,0,o)}):i}},pseudos:{not:r(function(e){var t=[],n=[],o=S(e.replace(ae,"$1"));return o[$]?r(function(e,t,n,r){for(var i,s=o(e,null,r,[]),a=e.length;a--;)(i=s[a])&&(e[a]=!(t[a]=i))}):function(e,r,i){return t[0]=e,o(t,null,i,n),t[0]=null,!n.pop()}}),has:r(function(e){return function(n){ -return t(e,n).length>0}}),contains:r(function(e){return e=e.replace(xe,be),function(t){return(t.textContent||t.innerText||j(t)).indexOf(e)>-1}}),lang:r(function(e){return pe.test(e||"")||t.error("unsupported lang: "+e),e=e.replace(xe,be).toLowerCase(),function(t){var n;do if(n=F?t.lang:t.getAttribute("xml:lang")||t.getAttribute("lang"))return n=n.toLowerCase(),n===e||0===n.indexOf(e+"-");while((t=t.parentNode)&&1===t.nodeType);return!1}}),target:function(t){var n=e.location&&e.location.hash;return n&&n.slice(1)===t.id},root:function(e){return e===H},focus:function(e){return e===L.activeElement&&(!L.hasFocus||L.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:c(!1),disabled:c(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,e.selected===!0},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!C.pseudos.empty(e)},header:function(e){return ge.test(e.nodeName)},input:function(e){return de.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:l(function(){return[0]}),last:l(function(e,t){return[t-1]}),eq:l(function(e,t,n){return[n<0?n+t:n]}),even:l(function(e,t){for(var n=0;n=0;)e.push(r);return e}),gt:l(function(e,t,n){for(var r=n<0?n+t:n;++r2&&"ID"===(s=i[0]).type&&9===t.nodeType&&F&&C.relative[i[1].type]){if(t=(C.find.ID(s.matches[0].replace(xe,be),t)||[])[0],!t)return n;c&&(t=t.parentNode),e=e.slice(i.shift().value.length)}for(o=he.needsContext.test(e)?0:i.length;o--&&(s=i[o],!C.relative[a=s.type]);)if((u=C.find[a])&&(r=u(s.matches[0].replace(xe,be),ye.test(i[0].type)&&f(t.parentNode)||t))){if(i.splice(o,1),e=r.length&&h(i),!e)return K.apply(n,r),n;break}}return(c||S(e,l))(r,t,!F,n,!t||ye.test(e)&&f(t.parentNode)||t),n},T.sortStable=$.split("").sort(V).join("")===$,T.detectDuplicates=!!D,O(),T.sortDetached=o(function(e){return 1&e.compareDocumentPosition(L.createElement("fieldset"))}),o(function(e){return e.innerHTML="","#"===e.firstChild.getAttribute("href")})||i("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),T.attributes&&o(function(e){return e.innerHTML="",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||i("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),o(function(e){return null==e.getAttribute("disabled")})||i(te,function(e,t,n){var r;if(!n)return e[t]===!0?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),t}(e);de.find=xe,de.expr=xe.selectors,de.expr[":"]=de.expr.pseudos,de.uniqueSort=de.unique=xe.uniqueSort,de.text=xe.getText,de.isXMLDoc=xe.isXML,de.contains=xe.contains,de.escapeSelector=xe.escape;var be=function(e,t,n){for(var r=[],o=void 0!==n;(e=e[t])&&9!==e.nodeType;)if(1===e.nodeType){if(o&&de(e).is(n))break;r.push(e)}return r},we=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},Te=de.expr.match.needsContext,Ce=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i,je=/^.[^:#\[\.,]*$/;de.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?de.find.matchesSelector(r,e)?[r]:[]:de.find.matches(e,de.grep(t,function(e){return 1===e.nodeType}))},de.fn.extend({find:function(e){var t,n,r=this.length,o=this;if("string"!=typeof e)return this.pushStack(de(e).filter(function(){for(t=0;t1?de.uniqueSort(n):n},filter:function(e){return this.pushStack(o(this,e||[],!1))},not:function(e){return this.pushStack(o(this,e||[],!0))},is:function(e){return!!o(this,"string"==typeof e&&Te.test(e)?de(e):e||[],!1).length}});var ke,Ee=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,Se=de.fn.init=function(e,t,n){var r,o;if(!e)return this;if(n=n||ke,"string"==typeof e){if(r="<"===e[0]&&">"===e[e.length-1]&&e.length>=3?[null,e,null]:Ee.exec(e),!r||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof de?t[0]:t,de.merge(this,de.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:te,!0)),Ce.test(r[1])&&de.isPlainObject(t))for(r in t)de.isFunction(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return o=te.getElementById(r[2]),o&&(this[0]=o,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):de.isFunction(e)?void 0!==n.ready?n.ready(e):e(de):de.makeArray(e,this)};Se.prototype=de.fn,ke=de(te);var Ne=/^(?:parents|prev(?:Until|All))/,Ae={children:!0,contents:!0,next:!0,prev:!0};de.fn.extend({has:function(e){var t=de(e,this),n=t.length;return this.filter(function(){for(var e=0;e-1:1===n.nodeType&&de.find.matchesSelector(n,e))){i.push(n);break}return this.pushStack(i.length>1?de.uniqueSort(i):i)},index:function(e){return e?"string"==typeof e?se.call(de(e),this[0]):se.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(de.uniqueSort(de.merge(this.get(),de(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),de.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return be(e,"parentNode")},parentsUntil:function(e,t,n){return be(e,"parentNode",n)},next:function(e){return i(e,"nextSibling")},prev:function(e){return i(e,"previousSibling")},nextAll:function(e){return be(e,"nextSibling")},prevAll:function(e){return be(e,"previousSibling")},nextUntil:function(e,t,n){return be(e,"nextSibling",n)},prevUntil:function(e,t,n){return be(e,"previousSibling",n)},siblings:function(e){return we((e.parentNode||{}).firstChild,e)},children:function(e){return we(e.firstChild)},contents:function(e){return e.contentDocument||de.merge([],e.childNodes)}},function(e,t){de.fn[e]=function(n,r){var o=de.map(this,t,n);return"Until"!==e.slice(-5)&&(r=n),r&&"string"==typeof r&&(o=de.filter(r,o)),this.length>1&&(Ae[e]||de.uniqueSort(o),Ne.test(e)&&o.reverse()),this.pushStack(o)}});var qe=/[^\x20\t\r\n\f]+/g;de.Callbacks=function(e){e="string"==typeof e?s(e):de.extend({},e);var t,n,r,o,i=[],a=[],u=-1,c=function(){for(o=e.once,r=t=!0;a.length;u=-1)for(n=a.shift();++u-1;)i.splice(n,1),n<=u&&u--}),this},has:function(e){return e?de.inArray(e,i)>-1:i.length>0},empty:function(){return i&&(i=[]),this},disable:function(){return o=a=[],i=n="",this},disabled:function(){return!i},lock:function(){return o=a=[],n||t||(i=n=""),this},locked:function(){return!!o},fireWith:function(e,n){return o||(n=n||[],n=[e,n.slice?n.slice():n],a.push(n),t||c()),this},fire:function(){return l.fireWith(this,arguments),this},fired:function(){return!!r}};return l},de.extend({Deferred:function(t){var n=[["notify","progress",de.Callbacks("memory"),de.Callbacks("memory"),2],["resolve","done",de.Callbacks("once memory"),de.Callbacks("once memory"),0,"resolved"],["reject","fail",de.Callbacks("once memory"),de.Callbacks("once memory"),1,"rejected"]],r="pending",o={state:function(){return r},always:function(){return i.done(arguments).fail(arguments),this},catch:function(e){return o.then(null,e)},pipe:function(){var e=arguments;return de.Deferred(function(t){de.each(n,function(n,r){var o=de.isFunction(e[r[4]])&&e[r[4]];i[r[1]](function(){var e=o&&o.apply(this,arguments);e&&de.isFunction(e.promise)?e.promise().progress(t.notify).done(t.resolve).fail(t.reject):t[r[0]+"With"](this,o?[e]:arguments)})}),e=null}).promise()},then:function(t,r,o){function i(t,n,r,o){return function(){var c=this,l=arguments,f=function(){var e,f;if(!(t=s&&(r!==u&&(c=void 0,l=[e]),n.rejectWith(c,l))}};t?p():(de.Deferred.getStackHook&&(p.stackTrace=de.Deferred.getStackHook()),e.setTimeout(p))}}var s=0;return de.Deferred(function(e){n[0][3].add(i(0,e,de.isFunction(o)?o:a,e.notifyWith)),n[1][3].add(i(0,e,de.isFunction(t)?t:a)),n[2][3].add(i(0,e,de.isFunction(r)?r:u))}).promise()},promise:function(e){return null!=e?de.extend(e,o):o}},i={};return de.each(n,function(e,t){var s=t[2],a=t[5];o[t[1]]=s.add,a&&s.add(function(){r=a},n[3-e][2].disable,n[0][2].lock),s.add(t[3].fire),i[t[0]]=function(){return i[t[0]+"With"](this===i?void 0:this,arguments),this},i[t[0]+"With"]=s.fireWith}),o.promise(i),t&&t.call(i,i),i},when:function(e){var t=arguments.length,n=t,r=Array(n),o=re.call(arguments),i=de.Deferred(),s=function(e){return function(n){r[e]=this,o[e]=arguments.length>1?re.call(arguments):n,--t||i.resolveWith(r,o)}};if(t<=1&&(c(e,i.done(s(n)).resolve,i.reject),"pending"===i.state()||de.isFunction(o[n]&&o[n].then)))return i.then();for(;n--;)c(o[n],s(n),i.reject);return i.promise()}});var De=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;de.Deferred.exceptionHook=function(t,n){e.console&&e.console.warn&&t&&De.test(t.name)&&e.console.warn("jQuery.Deferred exception: "+t.message,t.stack,n)},de.readyException=function(t){e.setTimeout(function(){throw t})};var Oe=de.Deferred();de.fn.ready=function(e){return Oe.then(e).catch(function(e){de.readyException(e)}),this},de.extend({isReady:!1,readyWait:1,holdReady:function(e){e?de.readyWait++:de.ready(!0)},ready:function(e){(e===!0?--de.readyWait:de.isReady)||(de.isReady=!0,e!==!0&&--de.readyWait>0||Oe.resolveWith(te,[de]))}}),de.ready.then=Oe.then,"complete"===te.readyState||"loading"!==te.readyState&&!te.documentElement.doScroll?e.setTimeout(de.ready):(te.addEventListener("DOMContentLoaded",l),e.addEventListener("load",l));var Le=function(e,t,n,r,o,i,s){var a=0,u=e.length,c=null==n;if("object"===de.type(n)){o=!0;for(a in n)Le(e,t,a,n[a],!0,i,s)}else if(void 0!==r&&(o=!0,de.isFunction(r)||(s=!0),c&&(s?(t.call(e,r),t=null):(c=t,t=function(e,t,n){return c.call(de(e),n)})),t))for(;a1,null,!0)},removeData:function(e){return this.each(function(){Re.remove(this,e)})}}),de.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Fe.get(e,t),n&&(!r||de.isArray(n)?r=Fe.access(e,t,de.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=de.queue(e,t),r=n.length,o=n.shift(),i=de._queueHooks(e,t),s=function(){de.dequeue(e,t)};"inprogress"===o&&(o=n.shift(),r--),o&&("fx"===t&&n.unshift("inprogress"),delete i.stop,o.call(e,s,i)),!r&&i&&i.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Fe.get(e,n)||Fe.access(e,n,{empty:de.Callbacks("once memory").add(function(){Fe.remove(e,[t+"queue",n])})})}}),de.fn.extend({queue:function(e,t){var n=2;return"string"!=typeof e&&(t=e,e="fx",n--),arguments.length\x20\t\r\n\f]+)/i,Ve=/^$|\/(?:java|ecma)script/i,Ge={option:[1,""],thead:[1,"","
                                                                  "],col:[2,"","
                                                                  "],tr:[2,"","
                                                                  "],td:[3,"","
                                                                  "],_default:[0,"",""]};Ge.optgroup=Ge.option,Ge.tbody=Ge.tfoot=Ge.colgroup=Ge.caption=Ge.thead,Ge.th=Ge.td;var Ye=/<|&#?\w+;/;!function(){var e=te.createDocumentFragment(),t=e.appendChild(te.createElement("div")),n=te.createElement("input");n.setAttribute("type","radio"),n.setAttribute("checked","checked"),n.setAttribute("name","t"),t.appendChild(n),pe.checkClone=t.cloneNode(!0).cloneNode(!0).lastChild.checked,t.innerHTML="",pe.noCloneChecked=!!t.cloneNode(!0).lastChild.defaultValue}();var Qe=te.documentElement,Je=/^key/,Ke=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,Ze=/^([^.]*)(?:\.(.+)|)/;de.event={global:{},add:function(e,t,n,r,o){var i,s,a,u,c,l,f,p,h,d,g,m=Fe.get(e);if(m)for(n.handler&&(i=n,n=i.handler,o=i.selector),o&&de.find.matchesSelector(Qe,o),n.guid||(n.guid=de.guid++),(u=m.events)||(u=m.events={}),(s=m.handle)||(s=m.handle=function(t){return"undefined"!=typeof de&&de.event.triggered!==t.type?de.event.dispatch.apply(e,arguments):void 0}),t=(t||"").match(qe)||[""],c=t.length;c--;)a=Ze.exec(t[c])||[],h=g=a[1],d=(a[2]||"").split(".").sort(),h&&(f=de.event.special[h]||{},h=(o?f.delegateType:f.bindType)||h,f=de.event.special[h]||{},l=de.extend({type:h,origType:g,data:r,handler:n,guid:n.guid,selector:o,needsContext:o&&de.expr.match.needsContext.test(o),namespace:d.join(".")},i),(p=u[h])||(p=u[h]=[],p.delegateCount=0,f.setup&&f.setup.call(e,r,d,s)!==!1||e.addEventListener&&e.addEventListener(h,s)),f.add&&(f.add.call(e,l),l.handler.guid||(l.handler.guid=n.guid)),o?p.splice(p.delegateCount++,0,l):p.push(l),de.event.global[h]=!0)},remove:function(e,t,n,r,o){var i,s,a,u,c,l,f,p,h,d,g,m=Fe.hasData(e)&&Fe.get(e);if(m&&(u=m.events)){for(t=(t||"").match(qe)||[""],c=t.length;c--;)if(a=Ze.exec(t[c])||[],h=g=a[1],d=(a[2]||"").split(".").sort(),h){for(f=de.event.special[h]||{},h=(r?f.delegateType:f.bindType)||h,p=u[h]||[],a=a[2]&&new RegExp("(^|\\.)"+d.join("\\.(?:.*\\.|)")+"(\\.|$)"),s=i=p.length;i--;)l=p[i],!o&&g!==l.origType||n&&n.guid!==l.guid||a&&!a.test(l.namespace)||r&&r!==l.selector&&("**"!==r||!l.selector)||(p.splice(i,1),l.selector&&p.delegateCount--,f.remove&&f.remove.call(e,l));s&&!p.length&&(f.teardown&&f.teardown.call(e,d,m.handle)!==!1||de.removeEvent(e,h,m.handle),delete u[h])}else for(h in u)de.event.remove(e,h+t[c],n,r,!0);de.isEmptyObject(u)&&Fe.remove(e,"handle events")}},dispatch:function(e){var t,n,r,o,i,s,a=de.event.fix(e),u=new Array(arguments.length),c=(Fe.get(this,"events")||{})[a.type]||[],l=de.event.special[a.type]||{};for(u[0]=a,t=1;t=1))for(;c!==this;c=c.parentNode||this)if(1===c.nodeType&&("click"!==e.type||c.disabled!==!0)){for(i=[],s={},n=0;n-1:de.find(o,this,null,[c]).length),s[o]&&i.push(r);i.length&&a.push({elem:c,handlers:i})}return c=this,u\x20\t\r\n\f]*)[^>]*)\/>/gi,tt=/\s*$/g;de.extend({htmlPrefilter:function(e){return e.replace(et,"<$1>")},clone:function(e,t,n){var r,o,i,s,a=e.cloneNode(!0),u=de.contains(e.ownerDocument,e);if(!(pe.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||de.isXMLDoc(e)))for(s=v(a),i=v(e),r=0,o=i.length;r0&&y(s,!u&&v(e,"script")),a},cleanData:function(e){for(var t,n,r,o=de.event.special,i=0;void 0!==(n=e[i]);i++)if(He(n)){if(t=n[Fe.expando]){if(t.events)for(r in t.events)o[r]?de.event.remove(n,r):de.removeEvent(n,r,t.handle);n[Fe.expando]=void 0}n[Re.expando]&&(n[Re.expando]=void 0)}}}),de.fn.extend({detach:function(e){return q(this,e,!0)},remove:function(e){return q(this,e)},text:function(e){return Le(this,function(e){return void 0===e?de.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return A(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=j(this,e);t.appendChild(e)}})},prepend:function(){return A(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=j(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return A(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return A(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(de.cleanData(v(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return de.clone(this,e,t)})},html:function(e){return Le(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!tt.test(e)&&!Ge[(Xe.exec(e)||["",""])[1].toLowerCase()]){e=de.htmlPrefilter(e);try{for(;n1)}}),de.Tween=I,I.prototype={constructor:I,init:function(e,t,n,r,o,i){this.elem=e,this.prop=n,this.easing=o||de.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=i||(de.cssNumber[n]?"":"px")},cur:function(){var e=I.propHooks[this.prop];return e&&e.get?e.get(this):I.propHooks._default.get(this)},run:function(e){var t,n=I.propHooks[this.prop];return this.options.duration?this.pos=t=de.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):I.propHooks._default.set(this),this}},I.prototype.init.prototype=I.prototype,I.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=de.css(e.elem,e.prop,""),t&&"auto"!==t?t:0)},set:function(e){de.fx.step[e.prop]?de.fx.step[e.prop](e):1!==e.elem.nodeType||null==e.elem.style[de.cssProps[e.prop]]&&!de.cssHooks[e.prop]?e.elem[e.prop]=e.now:de.style(e.elem,e.prop,e.now+e.unit)}}},I.propHooks.scrollTop=I.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},de.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},de.fx=I.prototype.init,de.fx.step={};var ht,dt,gt=/^(?:toggle|show|hide)$/,mt=/queueHooks$/;de.Animation=de.extend(U,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return d(n.elem,e,$e.exec(t),n),n}]},tweener:function(e,t){de.isFunction(e)?(t=e,e=["*"]):e=e.match(qe);for(var n,r=0,o=e.length;r1)},removeAttr:function(e){return this.each(function(){de.removeAttr(this,e)})}}),de.extend({attr:function(e,t,n){var r,o,i=e.nodeType;if(3!==i&&8!==i&&2!==i)return"undefined"==typeof e.getAttribute?de.prop(e,t,n):(1===i&&de.isXMLDoc(e)||(o=de.attrHooks[t.toLowerCase()]||(de.expr.match.bool.test(t)?vt:void 0)),void 0!==n?null===n?void de.removeAttr(e,t):o&&"set"in o&&void 0!==(r=o.set(e,n,t))?r:(e.setAttribute(t,n+""),n):o&&"get"in o&&null!==(r=o.get(e,t))?r:(r=de.find.attr(e,t),null==r?void 0:r))},attrHooks:{type:{set:function(e,t){if(!pe.radioValue&&"radio"===t&&de.nodeName(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,o=t&&t.match(qe);if(o&&1===e.nodeType)for(;n=o[r++];)e.removeAttribute(n)}}),vt={set:function(e,t,n){return t===!1?de.removeAttr(e,n):e.setAttribute(n,n),n}},de.each(de.expr.match.bool.source.match(/\w+/g),function(e,t){var n=yt[t]||de.find.attr;yt[t]=function(e,t,r){var o,i,s=t.toLowerCase();return r||(i=yt[s],yt[s]=o,o=null!=n(e,t,r)?s:null,yt[s]=i),o}});var xt=/^(?:input|select|textarea|button)$/i,bt=/^(?:a|area)$/i;de.fn.extend({prop:function(e,t){return Le(this,de.prop,e,t,arguments.length>1)},removeProp:function(e){return this.each(function(){delete this[de.propFix[e]||e]})}}),de.extend({prop:function(e,t,n){var r,o,i=e.nodeType;if(3!==i&&8!==i&&2!==i)return 1===i&&de.isXMLDoc(e)||(t=de.propFix[t]||t,o=de.propHooks[t]),void 0!==n?o&&"set"in o&&void 0!==(r=o.set(e,n,t))?r:e[t]=n:o&&"get"in o&&null!==(r=o.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=de.find.attr(e,"tabindex");return t?parseInt(t,10):xt.test(e.nodeName)||bt.test(e.nodeName)&&e.href?0:-1}}},propFix:{for:"htmlFor",class:"className"}}),pe.optSelected||(de.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),de.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){de.propFix[this.toLowerCase()]=this}),de.fn.extend({addClass:function(e){var t,n,r,o,i,s,a,u=0;if(de.isFunction(e))return this.each(function(t){de(this).addClass(e.call(this,t,X(this)))});if("string"==typeof e&&e)for(t=e.match(qe)||[];n=this[u++];)if(o=X(n),r=1===n.nodeType&&" "+z(o)+" "){for(s=0;i=t[s++];)r.indexOf(" "+i+" ")<0&&(r+=i+" ");a=z(r),o!==a&&n.setAttribute("class",a)}return this},removeClass:function(e){var t,n,r,o,i,s,a,u=0;if(de.isFunction(e))return this.each(function(t){de(this).removeClass(e.call(this,t,X(this)))});if(!arguments.length)return this.attr("class","");if("string"==typeof e&&e)for(t=e.match(qe)||[];n=this[u++];)if(o=X(n),r=1===n.nodeType&&" "+z(o)+" "){for(s=0;i=t[s++];)for(;r.indexOf(" "+i+" ")>-1;)r=r.replace(" "+i+" "," ");a=z(r),o!==a&&n.setAttribute("class",a)}return this},toggleClass:function(e,t){var n=typeof e;return"boolean"==typeof t&&"string"===n?t?this.addClass(e):this.removeClass(e):de.isFunction(e)?this.each(function(n){de(this).toggleClass(e.call(this,n,X(this),t),t)}):this.each(function(){var t,r,o,i;if("string"===n)for(r=0,o=de(this),i=e.match(qe)||[];t=i[r++];)o.hasClass(t)?o.removeClass(t):o.addClass(t);else void 0!==e&&"boolean"!==n||(t=X(this),t&&Fe.set(this,"__className__",t),this.setAttribute&&this.setAttribute("class",t||e===!1?"":Fe.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;for(t=" "+e+" ";n=this[r++];)if(1===n.nodeType&&(" "+z(X(n))+" ").indexOf(t)>-1)return!0;return!1}});var wt=/\r/g;de.fn.extend({val:function(e){var t,n,r,o=this[0];{if(arguments.length)return r=de.isFunction(e),this.each(function(n){var o;1===this.nodeType&&(o=r?e.call(this,n,de(this).val()):e,null==o?o="":"number"==typeof o?o+="":de.isArray(o)&&(o=de.map(o,function(e){return null==e?"":e+""})),t=de.valHooks[this.type]||de.valHooks[this.nodeName.toLowerCase()],t&&"set"in t&&void 0!==t.set(this,o,"value")||(this.value=o))});if(o)return t=de.valHooks[o.type]||de.valHooks[o.nodeName.toLowerCase()],t&&"get"in t&&void 0!==(n=t.get(o,"value"))?n:(n=o.value,"string"==typeof n?n.replace(wt,""):null==n?"":n)}}}),de.extend({valHooks:{option:{get:function(e){var t=de.find.attr(e,"value");return null!=t?t:z(de.text(e))}},select:{get:function(e){var t,n,r,o=e.options,i=e.selectedIndex,s="select-one"===e.type,a=s?null:[],u=s?i+1:o.length;for(r=i<0?u:s?i:0;r-1)&&(n=!0);return n||(e.selectedIndex=-1),i}}}}),de.each(["radio","checkbox"],function(){de.valHooks[this]={set:function(e,t){if(de.isArray(t))return e.checked=de.inArray(de(e).val(),t)>-1}},pe.checkOn||(de.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})});var Tt=/^(?:focusinfocus|focusoutblur)$/;de.extend(de.event,{trigger:function(t,n,r,o){var i,s,a,u,c,l,f,p=[r||te],h=ce.call(t,"type")?t.type:t,d=ce.call(t,"namespace")?t.namespace.split("."):[];if(s=a=r=r||te,3!==r.nodeType&&8!==r.nodeType&&!Tt.test(h+de.event.triggered)&&(h.indexOf(".")>-1&&(d=h.split("."),h=d.shift(),d.sort()),c=h.indexOf(":")<0&&"on"+h,t=t[de.expando]?t:new de.Event(h,"object"==typeof t&&t),t.isTrigger=o?2:3,t.namespace=d.join("."),t.rnamespace=t.namespace?new RegExp("(^|\\.)"+d.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,t.result=void 0,t.target||(t.target=r),n=null==n?[t]:de.makeArray(n,[t]),f=de.event.special[h]||{},o||!f.trigger||f.trigger.apply(r,n)!==!1)){if(!o&&!f.noBubble&&!de.isWindow(r)){for(u=f.delegateType||h,Tt.test(u+h)||(s=s.parentNode);s;s=s.parentNode)p.push(s),a=s;a===(r.ownerDocument||te)&&p.push(a.defaultView||a.parentWindow||e)}for(i=0;(s=p[i++])&&!t.isPropagationStopped();)t.type=i>1?u:f.bindType||h,l=(Fe.get(s,"events")||{})[t.type]&&Fe.get(s,"handle"),l&&l.apply(s,n),l=c&&s[c],l&&l.apply&&He(s)&&(t.result=l.apply(s,n),t.result===!1&&t.preventDefault());return t.type=h,o||t.isDefaultPrevented()||f._default&&f._default.apply(p.pop(),n)!==!1||!He(r)||c&&de.isFunction(r[h])&&!de.isWindow(r)&&(a=r[c],a&&(r[c]=null),de.event.triggered=h,r[h](),de.event.triggered=void 0,a&&(r[c]=a)),t.result}},simulate:function(e,t,n){var r=de.extend(new de.Event,n,{type:e,isSimulated:!0});de.event.trigger(r,null,t)}}),de.fn.extend({trigger:function(e,t){return this.each(function(){de.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return de.event.trigger(e,t,n,!0)}}),de.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,t){de.fn[t]=function(e,n){return arguments.length>0?this.on(t,null,e,n):this.trigger(t)}}),de.fn.extend({hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),pe.focusin="onfocusin"in e,pe.focusin||de.each({focus:"focusin",blur:"focusout"},function(e,t){var n=function(e){de.event.simulate(t,e.target,de.event.fix(e))};de.event.special[t]={setup:function(){var r=this.ownerDocument||this,o=Fe.access(r,t);o||r.addEventListener(e,n,!0),Fe.access(r,t,(o||0)+1)},teardown:function(){var r=this.ownerDocument||this,o=Fe.access(r,t)-1;o?Fe.access(r,t,o):(r.removeEventListener(e,n,!0),Fe.remove(r,t))}}});var Ct=e.location,jt=de.now(),kt=/\?/;de.parseXML=function(t){var n;if(!t||"string"!=typeof t)return null;try{n=(new e.DOMParser).parseFromString(t,"text/xml")}catch(e){n=void 0}return n&&!n.getElementsByTagName("parsererror").length||de.error("Invalid XML: "+t),n};var Et=/\[\]$/,St=/\r?\n/g,Nt=/^(?:submit|button|image|reset|file)$/i,At=/^(?:input|select|textarea|keygen)/i;de.param=function(e,t){var n,r=[],o=function(e,t){var n=de.isFunction(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(de.isArray(e)||e.jquery&&!de.isPlainObject(e))de.each(e,function(){o(this.name,this.value)});else for(n in e)V(n,e[n],t,o);return r.join("&")},de.fn.extend({serialize:function(){return de.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=de.prop(this,"elements");return e?de.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!de(this).is(":disabled")&&At.test(this.nodeName)&&!Nt.test(e)&&(this.checked||!ze.test(e))}).map(function(e,t){var n=de(this).val();return null==n?null:de.isArray(n)?de.map(n,function(e){return{name:t.name,value:e.replace(St,"\r\n")}}):{name:t.name,value:n.replace(St,"\r\n")}}).get()}});var qt=/%20/g,Dt=/#.*$/,Ot=/([?&])_=[^&]*/,Lt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Ht=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Ft=/^(?:GET|HEAD)$/,Rt=/^\/\//,It={},Pt={},Mt="*/".concat("*"),$t=te.createElement("a");$t.href=Ct.href,de.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Ct.href,type:"GET",isLocal:Ht.test(Ct.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Mt,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":de.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?Q(Q(e,de.ajaxSettings),t):Q(de.ajaxSettings,e)},ajaxPrefilter:G(It),ajaxTransport:G(Pt),ajax:function(t,n){function r(t,n,r,a){var c,p,h,b,w,T=n;l||(l=!0,u&&e.clearTimeout(u),o=void 0,s=a||"",C.readyState=t>0?4:0,c=t>=200&&t<300||304===t,r&&(b=J(d,C,r)),b=K(d,b,C,c),c?(d.ifModified&&(w=C.getResponseHeader("Last-Modified"),w&&(de.lastModified[i]=w),w=C.getResponseHeader("etag"),w&&(de.etag[i]=w)),204===t||"HEAD"===d.type?T="nocontent":304===t?T="notmodified":(T=b.state,p=b.data,h=b.error,c=!h)):(h=T,!t&&T||(T="error",t<0&&(t=0))),C.status=t,C.statusText=(n||T)+"",c?v.resolveWith(g,[p,T,C]):v.rejectWith(g,[C,T,h]),C.statusCode(x),x=void 0,f&&m.trigger(c?"ajaxSuccess":"ajaxError",[C,d,c?p:h]),y.fireWith(g,[C,T]),f&&(m.trigger("ajaxComplete",[C,d]),--de.active||de.event.trigger("ajaxStop")))}"object"==typeof t&&(n=t,t=void 0),n=n||{};var o,i,s,a,u,c,l,f,p,h,d=de.ajaxSetup({},n),g=d.context||d,m=d.context&&(g.nodeType||g.jquery)?de(g):de.event,v=de.Deferred(),y=de.Callbacks("once memory"),x=d.statusCode||{},b={},w={},T="canceled",C={readyState:0,getResponseHeader:function(e){var t;if(l){if(!a)for(a={};t=Lt.exec(s);)a[t[1].toLowerCase()]=t[2];t=a[e.toLowerCase()]}return null==t?null:t},getAllResponseHeaders:function(){return l?s:null},setRequestHeader:function(e,t){return null==l&&(e=w[e.toLowerCase()]=w[e.toLowerCase()]||e,b[e]=t),this},overrideMimeType:function(e){return null==l&&(d.mimeType=e),this},statusCode:function(e){var t;if(e)if(l)C.always(e[C.status]);else for(t in e)x[t]=[x[t],e[t]];return this},abort:function(e){var t=e||T;return o&&o.abort(t),r(0,t),this}};if(v.promise(C),d.url=((t||d.url||Ct.href)+"").replace(Rt,Ct.protocol+"//"),d.type=n.method||n.type||d.method||d.type,d.dataTypes=(d.dataType||"*").toLowerCase().match(qe)||[""],null==d.crossDomain){c=te.createElement("a");try{c.href=d.url,c.href=c.href,d.crossDomain=$t.protocol+"//"+$t.host!=c.protocol+"//"+c.host}catch(e){d.crossDomain=!0}}if(d.data&&d.processData&&"string"!=typeof d.data&&(d.data=de.param(d.data,d.traditional)),Y(It,d,n,C),l)return C;f=de.event&&d.global,f&&0===de.active++&&de.event.trigger("ajaxStart"),d.type=d.type.toUpperCase(),d.hasContent=!Ft.test(d.type),i=d.url.replace(Dt,""),d.hasContent?d.data&&d.processData&&0===(d.contentType||"").indexOf("application/x-www-form-urlencoded")&&(d.data=d.data.replace(qt,"+")):(h=d.url.slice(i.length),d.data&&(i+=(kt.test(i)?"&":"?")+d.data,delete d.data),d.cache===!1&&(i=i.replace(Ot,"$1"),h=(kt.test(i)?"&":"?")+"_="+jt++ +h),d.url=i+h),d.ifModified&&(de.lastModified[i]&&C.setRequestHeader("If-Modified-Since",de.lastModified[i]),de.etag[i]&&C.setRequestHeader("If-None-Match",de.etag[i])),(d.data&&d.hasContent&&d.contentType!==!1||n.contentType)&&C.setRequestHeader("Content-Type",d.contentType),C.setRequestHeader("Accept",d.dataTypes[0]&&d.accepts[d.dataTypes[0]]?d.accepts[d.dataTypes[0]]+("*"!==d.dataTypes[0]?", "+Mt+"; q=0.01":""):d.accepts["*"]);for(p in d.headers)C.setRequestHeader(p,d.headers[p]);if(d.beforeSend&&(d.beforeSend.call(g,C,d)===!1||l))return C.abort();if(T="abort",y.add(d.complete),C.done(d.success),C.fail(d.error),o=Y(Pt,d,n,C)){if(C.readyState=1,f&&m.trigger("ajaxSend",[C,d]),l)return C;d.async&&d.timeout>0&&(u=e.setTimeout(function(){C.abort("timeout")},d.timeout));try{l=!1,o.send(b,r)}catch(e){if(l)throw e;r(-1,e)}}else r(-1,"No Transport");return C},getJSON:function(e,t,n){return de.get(e,t,n,"json")},getScript:function(e,t){return de.get(e,void 0,t,"script")}}),de.each(["get","post"],function(e,t){de[t]=function(e,n,r,o){return de.isFunction(n)&&(o=o||r,r=n,n=void 0),de.ajax(de.extend({url:e,type:t,dataType:o,data:n,success:r},de.isPlainObject(e)&&e))}}),de._evalUrl=function(e){return de.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,throws:!0})},de.fn.extend({wrapAll:function(e){var t;return this[0]&&(de.isFunction(e)&&(e=e.call(this[0])),t=de(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){for(var e=this;e.firstElementChild;)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(e){return de.isFunction(e)?this.each(function(t){de(this).wrapInner(e.call(this,t))}):this.each(function(){var t=de(this),n=t.contents();n.length?n.wrapAll(e):t.append(e)})},wrap:function(e){var t=de.isFunction(e);return this.each(function(n){de(this).wrapAll(t?e.call(this,n):e)})},unwrap:function(e){return this.parent(e).not("body").each(function(){de(this).replaceWith(this.childNodes)}),this}}),de.expr.pseudos.hidden=function(e){return!de.expr.pseudos.visible(e)},de.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},de.ajaxSettings.xhr=function(){try{return new e.XMLHttpRequest}catch(e){}};var Wt={0:200,1223:204},Bt=de.ajaxSettings.xhr();pe.cors=!!Bt&&"withCredentials"in Bt,pe.ajax=Bt=!!Bt,de.ajaxTransport(function(t){var n,r;if(pe.cors||Bt&&!t.crossDomain)return{send:function(o,i){var s,a=t.xhr();if(a.open(t.type,t.url,t.async,t.username,t.password),t.xhrFields)for(s in t.xhrFields)a[s]=t.xhrFields[s];t.mimeType&&a.overrideMimeType&&a.overrideMimeType(t.mimeType),t.crossDomain||o["X-Requested-With"]||(o["X-Requested-With"]="XMLHttpRequest");for(s in o)a.setRequestHeader(s,o[s]);n=function(e){return function(){n&&(n=r=a.onload=a.onerror=a.onabort=a.onreadystatechange=null,"abort"===e?a.abort():"error"===e?"number"!=typeof a.status?i(0,"error"):i(a.status,a.statusText):i(Wt[a.status]||a.status,a.statusText,"text"!==(a.responseType||"text")||"string"!=typeof a.responseText?{binary:a.response}:{text:a.responseText},a.getAllResponseHeaders()))}},a.onload=n(),r=a.onerror=n("error"),void 0!==a.onabort?a.onabort=r:a.onreadystatechange=function(){4===a.readyState&&e.setTimeout(function(){n&&r()})},n=n("abort");try{a.send(t.hasContent&&t.data||null)}catch(e){if(n)throw e}},abort:function(){n&&n()}}}),de.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),de.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return de.globalEval(e),e}}}),de.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),de.ajaxTransport("script",function(e){if(e.crossDomain){var t,n;return{send:function(r,o){t=de(" - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/integration/AMQPBridge.md b/docs/integration/AMQPBridge.md deleted file mode 100644 index 41c5080..0000000 --- a/docs/integration/AMQPBridge.md +++ /dev/null @@ -1 +0,0 @@ -# Vert.x AMQP Bridge diff --git a/docs/integration/ConsulClient .md b/docs/integration/ConsulClient .md deleted file mode 100644 index 760a666..0000000 --- a/docs/integration/ConsulClient .md +++ /dev/null @@ -1 +0,0 @@ -# Vert.x Consul Client diff --git a/docs/integration/Integration.html b/docs/integration/Integration.html deleted file mode 100644 index 434aa29..0000000 --- a/docs/integration/Integration.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - Integration · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

                                                                  -
                                                                  - - - - - - - - -
                                                                  - -
                                                                  - -
                                                                  - - - - - - - - -
                                                                  -
                                                                  - -
                                                                  -
                                                                  - -
                                                                  - -

                                                                  Vert.x Integration

                                                                  - - -
                                                                  - -
                                                                  -
                                                                  -
                                                                  - -

                                                                  results matching ""

                                                                  -
                                                                    - -
                                                                    -
                                                                    - -

                                                                    No results matching ""

                                                                    - -
                                                                    -
                                                                    -
                                                                    - -
                                                                    -
                                                                    - -
                                                                    - - - - - - - - - - - - - - -
                                                                    - - -
                                                                    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/integration/JCAAdaptor.html b/docs/integration/JCAAdaptor.html deleted file mode 100644 index a625e6e..0000000 --- a/docs/integration/JCAAdaptor.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - JCA Adaptor · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                    -
                                                                    - - - - - - - - -
                                                                    - -
                                                                    - -
                                                                    - - - - - - - - -
                                                                    -
                                                                    - -
                                                                    -
                                                                    - -
                                                                    - -

                                                                    Vert.x JCA Adaptor

                                                                    - - -
                                                                    - -
                                                                    -
                                                                    -
                                                                    - -

                                                                    results matching ""

                                                                    -
                                                                      - -
                                                                      -
                                                                      - -

                                                                      No results matching ""

                                                                      - -
                                                                      -
                                                                      -
                                                                      - -
                                                                      -
                                                                      - -
                                                                      - - - - - - - - - - - - - - -
                                                                      - - -
                                                                      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/integration/KafkaClient.html b/docs/integration/KafkaClient.html deleted file mode 100644 index 2eac5fd..0000000 --- a/docs/integration/KafkaClient.html +++ /dev/null @@ -1,1665 +0,0 @@ - - - - - - - Kafka Client · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                      -
                                                                      - - - - - - - - -
                                                                      - -
                                                                      - -
                                                                      - - - - - - - - -
                                                                      -
                                                                      - -
                                                                      -
                                                                      - -
                                                                      - -

                                                                      Vert.x Kafka Client

                                                                      - -

                                                                      中英文对照表

                                                                      - -

                                                                      组件介绍

                                                                      -

                                                                      此组件提供了 Kafka Client 的集成，可以以 Vert.x 的方式从 Apache Kafka 集群上消费或者发送消息。

                                                                      -

                                                                      对于消费者(consumer)，API以异步的方式订阅消费指定的 topic 以及相关的分区(partition)，或者将消息以 Vert.x Stream 的方式读取（甚至可以支持暂停(pause)和恢复(resume)操作）。

                                                                      -

                                                                      对于生产者(producer)，API提供发送信息到指定 topic 以及相关的分区(partition)的方法，类似于向 Vert.x Stream 中写入数据。

                                                                      -
                                                                      -

                                                                      警告：此组件处于技术预览阶段，因此在之后版本中API可能还会发生一些变更。

                                                                      -
                                                                      -

                                                                      使用 Vert.x Kafka Client

                                                                      -

                                                                      要使用 Vert.x Kafka Client 组件，需要添加以下依赖：

                                                                      -
                                                                        -
                                                                      • Maven（在 pom.xml文件中）：
                                                                        • -
                                                                      -
                                                                      <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-kafka-client</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                      -
                                                                        -
                                                                      • Gradle（在build.gradle文件中）：
                                                                        • -
                                                                      -
                                                                      compile 'io.vertx:vertx-kafka-client:3.4.1'
-
                                                                      -

                                                                      创建 Kafka Client

                                                                      -

                                                                      创建 Consumer 和 Producer 以及使用它们的方法其实与原生的 Kafka Client 库非常相似，Vert.x 只是做了一层异步封装。

                                                                      -

                                                                      我们需要对 Consumer 与 Producer 进行一些相关的配置，具体可以参考 Apache Kafka 的官方文档：

                                                                      - -

                                                                      我们可以通过一个 Map 来包装这些配置，然后将其传入到 KafkaConsumer 接口或 KafkaProducer 接口中的 create 静态方法里来创建 KafkaConsumer 或 KafkaProducer：

                                                                      -
                                                                      Map<String, String> config = new HashMap<>();
-config.put("bootstrap.servers", "localhost:9092");
-config.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
-config.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
-config.put("group.id", "my_group");
-config.put("auto.offset.reset", "earliest");
-config.put("enable.auto.commit", "false");
-
-// 创建一个Kafka Consumer
-KafkaConsumer<String, String> consumer = KafkaConsumer.create(vertx, config);
-
                                                                      -

                                                                      在上面的例子中，我们在创建 KafkaConsumer 实例时传入了一个 Map 实例，用于指定要连接的 Kafka 节点列表（只有一个）以及如何对接收到的消息进行解析以得到 key 与 value。

                                                                      -

                                                                      我们可以用类似的方法来创建 Producer：

                                                                      -
                                                                      Map<String, String> config = new HashMap<>();
-config.put("bootstrap.servers", "localhost:9092");
-config.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
-config.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
-config.put("acks", "1");
-
-// 创建一个Kafka Producer
-KafkaProducer<String, String> producer = KafkaProducer.create(vertx, config);
-
                                                                      -

                                                                      另外也可以使用 Properties 来代替 Map：

                                                                      -
                                                                      Properties config = new Properties();
-config.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
-config.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
-config.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
-config.put(ConsumerConfig.GROUP_ID_CONFIG, "my_group");
-config.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
-config.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
-
-KafkaConsumer<String, String> consumer = KafkaConsumer.create(vertx, config);
-
                                                                      -

                                                                      消息的 key 和 value 的序列化格式也可以作为 create 方法的参数直接传进去，而不是在相关配置中指定：

                                                                      -
                                                                      Properties config = new Properties();
-config.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
-config.put(ProducerConfig.ACKS_CONFIG, "1");
-
-// 注意这里的第三和第四个参数
-KafkaProducer<String, String> producer = KafkaProducer.create(vertx, config, String.class, String.class);
-
                                                                      -

                                                                      在这里，我们在创建 KafkaProducer 实例的时候传入了一个 Properties 实例，用于指定要连接的 Kafka 节点列表（只有一个）和消息确认模式。消息 key 和 value 的解析方式作为参数传入 KafkaProducer.create 方法中。

                                                                      -

                                                                      消费感兴趣 Topic 的消息并加入消费组

                                                                      -

                                                                      我们可以通过 KafkaConsumer 的的 subscribe 方法来订阅一个或多个 topic 进行消费，同时加入到某个消费组（consumer group）中（在创建消费者实例时通过配置指定）。当然你需要通过 handler 方法注册一个 Handler 来处理接收的消息：

                                                                      -
                                                                      consumer.handler(record -> {
-  System.out.println("Processing key=" + record.key() + ",value=" + record.value() +
-    ",partition=" + record.partition() + ",offset=" + record.offset());
-});
-
-// 订阅多个topic
-Set<String> topics = new HashSet<>();
-topics.add("topic1");
-topics.add("topic2");
-topics.add("topic3");
-consumer.subscribe(topics);
-
-// 订阅单个主题
-consumer.subscribe("a-single-topic");
-
                                                                      -

                                                                      另外如果想知道消息是否成功被消费掉，可以在调用 subscribe 方法时绑定一个 Handler：

                                                                      -
                                                                      consumer.handler(record -> {
-  System.out.println("Processing key=" + record.key() + ",value=" + record.value() +
-    ",partition=" + record.partition() + ",offset=" + record.offset());
-});
-
-// subscribe to several topics
-Set<String> topics = new HashSet<>();
-topics.add("topic1");
-topics.add("topic2");
-topics.add("topic3");
-
-//这里lambda表达式用于接收消息处理结果
-consumer.subscribe(topics, ar -> {
-  if (ar.succeeded()) {
-    System.out.println("subscribed");
-  } else {
-    System.out.println("Could not subscribe " + ar.cause().getMessage());
-  }
-});
-
-//这里lambda表达式用于接收消息处理结果
-consumer.subscribe("a-single-topic", ar -> {
-  if (ar.succeeded()) {
-    System.out.println("subscribed");
-  } else {
-    System.out.println("Could not subscribe " + ar.cause().getMessage());
-  }
-});
-
                                                                      -

                                                                      由于Kafka的消费者会组成一个消费组(consumer group)，同一个组只有一个消费者可以消费特定的 partition，同时此消费组也可以接纳其他的消费者，这样可以实现 partition 分配给组内其它消费者继续去消费。

                                                                      -

                                                                      如果组内的一个消费者挂了，kafka 集群会自动把 partition 重新分配给组内其他消费者，或者新加入一个消费者去消费对应的 partition。您可以通过 partitionsRevokedHandler 和 partitionsAssignedHandler 方法在 KafkaConsumer 里注册一个 Handler 用于监听对应的 partition 是否被删除或者分配。

                                                                      -
                                                                      consumer.handler(record -> {
-  System.out.println("Processing key=" + record.key() + ",value=" + record.value() +
-    ",partition=" + record.partition() + ",offset=" + record.offset());
-});
-
-// 注册一个用于侦听新分配partition的Handler
-consumer.partitionsAssignedHandler(topicPartitions -> {
-
-  System.out.println("Partitions assigned");
-  for (TopicPartition topicPartition : topicPartitions) {
-    System.out.println(topicPartition.getTopic() + " " + topicPartition.getPartition());
-  }
-});
-
-// 注册一个用于侦听撤销partition的Handler
-consumer.partitionsRevokedHandler(topicPartitions -> {
-
-  System.out.println("Partitions revoked");
-  for (TopicPartition topicPartition : topicPartitions) {
-    System.out.println(topicPartition.getTopic() + " " + topicPartition.getPartition());
-  }
-});
-
-// subscribes to the topic
-consumer.subscribe("test", ar -> {
-
-  if (ar.succeeded()) {
-    System.out.println("Consumer subscribed");
-  }
-});
-
                                                                      -

                                                                      加入某个 consumer group 的消费者，可以通过 unsubscribe 方法退出该消费组，从而不再接受到相关消息：

                                                                      -
                                                                      consumer.unsubscribe();
-
                                                                      -

                                                                      当然你也可以在 unsubscribe 方法中传入一个 Handler 用于监听执行结果状态：

                                                                      -
                                                                      consumer.unsubscribe(ar -> {
-
-  if (ar.succeeded()) {
-    System.out.println("Consumer unsubscribed");
-  }
-});
-
                                                                      -

                                                                      从 Topic 的特定分区里接收消息

                                                                      -

                                                                      消费组内的消费者可以消费某个 topic 指定的 partition。如果某个消费者并不属于任何消费组，那么整个程序就不能依赖 Kafka 的 re-balancing 机制去消费消息。

                                                                      -

                                                                      您可以通过 assign 方法请求分配指定的分区：

                                                                      -
                                                                      consumer.handler(record -> {
-  System.out.println("key=" + record.key() + ",value=" + record.value() +
-    ",partition=" + record.partition() + ",offset=" + record.offset());
-});
-
-//
-Set<TopicPartition> topicPartitions = new HashSet<>();
-topicPartitions.add(new TopicPartition()
-  .setTopic("test")
-  .setPartition(0));
-
-// 要求分配到特定的topic以及partitions
-consumer.assign(topicPartitions, done -> {
-
-  if (done.succeeded()) {
-    System.out.println("Partition assigned");
-
-    // 侦听分配结果
-    consumer.assignment(done1 -> {
-
-      if (done1.succeeded()) {
-
-        for (TopicPartition topicPartition : done1.result()) {
-          System.out.println(topicPartition.getTopic() + " " + topicPartition.getPartition());
-        }
-      }
-    });
-  }
-});
-
                                                                      -

                                                                      上面的 assignment 方法可以列出当前分配的 topic partition。

                                                                      -

                                                                      获取 Topic 以及分区信息

                                                                      -

                                                                      您可以通过 partitionsFor 方法获取指定 topic 的 partition 信息：

                                                                      -
                                                                      
-consumer.partitionsFor("test", ar -> {
-  if (ar.succeeded()) {
-    for (PartitionInfo partitionInfo : ar.result()) {
-      System.out.println(partitionInfo);
-    }
-  }
-});
-
                                                                      -

                                                                      另外，listTopics 方法可以列出消费者下的所有 topic 以及对应的 partition 信息：

                                                                      -
                                                                      consumer.listTopics(ar -> {
-
-  if (ar.succeeded()) {
-
-    Map<String, List<PartitionInfo>> map = ar.result();
-    map.forEach((topic, partitions) -> {
-      System.out.println("topic = " + topic);
-      System.out.println("partitions = " + map.get(topic));
-    });
-  }
-});
-
                                                                      -

                                                                      手动提交偏移量

                                                                      -

                                                                      在 Apache Kafka 中，消费者负责处理最新读取消息的偏移量（offset）。Consumer 会在每次从某个 topic partition 中读取一批消息的时候自动执行提交偏移量的操作。需要在创建 KafkaConsumer 时将 enable.auto.commit 配置项设为 true 来开启自动提交。

                                                                      -

                                                                      我们可以通过 commit 方法进行手动提交。手动提交偏移量通常用于确保消息分发的 at least once 语义，以确保消息没有被消费前不会执行提交。

                                                                      -
                                                                      consumer.commit(ar -> {
-
-  if (ar.succeeded()) {
-    System.out.println("Last read message offset committed");
-  }
-});
-
                                                                      -

                                                                      分区偏移量定位

                                                                      -

                                                                      Apache Kafka 中的消息是按顺序持久化在磁盘上的，所以消费者可以在某个 partition 内部进行偏移量定位(seek)操作，并从任意指定的 topic 以及 partition 位置开始消费消息。我们可以通过 seek 方法来更改读取位置对应的偏移量：

                                                                      -
                                                                      TopicPartition topicPartition = new TopicPartition()
-  .setTopic("test")
-  .setPartition(0);
-
-// 指定offset位置10
-consumer.seek(topicPartition, 10, done -> {
-
-  if (done.succeeded()) {
-    System.out.println("Seeking done");
-  }
-});
-
                                                                      -

                                                                      当消费者需要从 Stream 的起始位置读取消息时，可以使用 seekToBeginning 方法将 offset 位置设置到 partition 的起始端：

                                                                      -
                                                                      TopicPartition topicPartition = new TopicPartition()
-  .setTopic("test")
-  .setPartition(0);
-
-// 将offset挪到分区起始端
-consumer.seekToBeginning(Collections.singleton(topicPartition), done -> {
-
-  if (done.succeeded()) {
-    System.out.println("Seeking done");
-  }
-});
-
                                                                      -

                                                                      最后我们也可以通过 seekToEnd 方法将 offset 位置设置到 partition 的末端：

                                                                      -
                                                                      
-TopicPartition topicPartition = new TopicPartition()
-  .setTopic("test")
-  .setPartition(0);
-
-// 将offset挪到分区末端
-consumer.seekToEnd(Collections.singleton(topicPartition), done -> {
-
-  if (done.succeeded()) {
-    System.out.println("Seeking done");
-  }
-});
-
                                                                      -

                                                                      偏移量查询

                                                                      -

                                                                      你可以利用 Kafka 0.10.1.1 引入的新的API beginningOffsets 来获取给定分区的起始偏移量。这个跟上面的 seekToBeginning 方法有一个地方不同：beginningOffsets 方法不会更改 offset 的值，仅仅是读取（只读模式）。

                                                                      -
                                                                      Set<TopicPartition> topicPartitions = new HashSet<>();
-TopicPartition topicPartition = new TopicPartition().setTopic("test").setPartition(0);
-topicPartitions.add(topicPartition);
-
-consumer.beginningOffsets(topicPartitions, done -> {
-  if(done.succeeded()) {
-    Map<TopicPartition, Long> results = done.result();
-    results.forEach((topic, beginningOffset) ->
-      System.out.println("Beginning offset for topic="+topic.getTopic()+", partition="+
-        topic.getPartition()+", beginningOffset="+beginningOffset));
-  }
-});
-
-// partition offset 查询辅助方法
-consumer.beginningOffsets(topicPartition, done -> {
-  if(done.succeeded()) {
-    Long beginningOffset = done.result();
-      System.out.println("Beginning offset for topic="+topicPartition.getTopic()+", partition="+
-        topicPartition.getPartition()+", beginningOffset="+beginningOffset);
-  }
-});
-
                                                                      -

                                                                      与此对应的API还有 endOffsets 方法，用于获取给定分区末端的偏移量值。与 seekToEnd 方法相比，endOffsets 方法不会更改 offset 的值，仅仅是读取（只读模式）。

                                                                      -
                                                                      Set<TopicPartition> topicPartitions = new HashSet<>();
-TopicPartition topicPartition = new TopicPartition().setTopic("test").setPartition(0);
-topicPartitions.add(topicPartition);
-
-consumer.endOffsets(topicPartitions, done -> {
-  if(done.succeeded()) {
-    Map<TopicPartition, Long> results = done.result();
-    results.forEach((topic, endOffset) ->
-      System.out.println("End offset for topic="+topic.getTopic()+", partition="+
-        topic.getPartition()+", endOffset="+endOffset));
-  }
-});
-
-consumer.endOffsets(topicPartition, done -> {
-  if(done.succeeded()) {
-    Long endOffset = done.result();
-      System.out.println("End offset for topic="+topicPartition.getTopic()+", partition="+
-        topicPartition.getPartition()+", endOffset="+endOffset);
-  }
-});
-
                                                                      -

                                                                      Kafka 0.10.1.1 还提供了一个根据时间戳(timestamp)来定位 offset 的API方法 offsetsForTimes，调用此API可以返回大于等于给定时间戳的 offset。因为 Kafka 的 offset 低位就是时间戳，所以 Kafka 很容易定位此类offset。

                                                                      -
                                                                      Map<TopicPartition, Long> topicPartitionsWithTimestamps = new HashMap<>();
-TopicPartition topicPartition = new TopicPartition().setTopic("test").setPartition(0);
-
-// 我们只想要60秒之前的消息的offset
-long timestamp = (System.currentTimeMillis() - 60000);
-
-topicPartitionsWithTimestamps.put(topicPartition, timestamp);
-consumer.offsetsForTimes(topicPartitionsWithTimestamps, done -> {
-  if(done.succeeded()) {
-    Map<TopicPartition, OffsetAndTimestamp> results = done.result();
-    results.forEach((topic, offset) ->
-      System.out.println("Offset for topic="+topic.getTopic()+
-        ", partition="+topic.getPartition()+"\n"+
-        ", timestamp="+timestamp+", offset="+offset.getOffset()+
-        ", offsetTimestamp="+offset.getTimestamp()));
-
-  }
-});
-
-consumer.offsetsForTimes(topicPartition, timestamp, done -> {
-  if(done.succeeded()) {
-    OffsetAndTimestamp offsetAndTimestamp = done.result();
-      System.out.println("Offset for topic="+topicPartition.getTopic()+
-        ", partition="+topicPartition.getPartition()+"\n"+
-        ", timestamp="+timestamp+", offset="+offsetAndTimestamp.getOffset()+
-        ", offsetTimestamp="+offsetAndTimestamp.getTimestamp());
-
-  }
-});
-
                                                                      -

                                                                      流量控制

                                                                      -

                                                                      Consumer 可以对消息流进行流量控制。如果我们读到一批消息，需要花点时间进行处理则可以暂时暂停（pause）消息的流入（这里实际上是把消息全部缓存到内存里了）；等我们处理了差不多了，可以再继续消费缓存起来的消息（resume）。

                                                                      -

                                                                      我们可以利用 pause 方法和 resume 方法来进行流量控制：

                                                                      -
                                                                      TopicPartition topicPartition = new TopicPartition()
-  .setTopic("test")
-  .setPartition(0);
-
-//注册一个handler处理进来的消息
-consumer.handler(record -> {
-  System.out.println("key=" + record.key() + ",value=" + record.value() +
-    ",partition=" + record.partition() + ",offset=" + record.offset());
-
-  // 如果我们读到partition0的第5个offset
-  if ((record.partition() == 0) && (record.offset() == 5)) {
-
-    // 则暂停读取
-    consumer.pause(topicPartition, ar -> {
-
-      if (ar.succeeded()) {
-
-        System.out.println("Paused");
-
-        // 5秒后再恢复,继续读取
-        vertx.setTimer(5000, timeId -> {
-
-          // resumi read operations
-          consumer.resume(topicPartition);
-        });
-      }
-    });
-  }
-});
-
                                                                      -

                                                                      关闭 Consumer

                                                                      -

                                                                      关闭 Consumer 只需要调用 close 方法就可以了，它会自动的关闭与 Kafka 的连接，同时释放相关资源。

                                                                      -

                                                                      由于 close 方法是异步的，你并不知道关闭操作什么时候完成或失败，这时你需要注册一个处理器(Handler)来监听关闭完成的消息。当关闭操作彻底完成以后，注册的 Handler 将会被调用。

                                                                      -
                                                                      consumer.close(res -> {
-  if (res.succeeded()) {
-    System.out.println("Consumer is now closed");
-  } else {
-    System.out.println("close failed");
-  }
-});
-
                                                                      -

                                                                      发送消息到某个 Topic

                                                                      -

                                                                      您可以利用 write 方法来向某个 topic 发送消息(records)。

                                                                      -

                                                                      最简单的发送消息的方式是仅仅指定目的 topic 以及相应的值而省略消息的 key 以及分区。在这种情况下，消息会以轮询(round robin)的方式发送到对应 topic 的所有分区上。

                                                                      -
                                                                      for (int i = 0; i < 5; i++) {
-
-  // 这里指定了topic和 message value,以round robin方式发送的目标partition
-  KafkaProducerRecord<String, String> record =
-    KafkaProducerRecord.create("test", "message_" + i);
-
-  producer.write(record);
-}
-
                                                                      -

                                                                      您可以通过绑定 Handler 来接受发送的结果。这个结果其实就是一些元数据(metadata)，包含消息的 topic、目的分区 (destination partition) 以及分配的偏移量 (assigned offset)。

                                                                      -
                                                                      for (int i = 0; i < 5; i++) {
-
-  KafkaProducerRecord<String, String> record =
-    KafkaProducerRecord.create("test", "message_" + i);
-
-  producer.write(record, done -> {
-
-    if (done.succeeded()) {
-
-      RecordMetadata recordMetadata = done.result();
-      System.out.println("Message " + record.value() + " written on topic=" + recordMetadata.getTopic() +
-        ", partition=" + recordMetadata.getPartition() +
-        ", offset=" + recordMetadata.getOffset());
-    }
-
-  });
-}
-
                                                                      -

                                                                      如果希望将消息发送到指定的分区，你可以指定分区的标识(identifier)或者设定消息的 key：

                                                                      -
                                                                      for (int i = 0; i < 10; i++) {
-
-  // 这里指定了 partition 为 0
-  KafkaProducerRecord<String, String> record =
-    KafkaProducerRecord.create("test", null, "message_" + i, 0);
-
-  producer.write(record);
-}
-
                                                                      -

                                                                      因为 Producer 可以使用消息的 key 作为 hash 值来确定 partition，所以我们可以保证所有的消息被发送到同样的 partition 中，并且是有序的。

                                                                      -
                                                                      
-for (int i = 0; i < 10; i++) {
-
-  // i.e. defining different keys for odd and even messages
-  int key = i % 2;
-
-  //这里指明了key,所有的消息将被发送同一个partition.
-  KafkaProducerRecord<String, String> record =
-    KafkaProducerRecord.create("test", String.valueOf(key), "message_" + i);
-
-  producer.write(record);
-}
-
                                                                      -
                                                                      -

                                                                      注意：可共享的 Producer 通过 createShared 方法创建。它可以在多个 Verticle 实例之间共享，所以相关的配置必须在创建 Producer 的时候定义。

                                                                      -
                                                                      -

                                                                      共享 Producer

                                                                      -

                                                                      有时候您希望在多个 Verticle 或者 Vert.x Context 下共用一个 Producer。您可以通过 KafkaProducer.createShared 方法来创建可以在 Verticle 之间安全共享的 KafkaProducer 实例：

                                                                      -
                                                                      KafkaProducer<String, String> producer1 = KafkaProducer.createShared(vertx, "the-producer", config);
-
-// 关闭
-producer1.close();
-
                                                                      -

                                                                      返回的 KafkaProducer 实例将复用相关的资源（如线程、连接等）。使用完 KafkaProducer 后，直接调用 close 方法关闭即可，相关的资源会自动释放。

                                                                      -

                                                                      关闭 Producer

                                                                      -

                                                                      与关闭 Consumer 类似，关闭 Producer 只需要调用 close 方法就可以了，它会自动的关闭与 Kafka 的连接，同时释放所有相关资源。

                                                                      -

                                                                      由于 close 方法是异步的，你并不知道关闭操作什么时候完成或失败，这时你需要注册一个处理器(Handler)来监听关闭完成的消息。当关闭操作彻底完成以后，注册的 Handler 将会被调用。

                                                                      -
                                                                      producer.close(res -> {
-  if (res.succeeded()) {
-    System.out.println("Producer is now closed");
-  } else {
-    System.out.println("close failed");
-  }
-});
-
                                                                      -

                                                                      获取 Topic Partition 的相关信息

                                                                      -

                                                                      您可以通过 partitionsFor 方法获取指定 topic 的分区信息。

                                                                      -
                                                                      producer.partitionsFor("test", ar -> {
-
-  if (ar.succeeded()) {
-
-    for (PartitionInfo partitionInfo : ar.result()) {
-      System.out.println(partitionInfo);
-    }
-  }
-});
-
                                                                      -

                                                                      错误处理

                                                                      -

                                                                      您可以利用 KafkaProducer#exceptionHandler 方法和 KafkaConsumer#exceptionHandler 方法来处理 Kafka 客户端（生产者和消费者）和 Kafka 集群之间的错误（如超时）。比如：

                                                                      -
                                                                      consumer.exceptionHandler(e -> {
-  System.out.println("Error = " + e.getMessage());
-});
-
                                                                      -

                                                                      随 Verticle 自动关闭

                                                                      -

                                                                      如果您是在 Verticle 内部创建的 Consumer 和 Producer，那么当对应 Verticle 被卸载(undeploy)的时候，相关的 Consumer 和 Producer 会自动关闭。

                                                                      -

                                                                      使用 Vert.x 自带的序列化与反序列化机制

                                                                      -

                                                                      Vert.x Kafka Client 自带现成的序列化与反序列化机制，可以处理 Buffer、JsonObject 和 JsonArray 等类型。

                                                                      -

                                                                      在 KafkaConsumer 里您可以使用 Buffer：

                                                                      -
                                                                      Map<String, String> config = new HashMap<>();
-config.put("bootstrap.servers", "localhost:9092");
-config.put("key.deserializer", "io.vertx.kafka.client.serialization.BufferDeserializer");
-config.put("value.deserializer", "io.vertx.kafka.client.serialization.BufferDeserializer");
-config.put("group.id", "my_group");
-config.put("auto.offset.reset", "earliest");
-config.put("enable.auto.commit", "false");
-
-// 创建一个可以反序列化成jsonObject的consumer.
-config = new HashMap<>();
-config.put("bootstrap.servers", "localhost:9092");
-config.put("key.deserializer", "io.vertx.kafka.client.serialization.JsonObjectDeserializer");
-config.put("value.deserializer", "io.vertx.kafka.client.serialization.JsonObjectDeserializer");
-config.put("group.id", "my_group");
-config.put("auto.offset.reset", "earliest");
-config.put("enable.auto.commit", "false");
-
-// 创建一个可以反序列化成jsonArray的consumer.
-config = new HashMap<>();
-config.put("bootstrap.servers", "localhost:9092");
-config.put("key.deserializer", "io.vertx.kafka.client.serialization.JsonArrayDeserializer");
-config.put("value.deserializer", "io.vertx.kafka.client.serialization.JsonArrayDeserializer");
-config.put("group.id", "my_group");
-config.put("auto.offset.reset", "earliest");
-config.put("enable.auto.commit", "false");
-
                                                                      -

                                                                      同样在 KafkaProducer 中也可以：

                                                                      -
                                                                      Map<String, String> config = new HashMap<>();
-config.put("bootstrap.servers", "localhost:9092");
-config.put("key.serializer", "io.vertx.kafka.client.serialization.BufferSerializer");
-config.put("value.serializer", "io.vertx.kafka.client.serialization.BufferSerializer");
-config.put("acks", "1");
-
-// 创建一个可以序列化成jsonObject的Producer.
-config = new HashMap<>();
-config.put("bootstrap.servers", "localhost:9092");
-config.put("key.serializer", "io.vertx.kafka.client.serialization.JsonObjectSerializer");
-config.put("value.serializer", "io.vertx.kafka.client.serialization.JsonObjectSerializer");
-config.put("acks", "1");
-
-// 创建一个可以序列化成jsonArray的Producer.
-config = new HashMap<>();
-config.put("bootstrap.servers", "localhost:9092");
-config.put("key.serializer", "io.vertx.kafka.client.serialization.JsonArraySerializer");
-config.put("value.serializer", "io.vertx.kafka.client.serialization.JsonArraySerializer");
-config.put("acks", "1");
-
                                                                      -

                                                                      您也可以在 create 方法里指明序列化与反序列化相关的类。

                                                                      -

                                                                      比如创建 Consumer 时：

                                                                      -
                                                                      Map<String, String> config = new HashMap<>();
-config.put("bootstrap.servers", "localhost:9092");
-config.put("group.id", "my_group");
-config.put("auto.offset.reset", "earliest");
-config.put("enable.auto.commit", "false");
-
-// 创建一个可以反序列化成Buffer的Consumer
-KafkaConsumer<Buffer, Buffer> bufferConsumer = KafkaConsumer.create(vertx, config, Buffer.class, Buffer.class);
-
-// 创建一个可以反序列化成JsonObject的Consumer
-KafkaConsumer<JsonObject, JsonObject> jsonObjectConsumer = KafkaConsumer.create(vertx, config, JsonObject.class, JsonObject.class);
-
-// 创建一个可以反序列化成JsonArray的Consumer
-KafkaConsumer<JsonArray, JsonArray> jsonArrayConsumer = KafkaConsumer.create(vertx, config, JsonArray.class, JsonArray.class);
-
                                                                      -

                                                                      创建 Producer 时：

                                                                      -
                                                                      Map<String, String> config = new HashMap<>();
-config.put("bootstrap.servers", "localhost:9092");
-config.put("acks", "1");
-
-// 创建一个可以序列化成Buffer的Producer.
-KafkaProducer<Buffer, Buffer> bufferProducer = KafkaProducer.create(vertx, config, Buffer.class, Buffer.class);
-
-// 创建一个可以序列化成jsonObject的Producer.
-KafkaProducer<JsonObject, JsonObject> jsonObjectProducer = KafkaProducer.create(vertx, config, JsonObject.class, JsonObject.class);
-
-// 创建一个可以序列化成jsonArray的Producer.
-KafkaProducer<JsonArray, JsonArray> jsonArrayProducer = KafkaProducer.create(vertx, config, JsonArray.class, JsonArray.class);
-
                                                                      -

                                                                      RxJava API

                                                                      -

                                                                      Vert.x Kafka Client 组件也提供Rx风格的API。

                                                                      -
                                                                      -

                                                                      译者注：此处也可以参考 Kafka Stream 相关的 API。

                                                                      -
                                                                      -
                                                                      Observable<KafkaConsumerRecord<String, Long>> observable = consumer.toObservable();
-
-observable
-  .map(record -> record.value())
-  .buffer(256)
-  .map(
-  list -> list.stream().mapToDouble(n -> n).average()
-).subscribe(val -> {
-
-  //获取到一个平均值
-
-});
-
                                                                      -

                                                                      流实现与 Kafka 原生对象

                                                                      -

                                                                      如果您希望直接操作原生的 Kafka record，您可以使用原生的 Kafka 流式对象，它可以处理原生 Kafka 对象。

                                                                      -

                                                                      KafkaReadStream用于读取 topic partition。它是 ConsumerRecord 对象的可读流对象，读到的是 ConsumerRecord 对象。

                                                                      -

                                                                      KafkaWriteStream用于向某些 topic 中写入数据。它是 ProducerRecord 对象的可写流对象。

                                                                      -

                                                                      API通过这些接口将这些方法展现给用户，其他语言版本也应该类似。

                                                                      -
                                                                      -
                                                                      -

                                                                      原文档最后更新于 2017-03-15 15:54:14 CET

                                                                      -
                                                                      - - -
                                                                      - -
                                                                      -
                                                                      -
                                                                      - -

                                                                      results matching ""

                                                                      -
                                                                        - -
                                                                        -
                                                                        - -

                                                                        No results matching ""

                                                                        - -
                                                                        -
                                                                        -
                                                                        - -
                                                                        -
                                                                        - -
                                                                        - - - - - - - - - - -
                                                                        - - -
                                                                        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/integration/MailClient.html b/docs/integration/MailClient.html deleted file mode 100644 index 8eb0e65..0000000 --- a/docs/integration/MailClient.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - Mail Client · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                        -
                                                                        - - - - - - - - -
                                                                        - -
                                                                        - -
                                                                        - - - - - - - - -
                                                                        -
                                                                        - -
                                                                        -
                                                                        - -
                                                                        - -

                                                                        Vert.x Mail Client

                                                                        - - -
                                                                        - -
                                                                        -
                                                                        -
                                                                        - -

                                                                        results matching ""

                                                                        -
                                                                          - -
                                                                          -
                                                                          - -

                                                                          No results matching ""

                                                                          - -
                                                                          -
                                                                          -
                                                                          - -
                                                                          -
                                                                          - -
                                                                          - - - - - - - - - - - - - - -
                                                                          - - -
                                                                          - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/integration/RabbitMQClient.md b/docs/integration/RabbitMQClient.md deleted file mode 100644 index 23b8ef3..0000000 --- a/docs/integration/RabbitMQClient.md +++ /dev/null @@ -1 +0,0 @@ -# Vert.x RabbitMQ Client diff --git a/docs/integration/STOMPClient&Server.html b/docs/integration/STOMPClient&Server.html deleted file mode 100644 index 15e1696..0000000 --- a/docs/integration/STOMPClient&Server.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - STOMP Client & Server · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                          -
                                                                          - - - - - - - - -
                                                                          - -
                                                                          - -
                                                                          - - - - - - - - -
                                                                          -
                                                                          - -
                                                                          -
                                                                          - -
                                                                          - -

                                                                          Vert.x STOMP Client & Server

                                                                          - - -
                                                                          - -
                                                                          -
                                                                          -
                                                                          - -

                                                                          results matching ""

                                                                          -
                                                                            - -
                                                                            -
                                                                            - -

                                                                            No results matching ""

                                                                            - -
                                                                            -
                                                                            -
                                                                            - -
                                                                            -
                                                                            - -
                                                                            - - - - - - - - - - - - - - -
                                                                            - - -
                                                                            - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/microservices/CircuitBreaker.html b/docs/microservices/CircuitBreaker.html deleted file mode 100644 index 4d5da36..0000000 --- a/docs/microservices/CircuitBreaker.html +++ /dev/null @@ -1,1278 +0,0 @@ - - - - - - - Vert.x Circuit Breaker · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                            -
                                                                            - - - - - - - - -
                                                                            - -
                                                                            - -
                                                                            - - - - - - - - -
                                                                            -
                                                                            - -
                                                                            -
                                                                            - -
                                                                            - -

                                                                            Vert.x Circuit Breaker

                                                                            - -

                                                                            中英文对照表

                                                                            -
                                                                              -
                                                                            • Circuit Breaker：熔断器
                                                                              • -
                                                                            • metric：指标
                                                                              • -
                                                                            -

                                                                            组件介绍

                                                                            -

                                                                            Vert.x Circuit Breaker是 熔断器模式 的Vert.x实现。

                                                                            -

                                                                            熔断器用来追踪故障次数，当失败次数达到阈值时触发熔断，并且可选择性提供失败回调。

                                                                            -

                                                                            熔断器支持以下的故障：

                                                                            -
                                                                              -
                                                                            • 使用 Future 时失败
                                                                              • -
                                                                            • 运行时抛出异常
                                                                              • -
                                                                            • 没有完成的 Future(超时)
                                                                              • -
                                                                            -

                                                                            熔断器要旨是保护 Vert.x 的 非阻塞 和 异步 的行为，以便受益于Vert.x 执行模型。

                                                                            -

                                                                            使用 Vert.x 熔断器

                                                                            -

                                                                            要使用 Vert.x 熔断器，只需要在依赖中增加以下代码片段：

                                                                            -
                                                                              -
                                                                            • Maven (在 pom.xml 文件中):
                                                                              • -
                                                                            -
                                                                            <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-circuit-breaker</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                            -
                                                                              -
                                                                            • Gradle (在 build.gradle 文件中):
                                                                              • -
                                                                            -
                                                                            compile 'io.vertx:vertx-circuit-breaker:3.4.1'
-
                                                                            -

                                                                            使用熔断器

                                                                            -

                                                                            为了使用熔断器我们需要以下的步骤：

                                                                            -
                                                                              -
                                                                            • 创建一个熔断器，并配置成你所需要的(超时，最大故障次数)
                                                                              • -
                                                                            • 使用熔断器执行代码
                                                                              • -
                                                                            -

                                                                            以下是例子:

                                                                            -
                                                                            CircuitBreaker breaker = CircuitBreaker.create("my-circuit-breaker", vertx,
-    new CircuitBreakerOptions()
-        .setMaxFailures(5) // 最大故障次数
-        .setTimeout(2000) // 超时时间
-        .setFallbackOnFailure(true) // 设置是否失败回调
-        .setResetTimeout(10000) // 重置状态超时
-);
-
-breaker.execute(future -> {
-  // 在熔断器中执行的代码
-  // 这里的代码可以成功或者失败
-  // 如果future在这里被标记为失败，熔断器将自增失败数
-}).setHandler(ar -> {
-  // 处理结果
-});
-
                                                                            -

                                                                            执行块中接收 Future 作为参数，以表示操作和结果的成功或失败。 例如在下面的例子中，对应的结果就是REST调用的输出：

                                                                            -
                                                                            CircuitBreaker breaker = CircuitBreaker.create("my-circuit-breaker", vertx,
-    new CircuitBreakerOptions().setMaxFailures(5).setTimeout(2000)
-);
-
-breaker.<String>execute(future -> {
-  vertx.createHttpClient().getNow(8080, "localhost", "/", response -> {
-    if (response.statusCode() != 200) {
-      future.fail("HTTP error");
-    } else {
-      response
-          .exceptionHandler(future::fail)
-          .bodyHandler(buffer -> {
-            future.complete(buffer.toString());
-          });
-    }
-  });
-}).setHandler(ar -> {
-  // 处理结果
-});
-
                                                                            -

                                                                            操作的结果以下面的方式提供：

                                                                            -
                                                                              -
                                                                            • 调用 execute 方式返回 Future
                                                                              • -
                                                                            • 调用 executeAndReport 时作为参数提供的 Future
                                                                              • -
                                                                            -

                                                                            也可以提供一个失败时回调方法(fallback)：

                                                                            -
                                                                            CircuitBreaker breaker = CircuitBreaker.create("my-circuit-breaker", vertx,
-    new CircuitBreakerOptions().setMaxFailures(5).setTimeout(2000)
-);
-
-breaker.executeWithFallback(
-    future -> {
-      vertx.createHttpClient().getNow(8080, "localhost", "/", response -> {
-        if (response.statusCode() != 200) {
-          future.fail("HTTP error");
-        } else {
-          response
-              .exceptionHandler(future::fail)
-              .bodyHandler(buffer -> {
-                future.complete(buffer.toString());
-              });
-        }
-      });
-    }, v -> {
-      // 当熔断器熔断时将调用此处代码
-      return "Hello";
-    })
-    .setHandler(ar -> {
-      // 处理结果
-    });
-
                                                                            -

                                                                            熔断状态中都会调用失败回调（fallback），或者设置 isFallbackOnFailure，其结果是失败回调函数的输出。失败回调函数将 Throwable 对象作为参数，并返回预期类型的​​对象。

                                                                            -

                                                                            失败回调可以直接设置在 CircuitBreaker 上：

                                                                            -
                                                                            CircuitBreaker breaker = CircuitBreaker.create("my-circuit-breaker", vertx,
-    new CircuitBreakerOptions().setMaxFailures(5).setTimeout(2000)
-).fallback(v -> {
-  // 当熔断器熔断时将调用此处代码
-  return "hello";
-});
-
-breaker.execute(
-    future -> {
-      vertx.createHttpClient().getNow(8080, "localhost", "/", response -> {
-        if (response.statusCode() != 200) {
-          future.fail("HTTP error");
-        } else {
-          response
-              .exceptionHandler(future::fail)
-              .bodyHandler(buffer -> {
-                future.complete(buffer.toString());
-              });
-        }
-      });
-    });
-
                                                                            -

                                                                            可以指定熔断器在生效之前的尝试次数，使用 setMaxRetries。如果将其设置为高于0的值，则您的代码在最终失败之前进行尝试多次执行。如果代码在其中一个重试中成功，则处理程序将得到通知，并且跳过剩余的重试。此配置仅当熔断器未生效时工作。

                                                                            -

                                                                            回调

                                                                            -

                                                                            你能够配置熔断生效/关闭时回调。

                                                                            -
                                                                            CircuitBreaker breaker = CircuitBreaker.create("my-circuit-breaker", vertx,
-    new CircuitBreakerOptions().setMaxFailures(5).setTimeout(2000)
-).openHandler(v -> {
-  System.out.println("Circuit opened");
-}).closeHandler(v -> {
-  System.out.println("Circuit closed");
-});
-
-breaker.execute(
-    future -> {
-      vertx.createHttpClient().getNow(8080, "localhost", "/", response -> {
-        if (response.statusCode() != 200) {
-          future.fail("HTTP error");
-        } else {
-          // 处理结果
-          future.complete();
-        }
-      });
-    });
-
                                                                            -

                                                                            当熔断器决定尝试复位的时候（ half-open 状态），我们也可以注册 halfOpenHandler 的回调从而得到回调通知。

                                                                            -

                                                                            Event Bus 通知

                                                                            -

                                                                            每次熔断器状态发生变化时，会在Event Bus上发布事件。事件发送的地址可以使用 setNotificationAddress 进行配置。如果将 null 传递给此方法，则通知将被禁用。默认情况下，使用的地址是 vertx.circuit-breaker。 -每次事件信息包含以下：

                                                                            -
                                                                              -
                                                                            • state: 熔断器的新状态 （OPEN，CLOSED，HALF_OPEN）
                                                                              • -
                                                                            • name: 熔断器的名字
                                                                              • -
                                                                            • failures: 故障的数量
                                                                              • -
                                                                            • node: 节点的标志符（如果运行在单节点模式是 local）
                                                                              • -
                                                                            -

                                                                            半开启状态

                                                                            -

                                                                            当熔断器在熔断状态中，对其调用会立即失败，不会执行实际操作。经过适当的时间（setResetTimeout 设置），熔断器决定是否恢复状态，此时进入半开启状态（half-open state）。在这种状态下，允许下一次熔断器的调用实际调用如果成功，熔断器将复位并返回到关闭状态，回归正常的模式；但是如果这次调用失败，则熔断器返回到熔断状态，直到下次半开状态。

                                                                            -

                                                                            将熔断器指标推送到Hystrix Dashboard

                                                                            -

                                                                            Netflix Hystrix带有一个仪表板（dashboard），用于显示熔断器的当前状态。 Vert.x 熔断器可以发布其指标（metric），以供Hystrix 仪表板使用。 Hystrix 仪表板需要一个发送指标的SSE流，此流由 HystrixMetricHandler 这个 Vert.x Web Handler 提供：

                                                                            -
                                                                            CircuitBreaker breaker = CircuitBreaker.create("my-circuit-breaker", vertx);
-CircuitBreaker breaker2 = CircuitBreaker.create("my-second-circuit-breaker", vertx);
-
-// 创建 Vert.x Web 路由
-Router router = Router.router(vertx);
-// 注册指标Handler
-router.get("/hystrix-metrics").handler(HystrixMetricHandler.create(vertx));
-
-// 创建HTTP服务器，并分配路由
-vertx.createHttpServer()
-  .requestHandler(router::accept)
-  .listen(8080);
-
                                                                            -

                                                                            在Hystrix 仪表板中，配置流网址（stream url），如：http://localhost:8080/metrics。仪表板将使用Vert.x熔断器的指标。

                                                                            -

                                                                            请注意，这些指标量是由 Vert.x Web Handler 使用 Event Bus 事件通知收集的。如果您不使用默认通知地址，则需要在创建时指定。

                                                                            -

                                                                            使用 Netflix Hystrix

                                                                            -

                                                                            Hystrix提供了熔断器模式的实现。可以在Vert.x中使用Hystrix提供的熔断器或组合使用。本节介绍在Vert.x应用程序中使用Hystrix的技巧。

                                                                            -

                                                                            首先，您需要将Hystrix添加到你的依赖中。详细信息请参阅Hystrix页面。然后，您需要使用 Command 隔离“受保护的”调用。你可以这样执行它：

                                                                            -
                                                                            HystrixCommand<String> someCommand = getSomeCommandInstance();
-String result = someCommand.execute();
-
                                                                            -

                                                                            但是，命令执行是阻塞的，必须结合 executeBlocking 方法执行，或者在Worker Verticle中调用：

                                                                            -
                                                                            HystrixCommand<String> someCommand = getSomeCommandInstance();
-vertx.<String>executeBlocking(
-  future -> future.complete(someCommand.execute()),
-  ar -> {
-    // 回到Event Loop线程中
-    String result = ar.result();
-  }
-);
-
                                                                            -

                                                                            如果您使用Hystrix的异步支持，请注意，对应的回调函数不会在Vert.x线程中执行，并且必须在执行前保留对上下文的引用（使用 getOrCreateContext )，并且在回调中，执行 runOnContext 函数将当前线程切换回Event Loop线程。如果不这样做的话，您将失去Vert.x并发模型的优势，并且必须自行管理线程同步和执行顺序：

                                                                            -
                                                                            vertx.runOnContext(v -> {
-  Context context = vertx.getOrCreateContext();
-  HystrixCommand<String> command = getSomeCommandInstance();
-  command.observe().subscribe(result -> {
-    context.runOnContext(v2 -> {
-      // 回到Vert.x Context下(Event Loop线程或Worker线程)
-      String r = result;
-    });
-  });
-});
-
                                                                            -
                                                                            -
                                                                            -

                                                                            原文档最后更新于 2017-03-15 15:54:14 CET

                                                                            -
                                                                            - - -
                                                                            - -
                                                                            -
                                                                            -
                                                                            - -

                                                                            results matching ""

                                                                            -
                                                                              - -
                                                                              -
                                                                              - -

                                                                              No results matching ""

                                                                              - -
                                                                              -
                                                                              -
                                                                              - -
                                                                              -
                                                                              - -
                                                                              - - - - - - - - - - - - - - -
                                                                              - - -
                                                                              - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/microservices/Config.html b/docs/microservices/Config.html deleted file mode 100644 index a2ecf62..0000000 --- a/docs/microservices/Config.html +++ /dev/null @@ -1,1596 +0,0 @@ - - - - - - - Vert.x Config · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                              -
                                                                              - - - - - - - - -
                                                                              - -
                                                                              - -
                                                                              - - - - - - - - -
                                                                              -
                                                                              - -
                                                                              -
                                                                              - -
                                                                              - -

                                                                              Vert.x Config

                                                                              - -

                                                                              中英文对照表

                                                                              -
                                                                                -
                                                                              • Overloading：重载
                                                                                • -
                                                                              • Configuration Store：配置仓库
                                                                                • -
                                                                              -

                                                                              组件介绍

                                                                              -

                                                                              Vert.x Config 提供了一种配置 Vert.x 应用的方式。

                                                                              -

                                                                              它包含：

                                                                              -
                                                                                -
                                                                              • 支持多种配置语法（JSON、properties、YAML（扩展）、HOCON（扩展）等）
                                                                                • -
                                                                              • 支持多种存储方式（文件、目录、HTTP、Git（扩展）、Redis（扩展）、系统属性、环境变量等）
                                                                                • -
                                                                              • 支持自定义配置处理顺序和配置重载(overloading)
                                                                                • -
                                                                              • 支持运行时重新配置(runtime reconfiguration)
                                                                                • -
                                                                              -

                                                                              概念

                                                                              -

                                                                              本组件基于如下几个概念：

                                                                              -
                                                                                -
                                                                              • Config Retriever 由Vert.x 应用实例化以及使用；它配置了一系列的配置仓库
                                                                                • -
                                                                              • Configuration Store 定义了配置项的数据源和语法（默认是 JSON）
                                                                                • -
                                                                              -

                                                                              配置文件最终会以 JSON 对象(JsonObject)的形式取出。

                                                                              -

                                                                              使用 Config Retriever

                                                                              -

                                                                              要使用 Config Retriever，只需要在依赖中增加以下代码片段：

                                                                              -
                                                                                -
                                                                              • Maven (在 pom.xml 文件中):
                                                                                • -
                                                                              -
                                                                              <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-config</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                              -
                                                                                -
                                                                              • Gradle (在 build.gradle 文件中):
                                                                                • -
                                                                              -
                                                                              compile 'io.vertx:vertx-config:3.4.1'
-
                                                                              -

                                                                              一旦完成以上步骤，我们第一步所需要做的就是实例化 ConfigRetriever：

                                                                              -
                                                                              ConfigRetriever retriever = ConfigRetriever.create(vertx);
-
                                                                              -

                                                                              默认配置下，Config Retriever 会按照以下的顺序进行配置：

                                                                              -
                                                                                -
                                                                              • Vert.x Verticle 中的 config() 函数
                                                                                • -
                                                                              • 系统配置
                                                                                • -
                                                                              • 环境变量
                                                                                • -
                                                                              -

                                                                              你可以通过下列示例自定义配置：

                                                                              -
                                                                              ConfigStoreOptions httpStore = new ConfigStoreOptions()
-  .setType("http")
-  .setConfig(new JsonObject()
-    .put("host", "localhost").put("port", 8080).put("path", "/conf"));
-
-ConfigStoreOptions fileStore = new ConfigStoreOptions()
-  .setType("file")
-  .setConfig(new JsonObject().put("path", "my-config.json"));
-
-ConfigStoreOptions sysPropsStore = new ConfigStoreOptions().setType("sys");
-
-
-ConfigRetrieverOptions options = new ConfigRetrieverOptions()
-  .addStore(httpStore).addStore(fileStore).addStore(sysPropsStore);
-
-ConfigRetriever retriever = ConfigRetriever.create(vertx, options);
-
                                                                              -

                                                                              在后续章节会将更加详细的重载规则和其他可用的配置仓库设置一一展现。

                                                                              -

                                                                              一旦成功实例化 Config Retriever, 可用如下代码获取配置：

                                                                              -
                                                                              retriever.getConfig(ar -> {
-  if (ar.failed()) {
-    // Failed to retrieve the configuration
-  } else {
-    JsonObject config = ar.result();
-  }
-});
-
                                                                              -

                                                                              重载规则

                                                                              -

                                                                              明确配置仓库的顺序对于重载极为重要。对于冲突的键名，后面的配置值将替换掉之前的。举个例子，比如我们有两个配置仓库：

                                                                              -
                                                                                -
                                                                              • A 含有 {a:value, b:1}
                                                                                • -
                                                                              • B 含有 {a:value2, c:2}
                                                                                • -
                                                                              -

                                                                              如果我们配置的顺序是 (A, B)，那我们的配置结果将是：{a:value2, b:1, c:2}。
                                                                              如果我们将配置顺序颠倒为 (B, A)，我们最终得到的结果是：{a:value, b:1, c:2}。

                                                                              -

                                                                              支持的配置仓库

                                                                              -

                                                                              Vert.x Config 提供了一系列的配置存储支持和格式支持。更多的种类支持以扩展组件的形式提供，当然你也可以实现自己的扩展组件。

                                                                              -

                                                                              配置的数据结构

                                                                              -

                                                                              声明每一个数据存储源就必须要指明存储类型（type）。它可以指定格式（format），默认将使用 JSON。

                                                                              -

                                                                              一些配置仓库需要一些额外的配置项（比如路径）。我们可以通过 setConfig 方法传入一个 JsonObject 对象来进行上述的配置。

                                                                              -

                                                                              文件

                                                                              -

                                                                              此配置仓库仅仅从文件中读取配置，支持所有的格式。

                                                                              -
                                                                              ConfigStoreOptions file = new ConfigStoreOptions()
-  .setType("file")
-  .setFormat("properties")
-  .setConfig(new JsonObject().put("path", "path-to-file.properties"));
-
                                                                              -

                                                                              其中 path 参数是必须的。

                                                                              -

                                                                              JSON

                                                                              -

                                                                              JSON 配置仓库仅支持通过给定的 JSON 对象（JsonObject）进行配置。

                                                                              -
                                                                              ConfigStoreOptions json = new ConfigStoreOptions()
-  .setType("json")
-  .setConfig(new JsonObject().put("key", "value"));
-
                                                                              -

                                                                              本配置仓库仅支持 JSON 格式。

                                                                              -

                                                                              环境变量

                                                                              -

                                                                              此配置仓库将环境变量中的键值对映射成 JSON 对象传入，作为全局配置。

                                                                              -
                                                                              ConfigStoreOptions json = new ConfigStoreOptions()
-  .setType("env");
-
                                                                              -

                                                                              此配置仓库不支持 format 配置项。

                                                                              -

                                                                              系统属性

                                                                              -

                                                                              此配置仓库将系统属性中的键值对映射成 JSON 对象传入，作为全局配置。

                                                                              -
                                                                              ConfigStoreOptions json = new ConfigStoreOptions()
-  .setType("sys")
-  .setConfig(new JsonObject().put("cache", "false"));
-
                                                                              -

                                                                              此配置仓库不支持 format 配置项。

                                                                              -

                                                                              您可以对 cache 属性进行配置（默认为 true）。此配置项决定是否在初次获取系统属性时对其进行缓存，并且在后面不会重新加载。

                                                                              -

                                                                              HTTP

                                                                              -

                                                                              此配置仓库会通过给定的 HTTP 地址获得配置，可以使用任何支持的格式。

                                                                              -
                                                                              ConfigStoreOptions http = new ConfigStoreOptions()
-  .setType("http")
-  .setConfig(new JsonObject()
-    .put("host", "localhost")
-    .put("port", 8080)
-    .put("path", "/A"));
-
                                                                              -

                                                                              它会创建一个Vert.x HTTP 客户端（HttpClient）来访问配置仓库（请看下面的代码）。你也可以通过配置 host、port 和 path 这些属性来简化这个过程。

                                                                              -
                                                                              ConfigStoreOptions http = new ConfigStoreOptions()
-  .setType("http")
-  .setConfig(new JsonObject()
-    .put("defaultHost", "localhost")
-    .put("defaultPort", 8080)
-    .put("ssl", true)
-    .put("path", "/A"));
-
                                                                              -

                                                                              Event Bus

                                                                              -

                                                                              此配置仓库会从 Event Bus 中获取配置。这种方式让你可以在本地和分布式组件中分发你的配置。

                                                                              -
                                                                              ConfigStoreOptions eb = new ConfigStoreOptions()
-  .setType("event-bus")
-  .setConfig(new JsonObject()
-    .put("address", "address-getting-the-conf")
-  );
-
                                                                              -

                                                                              此配置仓库也支持所有的格式。

                                                                              -

                                                                              目录

                                                                              -

                                                                              这种配置仓库非常像 file 配置方式，但是不同的是，file 只读取一个配置文件，而这种方式会从一个目录中读取一批配置文件。

                                                                              -

                                                                              此方式有两个必要的参数：

                                                                              -
                                                                                -
                                                                              • path - 文件所在的根结点路径
                                                                                • -
                                                                              • 至少一个 fileset - 需要读取的文件列表（模式）
                                                                                • -
                                                                              -

                                                                              每一个 fileset 都包含：pattern（匹配模式），即用于选取文件的Ant风格的匹配模式。此匹配模式使用相对路径确定配置文件位置。format（格式）作为可选的参数（每一个 fileset 都可以使用不同的格式，但是在一个 fileset 内的文件必须是同一种格式）。

                                                                              -
                                                                              ConfigStoreOptions dir = new ConfigStoreOptions()
-  .setType("directory")
-  .setConfig(new JsonObject().put("path", "config")
-    .put("filesets", new JsonArray()
-      .add(new JsonObject().put("pattern", "dir/*json"))
-      .add(new JsonObject().put("pattern", "dir/*.properties")
-        .put("format", "properties"))
-    ));
-
                                                                              -

                                                                              监听配置变更

                                                                              -

                                                                              Configuration Retriever 会定期地从配置仓库处读取配置。如果读取的结果和当前的配置不一样，那么应用就会重新进行配置，默认情况下，配置的刷新时间是 5 秒钟。

                                                                              -
                                                                              ConfigRetrieverOptions options = new ConfigRetrieverOptions()
-  .setScanPeriod(2000)
-  .addStore(store1)
-  .addStore(store2);
-
-ConfigRetriever retriever = ConfigRetriever.create(Vertx.vertx(), options);
-retriever.getConfig(json -> {
-  // Initial retrieval of the configuration
-});
-
-retriever.listen(change -> {
-  // Previous configuration
-  JsonObject previous = change.getPreviousConfiguration();
-  // New configuration
-  JsonObject conf = change.getNewConfiguration();
-});
-
                                                                              -

                                                                              检索最近一次获取的配置内容

                                                                              -

                                                                              可以快速、无需“等待”地获得最近一次获取的配置内容：

                                                                              -
                                                                              JsonObject last = retriever.getCachedConfig();
-
                                                                              -

                                                                              使用流的方式读取配置

                                                                              -

                                                                              ConfigRetriever 提供流(Stream)的方式去获取配置。对应的流是 JsonObject 类型的可读流(ReadStream)。你可以注册相应的处理器(Handler)，来获得下面的事件通知：

                                                                              -
                                                                                -
                                                                              • 检索到新的配置
                                                                                • -
                                                                              • 获取新配置时发生错误
                                                                                • -
                                                                              • 当 ConfigRetriever 关闭时（endHandler 方法会被调用）
                                                                                • -
                                                                              -
                                                                              ConfigRetrieverOptions options = new ConfigRetrieverOptions()
-  .setScanPeriod(2000)
-  .addStore(store1)
-  .addStore(store2);
-
-ConfigRetriever retriever = ConfigRetriever.create(Vertx.vertx(), options);
-retriever.configStream()
-  .endHandler(v -> {
-    // 关闭时
-  })
-  .exceptionHandler(t -> {
-    // 获取配置发生错误
-  })
-  .handler(conf -> {
-    // 配置内容
-  });
-
                                                                              -

                                                                              使用 Future 方式读取配置

                                                                              -

                                                                              ConfigRetriever 也支持采用 Future 作为返回值的方式获取配置：

                                                                              -
                                                                              Future<JsonObject> future = ConfigRetriever.getConfigAsFuture(retriever);
-future.setHandler(ar -> {
-  if (ar.failed()) {
-    // Failed to retrieve the configuration
-  } else {
-    JsonObject config = ar.result();
-  }
-});
-
                                                                              -

                                                                              扩展 Config Retriever

                                                                              -

                                                                              你可以通过以下SPI对其进行扩展：

                                                                              - -

                                                                              额外的配置格式

                                                                              -

                                                                              除了上文所提到的一系列现成的格式支持以外，Vert.x Config 也提供额外的格式支持组件，并可以在你的应用中使用。

                                                                              -

                                                                              HOCON 配置格式

                                                                              -

                                                                              HOCON 配置格式组件是对 Vert.x Config 的扩展，并且提供 HOCON) 格式的支持。

                                                                              -

                                                                              此格式支持 includes, json, properties, macros等。

                                                                              -

                                                                              使用 HOCON 配置格式

                                                                              -

                                                                              为了使用 HOCON 配置格式，您需要添加以下依赖：

                                                                              -
                                                                                -
                                                                              • Maven (在 pom.xml 文件中):
                                                                                • -
                                                                              -
                                                                              <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-config-hocon</artifactId>
-  <version>3.4.1</version>
-</dependency>
-<dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-config</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                              -
                                                                                -
                                                                              • Gradle (在 build.gradle 文件中):
                                                                                • -
                                                                              -
                                                                              compile 'io.vertx:vertx-config:3.4.1'
-compile 'io.vertx:vertx-config-hocon:3.4.1'
-
                                                                              -

                                                                              配置使用 HOCON 格式

                                                                              -

                                                                              一旦添加完依赖，我们就需要配置 ConfigRetriever 来使用此格式：

                                                                              -
                                                                              ConfigStoreOptions store = new ConfigStoreOptions()
-  .setType("file")
-  .setFormat("hocon")
-  .setConfig(new JsonObject()
-    .put("path", "my-config.conf")
-  );
-
-ConfigRetriever retriever = ConfigRetriever.create(vertx,
-    new ConfigRetrieverOptions().addStore(store));
-
                                                                              -

                                                                              你仅仅需要将 format 设置为 hocon。

                                                                              -

                                                                              YAML 配置格式

                                                                              -

                                                                              YAML 配置格式组件是对 Vert.x Config 的扩展，并且提供 YAML 格式的支持。

                                                                              -

                                                                              使用 YAML 配置格式

                                                                              -

                                                                              为了使用 YAML 配置格式，您需要添加以下依赖：

                                                                              -
                                                                                -
                                                                              • Maven (在 pom.xml 文件中):
                                                                                • -
                                                                              -
                                                                              <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-config-yaml</artifactId>
-  <version>3.4.1</version>
-</dependency>
-<dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-config</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                              -
                                                                                -
                                                                              • Gradle (在 build.gradle 文件中):
                                                                                • -
                                                                              -
                                                                              compile 'io.vertx:vertx-config:3.4.1'
-compile 'io.vertx:vertx-config-yaml:3.4.1'
-
                                                                              -

                                                                              配置使用 YAML 格式

                                                                              -

                                                                              一旦添加完依赖，我们就需要配置 ConfigRetriever 来使用此格式：

                                                                              -
                                                                              ConfigStoreOptions store = new ConfigStoreOptions()
-  .setType("file")
-  .setFormat("yaml")
-  .setConfig(new JsonObject()
-    .put("path", "my-config.yaml")
-  );
-
-ConfigRetriever retriever = ConfigRetriever.create(vertx,
-    new ConfigRetrieverOptions().addStore(store));
-
                                                                              -

                                                                              你仅仅需要将 format 设置为 yaml。

                                                                              -

                                                                              额外的配置仓库

                                                                              -

                                                                              除了上文所提到的一系列现成的配置仓库支持以外，Vert.x Config 也提供额外的配置仓库支持，并可以在你的应用中使用。

                                                                              -

                                                                              Git 配置仓库

                                                                              -

                                                                              Git 配置仓库组件是对 Vert.x Config 的扩展，支持从 Git 仓库(repository)中获取配置。

                                                                              -

                                                                              使用 Git 配置仓库

                                                                              -

                                                                              为了使用 Git 配置仓库，您需要添加以下依赖：

                                                                              -
                                                                                -
                                                                              • Maven (在 pom.xml 文件中):
                                                                                • -
                                                                              -
                                                                              <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-config-git</artifactId>
-  <version>3.4.1</version>
-</dependency>
-<dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-config</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                              -
                                                                                -
                                                                              • Gradle (在 build.gradle 文件中):
                                                                                • -
                                                                              -
                                                                              compile 'io.vertx:vertx-config:3.4.1'
-compile 'io.vertx:vertx-config-git:3.4.1'
-
                                                                              -

                                                                              对配置仓库进行配置

                                                                              -

                                                                              一旦添加完依赖，我们就需要配置 ConfigRetriever 来使用此配置仓库：

                                                                              -
                                                                              ConfigStoreOptions git = new ConfigStoreOptions()
-    .setType("git")
-    .setConfig(new JsonObject()
-        .put("url", "https://github.com/cescoffier/vertx-config-test.git")
-        .put("path", "local")
-        .put("filesets",
-            new JsonArray().add(new JsonObject().put("pattern", "*.json"))));
-
-ConfigRetriever retriever = ConfigRetriever.create(vertx,
-    new ConfigRetrieverOptions().addStore(git));
-
                                                                              -

                                                                              此配置仓库需要以下几个参数：

                                                                              -
                                                                                -
                                                                              • 仓库(Git repository)的 url（地址）
                                                                                • -
                                                                              • 仓库克隆的 path（本地路径）
                                                                                • -
                                                                              • 至少一个 fileset —— 需要读取的文件列表（模式）（等同于目录配置仓库的配置方式）
                                                                                • -
                                                                              -

                                                                              你也可以配置 branch(分支，默认为 master)，并且可以指定 remote（远程）仓库名称（默认读取 origin）

                                                                              -

                                                                              它是如何工作的

                                                                              -

                                                                              如果本地 path 不存在，那首先将配置的 Git 仓库克隆下来，然后从中读取匹配的文件集合。

                                                                              -

                                                                              如果本地 path 存在，那首先尝试更新（如果需要切换分支就切换分支）。如果更新失败，那配置读取也会失败。

                                                                              -

                                                                              Vert.x Config会周期性的去检查变更并更新本地仓库。

                                                                              -

                                                                              Kubernetes ConfigMap 配置仓库

                                                                              -

                                                                              Kubernetes ConfigMap 配置仓库组件是对 Vert.x Config 的扩展。它提供了对 Kubernetes ConfigMap 和 Secrets 的支持。

                                                                              -

                                                                              使用 Kubernetes ConfigMap 配置仓库

                                                                              -

                                                                              为了使用 Kubernetes ConfigMap 配置仓库，您需要添加以下依赖：

                                                                              -
                                                                                -
                                                                              • Maven (在 pom.xml 文件中):
                                                                                • -
                                                                              -
                                                                              <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-config-kubernetes-configmap</artifactId>
-  <version>3.4.1</version>
-</dependency>
-<dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-config</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                              -
                                                                                -
                                                                              • Gradle (在 build.gradle 文件中):
                                                                                • -
                                                                              -
                                                                              compile 'io.vertx:vertx-config:3.4.1'
-compile 'io.vertx:vertx-config-kubernetes-configmap:3.4.1'
-
                                                                              -

                                                                              对配置仓库进行配置

                                                                              -

                                                                              一旦添加完依赖，我们需要配置 ConfigRetriever 来使用此配置仓库：

                                                                              -
                                                                              ConfigStoreOptions store = new ConfigStoreOptions()
-    .setType("configmap")
-    .setConfig(new JsonObject()
-        .put("namespace", "my-project-namespace")
-        .put("name", "configmap-name")
-    );
-
-ConfigRetriever retriever = ConfigRetriever.create(vertx,
-    new ConfigRetrieverOptions().addStore(store));
-
                                                                              -

                                                                              你需要对配置仓库进行配置，来找到正确的 ConfigMap：

                                                                              -
                                                                                -
                                                                              • namespace —— 项目的命名空间，默认是 default。如果环境变量中有 KUBERNETES_NAMESPACE，则会优先使用此值
                                                                                • -
                                                                              • name —— ConfigMap 的名称。
                                                                                • -
                                                                              -

                                                                              如果 ConfigMap 由多个元素部分构成，你可以使用 key 参数确定哪一个才是我们要读取的。另外，应用必须要拥有对 ConfigMap 的读权限。

                                                                              -

                                                                              为了从 Secret 中读取数据，必须设置 secret 属性为 true：

                                                                              -
                                                                              ConfigStoreOptions store = new ConfigStoreOptions()
-    .setType("configmap")
-    .setConfig(new JsonObject()
-        .put("namespace", "my-project-namespace")
-        .put("name", "my-secret")
-        .put("secret", true)
-    );
-
-ConfigRetriever retriever = ConfigRetriever.create(vertx,
-    new ConfigRetrieverOptions().addStore(store));
-
                                                                              -

                                                                              Redis 配置仓库

                                                                              -

                                                                              Redis 配置仓库组件是对 Vert.x Config 的扩展，支持从 Redis 服务器中获取配置。

                                                                              -

                                                                              使用 Redis 配置仓库

                                                                              -

                                                                              为了使用 Redis 配置仓库，您需要添加以下依赖：

                                                                              -
                                                                                -
                                                                              • Maven (在 pom.xml 文件中):
                                                                                • -
                                                                              -
                                                                              <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-config-redis</artifactId>
-  <version>3.4.1</version>
-</dependency>
-<dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-config</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                              -
                                                                                -
                                                                              • Gradle (在 build.gradle 文件中):
                                                                                • -
                                                                              -
                                                                              compile 'io.vertx:vertx-config:3.4.1'
-compile 'io.vertx:vertx-config-redis:3.4.1'
-
                                                                              -

                                                                              对配置仓库进行配置

                                                                              -

                                                                              一旦添加完依赖，我们需要配置 ConfigRetriever 来使用此配置仓库：

                                                                              -
                                                                              ConfigStoreOptions store = new ConfigStoreOptions()
-    .setType("redis")
-    .setConfig(new JsonObject()
-        .put("host", "localhost")
-        .put("port", 6379)
-        .put("key", "my-configuration")
-    );
-
-ConfigRetriever retriever = ConfigRetriever.create(vertx,
-    new ConfigRetrieverOptions().addStore(store));
-
                                                                              -

                                                                              此配置仓库会创建一个 RedisClient 实例。关于此部分的配置可以参考 Vert.x Redis Client 文档。

                                                                              -

                                                                              除此之外，你可以设置 key 参数用来指示存储配置对应的 field（字段），默认值是 configuration。

                                                                              -

                                                                              最终创建的 RedisClient 实例将通过 HGETALL 命令来检索配置。

                                                                              -

                                                                              ZooKeeper 配置仓库

                                                                              -

                                                                              ZooKeeper 配置仓库组件是对 Vert.x Config 的扩展，支持从 ZooKeeper 服务器中获得配置。

                                                                              -

                                                                              此组件底层使用 Apache Curator 作为访问 ZooKeeper 的客户端。

                                                                              -

                                                                              使用 ZooKeeper 配置仓库

                                                                              -

                                                                              为了使用 ZooKeeper 配置仓库，您需要添加以下依赖：

                                                                              -
                                                                                -
                                                                              • Maven (在 pom.xml 文件中):
                                                                                • -
                                                                              -
                                                                              <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-config-zookeeper</artifactId>
-  <version>3.4.1</version>
-</dependency>
-<dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-config</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                              -
                                                                                -
                                                                              • Gradle (在 build.gradle 文件中):
                                                                                • -
                                                                              -
                                                                              compile 'io.vertx:vertx-config:3.4.1'
-compile 'io.vertx:vertx-config-zookeeper:3.4.1'
-
                                                                              -

                                                                              对配置仓库进行配置

                                                                              -

                                                                              一旦添加完依赖，我们需要配置 ConfigRetriever 来使用此配置仓库：

                                                                              -
                                                                              ConfigStoreOptions store = new ConfigStoreOptions()
-    .setType("zookeeper")
-    .setConfig(new JsonObject()
-        .put("connection", "localhost:2181")
-        .put("path", "/path/to/my/conf")
-    );
-
-ConfigRetriever retriever = ConfigRetriever.create(vertx,
-    new ConfigRetrieverOptions().addStore(store));
-
                                                                              -

                                                                              使用此配置仓库通常需要配置 Apache Curator 客户端以及存储我们配置内容的 ZNode 路径（path）。此节点的数据格式可以是 JSON 或者其它任意支持的类型。

                                                                              -

                                                                              此配置仓库需要传入一系列参数：configuration 属性包含连接 ZooKeeper 服务器的地址和包含我们所配置的节点 path 路径。

                                                                              -

                                                                              额外可以配置的有：

                                                                              -
                                                                                -
                                                                              • maxRetries：尝试重新连接的次数，默认是 3
                                                                                • -
                                                                              • baseSleepTimeBetweenRetries： 在每一次重新尝试连接的间隔（Exponential Backoff 策略），默认是 1000 ms
                                                                                • -
                                                                              -

                                                                              Spring Config Server 配置仓库

                                                                              -

                                                                              Spring Config Server 配置仓库组件是对 Vert.x Config 的扩展，支持从 Spring Config Server 中获得配置。

                                                                              -

                                                                              使用 Spring Config Server 配置仓库

                                                                              -

                                                                              为了使用 Spring Config Server 配置仓库，您需要添加以下依赖：

                                                                              -
                                                                                -
                                                                              • Maven (在 pom.xml 文件中):
                                                                                • -
                                                                              -
                                                                              <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-config-spring-config-server</artifactId>
-  <version>3.4.1</version>
-</dependency>
-<dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-config</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                              -
                                                                                -
                                                                              • Gradle (在 build.gradle 文件中):
                                                                                • -
                                                                              -
                                                                              compile 'io.vertx:vertx-config:3.4.1'
-compile 'io.vertx:vertx-config-spring-config-server:3.4.1'
-
                                                                              -

                                                                              对配置仓库进行配置

                                                                              -

                                                                              一旦添加完依赖，我们需要配置 ConfigRetriever 来使用此配置仓库。

                                                                              -
                                                                              ConfigStoreOptions store = new ConfigStoreOptions()
-    .setType("spring-config-server")
-    .setConfig(new JsonObject().put("url", "http://localhost:8888/foo/development"));
-
-ConfigRetriever retriever = ConfigRetriever.create(vertx,
-    new ConfigRetrieverOptions().addStore(store));
-
                                                                              -

                                                                              以下的参数可供配置：

                                                                              -
                                                                                -
                                                                              • url: 读取配置的 url（必填）
                                                                                • -
                                                                              • timeout: 读取配置的超时时间，单位是毫秒，默认为 3000 ms
                                                                                • -
                                                                              • user: 用户（默认无权限）
                                                                                • -
                                                                              • password: 密码
                                                                                • -
                                                                              • httpClientConfiguration: 底层所使用的 HTTP 客户端的配置
                                                                                • -
                                                                              -
                                                                              -
                                                                              -

                                                                              原文档最后更新于 2017-03-15 15:54:14 CET

                                                                              -
                                                                              - - -
                                                                              - -
                                                                              -
                                                                              -
                                                                              - -

                                                                              results matching ""

                                                                              -
                                                                                - -
                                                                                -
                                                                                - -

                                                                                No results matching ""

                                                                                - -
                                                                                -
                                                                                -
                                                                                - -
                                                                                -
                                                                                - -
                                                                                - - - - - - - - - - - - - - -
                                                                                - - -
                                                                                - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/microservices/ServiceDiscovery.html b/docs/microservices/ServiceDiscovery.html deleted file mode 100644 index a49128a..0000000 --- a/docs/microservices/ServiceDiscovery.html +++ /dev/null @@ -1,1904 +0,0 @@ - - - - - - - Vert.x Service Discovery · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                -
                                                                                - - - - - - - - -
                                                                                - -
                                                                                - -
                                                                                - - - - - - - - -
                                                                                -
                                                                                - -
                                                                                -
                                                                                - -
                                                                                - -

                                                                                Vert.x Service Discovery

                                                                                - -

                                                                                组件介绍

                                                                                -

                                                                                Vert.x 提供了一个服务发现的基础组件，用来发布和发现各种类型的资源，比如服务代理、HTTP端点（endpoint）、数据源（data source）等等。

                                                                                -

                                                                                这些资源都可以称为服务。服务就是一个可以被发现和访问的功能，可以通过它的类型、元数据和位置来进行描述。所以，服务可以是一个数据库、一个服务代理、一个HTTP应用，以及任何你能想到的可描述、可发现、可交互的资源。它不一定是Vert.x实体，它可以是任何组件。在Vert.x 服务发现组件中，我们通过 Record 来描述每个服务。

                                                                                -

                                                                                服务发现组件实现了面向服务计算中定义的服务交互。此外，在某种程度上，还提供了动态的面向服务计算交互，这样应用程序可以对各种服务的上线、下线作出反应。

                                                                                -

                                                                                一个服务提供者可以：

                                                                                -
                                                                                  -
                                                                                • 发布一个服务记录
                                                                                  • -
                                                                                • 将已经发布的服务记录注销
                                                                                  • -
                                                                                • 更新已发布服务记录的状态（下线、服务暂停等等）
                                                                                  • -
                                                                                -

                                                                                一个服务消费者可以：

                                                                                -
                                                                                  -
                                                                                • 查找各种服务
                                                                                  • -
                                                                                • 绑定到某个服务（它所获取到的 ServiceReference）并且使用这个服务
                                                                                  • -
                                                                                • 当使用完后，释放绑定的服务
                                                                                  • -
                                                                                • 监听服务的上线、下线和状态变更的消息
                                                                                  • -
                                                                                -

                                                                                服务消费者访问服务的步骤：

                                                                                -
                                                                                  -
                                                                                1. 查找满足它需求的服务记录
                                                                                  2. -
                                                                                2. 取得可访问的 ServiceReference
                                                                                  3. -
                                                                                3. 通过服务对象来访问服务
                                                                                  4. -
                                                                                4. 一旦使用完后释放服务对象
                                                                                  5. -
                                                                                -

                                                                                如果知道服务的类型（JDBC客户端、HTTP客户端），整个过程就可以简化为通过服务类型直接获取服务对象。

                                                                                -

                                                                                从上面可以看出，服务提供者和服务消费者，通过服务记录来共享关键的信息。

                                                                                -

                                                                                服务提供者和消费者，必须创建他们自己的 ServiceDiscovery 实例。这些实例通过底层的分布式数据结构来协同保持服务集合的同步。

                                                                                -

                                                                                服务发现组件支持桥接的方式，来从其他服务发现技术中导入和导出服务。

                                                                                -

                                                                                使用Service Discovery

                                                                                -

                                                                                要使用Vert.x 服务发现组件，需要将下列依赖加入到依赖配置中文件：

                                                                                -
                                                                                  -
                                                                                • Maven (pom.xml文件中)：
                                                                                  • -
                                                                                -
                                                                                <dependency>
-   <groupId>io.vertx</groupId>
-   <artifactId>vertx-service-discovery</artifactId>
-   <version>3.4.1</version>
-</dependency>
-
                                                                                -
                                                                                  -
                                                                                • Gradle (build.gradle 文件中)：
                                                                                  • -
                                                                                -
                                                                                compile 'io.vertx:vertx-service-discovery:3.4.1'
-
                                                                                -

                                                                                基本概念

                                                                                -

                                                                                本节将解释服务发现机制所涉及到的一些概念。

                                                                                -

                                                                                服务记录

                                                                                -

                                                                                我们用服务记录 （Record 对象）来描述服务提供者提供的服务，它包含了服务名称、一些元数据和一个描述服务所在位置的位置对象。

                                                                                -

                                                                                服务记录的元数据、甚至位置的格式，都有赖于服务的类型（详见后续章节）。

                                                                                -

                                                                                当服务提供者准备好可以提供服务时，会发布一条服务记录，在服务停止的时候，会收回这条服务记录。

                                                                                -

                                                                                服务提供者和发布者

                                                                                -

                                                                                服务提供者是提供服务的实体，而发布者的职责是发布服务记录，通过该服务记录来描述服务提供者的信息。服务提供者和发布者可以是同一个实体，也可以是不同的实体。

                                                                                -

                                                                                服务消费者

                                                                                -

                                                                                服务消费者在Service Discovery中搜索服务，每次搜索得到的结果是0..n条服务记录（Record）。通过这些服务记录，消费者可以获得服务引用（ServiceReference）。服务引用的作用是绑定服务消费者和服务提供者。通过服务引用，消费者可以得到服务对象来使用服务，也可以通过服务引用释放服务对象。

                                                                                -

                                                                                在使用完服务后，必须释放服务引用，才能清理服务对象和更新服务使用状态。

                                                                                -

                                                                                服务对象

                                                                                -

                                                                                服务对象为服务消费者提供了一条获取服务的通道，它有各种实现方式，比如一个代理对象、一个客户端对象、甚至某些类型的服务可能不存在这样一个服务对象。服务对象的表现有赖于服务的类型。

                                                                                -

                                                                                由于Vert.x的多语言特性，当你从Java、Groovy或其他语言中获取服务对象的时候，可能会有差异。

                                                                                -

                                                                                服务类型

                                                                                -

                                                                                服务就是资源。有很多各种各样的服务，比如功能性的服务组件、数据库、REST API等等。Vert.x 服务发现组件通过服务类型的概念来处理这种差异。每种服务类型都需要定义：

                                                                                -
                                                                                  -
                                                                                • 如何定位服务（URI、Event Bus地址、IP/DNS 等） - location
                                                                                  • -
                                                                                • 提供服务的对象的性质（服务代理、HTTP Client、消息消费者 等） - client
                                                                                  • -
                                                                                -

                                                                                服务发现组件提供了一些现成的服务类型，但你也可以添加自己的服务类型。

                                                                                -

                                                                                服务事件

                                                                                -

                                                                                每当发布或回收服务时，Event Bus中都会触发一个事件，这个事件包含着被修改的服务记录。

                                                                                -

                                                                                每当通过 getReference 方法获取一个服务引用或者通过 release 方法释放一个服务引用时，都会有事件发送到 Event Bus 中，用来跟踪服务的使用情况。

                                                                                -

                                                                                关于服务事件的更详细内容参考后续章节。

                                                                                -

                                                                                服务存储后端

                                                                                -

                                                                                服务发现组件使用Vert.x的分布式数据结构来存储服务记录。所以，集群中所有的成员都可以访问到所有的服务记录，这是服务后端的默认实现。你也可以实现自己的服务记录存储后端，只要实现 ServiceDiscoveryBackend 接口就可以了。比如，Vert.x还通过实现该接口提供了基于Redis的存储后端。

                                                                                -

                                                                                注意服务发现模块并不需要运行在Vert.x 集群模式下。在单机模式下，服务记录存储于本地，并且可以通过 ServiceImporter 来导入。

                                                                                -

                                                                                创建Service Discovery实例

                                                                                -

                                                                                服务发布者和服务消费者都必须通过单独创建自己的 ServiceDiscovery 实例来使用服务发现模块：

                                                                                -
                                                                                ServiceDiscovery discovery = ServiceDiscovery.create(vertx);
-
-// 自定义配置
-discovery = ServiceDiscovery.create(vertx,
-      new ServiceDiscoveryOptions()
-         .setAnnounceAddress("service-announce")
-         .setName("my-name"));
-
-// 做一些事情。。。
-
-discovery.close();
-
                                                                                -

                                                                                在默认情况下，服务事件发送到Event Bus中的地址是 vertx.discovery.announce，你可以自己配置一个（查看服务使用章节）。

                                                                                -

                                                                                当你不再需要 ServiceDiscovery 对象时，不要忘记关掉它（通过 close 方法）。它会把你配置的不同的服务导入/导出模块都关掉，并且释放服务引用。

                                                                                -

                                                                                发布服务

                                                                                -

                                                                                有了 ServiceDiscovery 实例，就可以发布服务了。发布的流程如下：

                                                                                -
                                                                                  -
                                                                                1. 为服务提供者创建一个服务记录
                                                                                  2. -
                                                                                2. 发布这个服务记录
                                                                                  3. -
                                                                                3. 保存这个发布记录的引用，后面可以用来取消发布或者修改发布
                                                                                  4. -
                                                                                -

                                                                                你可以通过 Record 类或者各种服务类型类提供的快捷方法来创建服务记录。

                                                                                -
                                                                                Record record = new Record()
-    .setType("eventbus-service-proxy")
-    .setLocation(new JsonObject().put("endpoint", "the-service-address"))
-    .setName("my-service")
-    .setMetadata(new JsonObject().put("some-label", "some-value"));
-
-discovery.publish(record, ar -> {
-  if (ar.succeeded()) {
-    // publication succeeded
-    Record publishedRecord = ar.result();
-  } else {
-    // publication failed
-  }
-});
-
-// Record creation from a type
-record = HttpEndpoint.createRecord("some-rest-api", "localhost", 8080, "/api");
-discovery.publish(record, ar -> {
-  if (ar.succeeded()) {
-    // publication succeeded
-    Record publishedRecord = ar.result();
-  } else {
-    // publication failed
-  }
-});
-
                                                                                -

                                                                                一定要保持一个指向服务记录对象的引用，因为这个返回的服务记录会带有一个 注册ID。

                                                                                -

                                                                                取消发布的服务

                                                                                -

                                                                                要取消一个已发布的服务，可以用如下方式：

                                                                                -
                                                                                discovery.unpublish(record.getRegistration(), ar -> {
-  if (ar.succeeded()) {
-    // Ok
-  } else {
-    // cannot un-publish the service, may have already been removed, or the record is not published
-  }
-});
-
                                                                                -

                                                                                查找服务

                                                                                -

                                                                                本节讲述的是最基本的获取服务的方法。每种服务类型接口，都提供了快捷的方法，来简化获取服务的步骤。

                                                                                -

                                                                                在服务消费端，第一步要做的事情就是查找服务记录。你可以查找并获取一条服务记录，也可以获取一批满足条件的记录。如果是获取一条记录，那么将返回第一条满足条件的服务记录。

                                                                                -

                                                                                服务消费者通过传递一个过滤器来选择服务，有两种形式的过滤器：

                                                                                -
                                                                                  -
                                                                                1. 一个接收 Record 对象的函数，这个函数返回一个布尔值（就是一个 predicate，即判断函数）
                                                                                  2. -
                                                                                2. 过滤器是一个JSON对象。对象中的每个条目，将会用来过滤服务记录。服务记录必须满足所有的条目要求。这些条目可以使用 * 号来代表必须存在某个key值，而不管value值
                                                                                  3. -
                                                                                -

                                                                                让我们看一些JSON过滤器的例子

                                                                                -
                                                                                { "name" = "a" } => 匹配所有名称为"a"的记录
-{ "color" = "*" } => 匹配所有设置了 "color" 的记录
-{ "color" = "red" } => 匹配所有"color" 值为 "red"的记录
-{ "color" = "red", "name" = "a"} => 匹配所有名称为 "a", 并且"color"值为"red"的记录
-
                                                                                -

                                                                                如果JSON过滤器未设置（为空或null），获取时将获取到所有的服务记录。当使用函数形式时，要获取所有的服务记录，你只需要返回 true 而不需要管服务记录的内容。

                                                                                -

                                                                                下面是一些例子：

                                                                                -
                                                                                discovery.getRecord(r -> true, ar -> {
-  if (ar.succeeded()) {
-    if (ar.result() != null) {
-      // we have a record
-    } else {
-      // the lookup succeeded, but no matching service
-    }
-  } else {
-    // lookup failed
-  }
-});
-
-discovery.getRecord((JsonObject) null, ar -> {
-  if (ar.succeeded()) {
-    if (ar.result() != null) {
-      // we have a record
-    } else {
-      // the lookup succeeded, but no matching service
-    }
-  } else {
-    // lookup failed
-  }
-});
-
-
-// Get a record by name
-discovery.getRecord(r -> r.getName().equals("some-name"), ar -> {
-  if (ar.succeeded()) {
-    if (ar.result() != null) {
-      // we have a record
-    } else {
-      // the lookup succeeded, but no matching service
-    }
-  } else {
-    // lookup failed
-  }
-});
-
-discovery.getRecord(new JsonObject().put("name", "some-service"), ar -> {
-  if (ar.succeeded()) {
-    if (ar.result() != null) {
-      // we have a record
-    } else {
-      // the lookup succeeded, but no matching service
-    }
-  } else {
-    // lookup failed
-  }
-});
-
-// Get all records matching the filter
-discovery.getRecords(r -> "some-value".equals(r.getMetadata().getString("some-label")), ar -> {
-  if (ar.succeeded()) {
-    List<Record> results = ar.result();
-    // If the list is not empty, we have matching record
-    // Else, the lookup succeeded, but no matching service
-  } else {
-    // lookup failed
-  }
-});
-
-
-discovery.getRecords(new JsonObject().put("some-label", "some-value"), ar -> {
-  if (ar.succeeded()) {
-    List<Record> results = ar.result();
-    // If the list is not empty, we have matching record
-    // Else, the lookup succeeded, but no matching service
-  } else {
-    // lookup failed
-  }
-});
-
                                                                                -

                                                                                你可以获取一条服务记录，也可以通过 getRecords 方法获取所有匹配到的服务记录。默认情况下，服务查找只会包含状态为UP的服务，可以通过如下方式覆盖默认设置：

                                                                                -
                                                                                  -
                                                                                • 当使用JSON过滤器，设置status属性为你想要的值（或者 * 来接收所有的状态）
                                                                                  • -
                                                                                • 当使用函数过滤器，将 getRecords 方法的参数includeOutOfService设置为true
                                                                                  • -
                                                                                -

                                                                                获取服务引用

                                                                                -

                                                                                当你选择好了服务记录后，你就可以获得到一个ServiceReference，然后得到服务对象：

                                                                                -
                                                                                ServiceReference reference1 = discovery.getReference(record1);
-ServiceReference reference2 = discovery.getReference(record2);
-
-// Then, gets the service object, the returned type depends on the service type:
-// For http endpoint:
-HttpClient client = reference1.getAs(HttpClient.class);
-// For message source
-MessageConsumer consumer = reference2.getAs(MessageConsumer.class);
-
-// When done with the service
-reference1.release();
-reference2.release();
-
                                                                                -

                                                                                使用完后，不要忘记释放服务引用。

                                                                                -

                                                                                服务引用代表了一个绑定的服务提供者。

                                                                                -

                                                                                获取服务引用的时候，可以传递一个JsonObject对象来配置服务对象，可以包括用来配置服务对象的各种参数。某些服务类型不需要额外的配置，有些需要（比如数据库对象）：

                                                                                -
                                                                                ServiceReference reference = discovery.getReferenceWithConfiguration(record, conf);
-
-// Then, gets the service object, the returned type depends on the service type:
-// For http endpoint:
-JDBCClient client = reference.getAs(JDBCClient.class);
-
-// Do something with the client...
-
-// When done with the service
-reference.release();
-
                                                                                -

                                                                                在前面的示例中，代码中使用的是getAs方法，参数是你期望获得的对象类型。如果你使用Java语言，那么可以直接用get方法，而其他语言中，你必须传递对象类型。

                                                                                -

                                                                                服务类型

                                                                                -

                                                                                前面提到，服务发现使用了服务类型的概念，来封装各种服务的差异性。

                                                                                -

                                                                                目前服务发现组件提供了几种默认的服务类型：

                                                                                -
                                                                                  -
                                                                                • HttpEndpoint - 为REST API服务提供的类型，服务对象的类型是一个配置好了host和port的HttpClient（其location表现为一个url）
                                                                                  • -
                                                                                • EventBusService - 服务代理，服务对象是一个代理，它的类型是所代理的接口（其location表现为一个Event Bus的address地址）
                                                                                  • -
                                                                                • MessageSource - 消息源服务，服务对象的类型是一个MessageConsumer（其location表现为一个Event Bus的address地址）
                                                                                  • -
                                                                                • JDBCDataSource - JDBC数据源服务，服务对象的类型是一个JDBCClient（该Client的配置参数，将从location、元数据和服务消费者传递的参数中获取）
                                                                                  • -
                                                                                • RedisDataSource - Redis数据源服务，服务对象的类型是一个RedisClient（该client的配置参数，将从location、元数据和服务消费者传递的参数中获取）
                                                                                  • -
                                                                                • MongoDataSource - Mongo数据源服务，服务对象的类型一个MongoClient（该client的配置参数，将从location、元数据和服务消费者传递的参数中获取）
                                                                                  • -
                                                                                -

                                                                                本节将详细介绍一下服务类型，以及如何使用服务发现框架已提供的几种服务类型。

                                                                                -

                                                                                无类型的服务

                                                                                -

                                                                                某些服务记录也可以不带有类型（ServiceType.UNKNOWN）。通过这种服务记录，是无法获取到服务引用的，但是你可以通过服务记录（Record）的location和metadata来创建连接的细节。

                                                                                -

                                                                                使用这种服务，将不会产生服务使用的事件。

                                                                                -

                                                                                自定义的服务类型

                                                                                -

                                                                                通过实现 ServiceType SPI接口，可以自定义服务类型：

                                                                                -
                                                                                  -
                                                                                1. （可选）创建一个继承了 ServiceType 的公共接口。在这个接口中，仅需要提供一些辅助方法，来简化自定义类型的使用，比如提供 createRecord 方法以及 getX 方法（这里的X指的是将返回的服务对象的类型）等等。可以查看 HttpEndpoint 和 MessageSource 等接口例子来了解这种设计。
                                                                                  2. -
                                                                                2. 创建一个实现了 ServiceType 接口或者第一步定义的接口的类，这个类必须有一个 name 方法和一个用来创建 ServiceReference 的方法，这个 name 方法返回的名称，要和关联到自定义类型的 Record 的 type 属性一致。
                                                                                  3. -
                                                                                3. 创建一个继承io.vertx.ext.discovery.types.AbstractServiceReference的类。你可以对类进行参数化，添加上你要返回的服务对象的类型信息，你必须实现AbstractServiceReference#retrieve()这个方法，在这个方法中创建服务对象，这个方法只会被调用一次，如果你的服务对象需要释放资源，那另外还需要覆写 AbstractServiceReference#close()方法。
                                                                                  4. -
                                                                                4. 创建META-INF/services/io.vertx.servicediscovery.spi.ServiceType文件，并把这个文件打包到自定义类型的jar包中，在这个文件中，需要标明第二步中所创建类的全限定名。
                                                                                  5. -
                                                                                5. 将第一步的服务接口、第二步第三步的实现类以及第四步中的服务描述文件打包成一个jar包，然后将这个jar包放到你应用的 classpath 中。然后，这个自定义类型就可以使用了。
                                                                                  6. -
                                                                                -

                                                                                HTTP Endpoint

                                                                                -

                                                                                一个 HTTP 端点(endpoint)，就是一个REST API或可以通过HTTP请求访问的服务。HTTP Endpoint服务对象就是一个配置了host、port和ssl的 HttpClient 对象。

                                                                                -

                                                                                发布HTTP Endpoint服务

                                                                                -

                                                                                要发布一个HTTP Endpoint服务，你需要一个 Record 对象。你可以通过调用HttpEndpoint.createRecord创建这样一个服务记录对象。

                                                                                -

                                                                                下面的代码片段，展示了如何通过 HttpEndpoint 接口创建一个 Record：

                                                                                -
                                                                                Record record1 = HttpEndpoint.createRecord(
-  "some-http-service", // The service name
-  "localhost", // The host
-  8433, // the port
-  "/api" // the root of the service
-);
-
-discovery.publish(record1, ar -> {
-  // ...
-});
-
-Record record2 = HttpEndpoint.createRecord(
-  "some-other-name", // the service name
-  true, // whether or not the service requires HTTPs
-  "localhost", // The host
-  8433, // the port
-  "/api", // the root of the service
-  new JsonObject().put("some-metadata", "some value")
-);
-
                                                                                -

                                                                                当你在容器或云上部署你的服务时，可能你不能确定公开的IP地址和端口。所以，服务的发布必须通过其他拥有这些信息的实体来进行，这通常是一个桥接对象（bridge）。

                                                                                -

                                                                                调用HTTP Endpoint服务

                                                                                -

                                                                                一旦一个HTTP Endpoint服务发布好了，服务消费者就可以获取到这个服务。对应的服务对象是一个 HttpClient 实例，并且已经配置好了host和port参数。

                                                                                -
                                                                                discovery.getRecord(new JsonObject().put("name", "some-http-service"), ar -> {
-  if (ar.succeeded() && ar.result() != null) {
-    // Retrieve the service reference
-    ServiceReference reference = discovery.getReference(ar.result());
-    // Retrieve the service object
-    HttpClient client = reference.getAs(HttpClient.class);
-
-    // You need to path the complete path
-    client.getNow("/api/persons", response -> {
-
-      // ...
-
-      // Dont' forget to release the service
-      reference.release();
-
-    });
-  }
-});
-
                                                                                -

                                                                                你也可以使用 HttpEndpoint.getClient 这个方法，一步就完成服务查找和服务获取：

                                                                                -
                                                                                HttpEndpoint.getClient(discovery, new JsonObject().put("name", "some-http-service"), ar -> {
-  if (ar.succeeded()) {
-    HttpClient client = ar.result();
-
-    // You need to path the complete path
-    client.getNow("/api/persons", response -> {
-
-      // ...
-
-      // Dont' forget to release the service
-      ServiceDiscovery.releaseServiceObject(discovery, client);
-
-    });
-  }
-});
-
                                                                                -

                                                                                在第二种写法中，服务对象的释放是通过 ServiceDiscovery.releaseServiceObject 这个方法完成的，因此在这种情况下你是不需要持有一个服务引用的。

                                                                                -

                                                                                从Vert.x 3.4.0开始，Vert.x提供了另一种更高层次封装、更方便使用的HTTP客户端 — WebClient。你可以通过如下方式来获取一个 WebClient 实例：

                                                                                -
                                                                                discovery.getRecord(new JsonObject().put("name", "some-http-service"), ar -> {
-  if (ar.succeeded() && ar.result() != null) {
-    // Retrieve the service reference
-    ServiceReference reference = discovery.getReference(ar.result());
-    // Retrieve the service object
-    WebClient client = reference.getAs(WebClient.class);
-
-    // You need to path the complete path
-    client.get("/api/persons").send(
-      response -> {
-
-        // ...
-
-        // Dont' forget to release the service
-        reference.release();
-
-      });
-  }
-});
-
                                                                                -

                                                                                另外一种写法，通过对应的服务类型接口获取的方式：

                                                                                -
                                                                                HttpEndpoint.getWebClient(discovery, new JsonObject().put("name", "some-http-service"), ar -> {
-  if (ar.succeeded()) {
-    WebClient client = ar.result();
-
-    // You need to path the complete path
-    client.get("/api/persons")
-      .send(response -> {
-
-        // ...
-
-        // Dont' forget to release the service
-        ServiceDiscovery.releaseServiceObject(discovery, client);
-
-      });
-  }
-});
-
                                                                                -

                                                                                Event Bus 服务

                                                                                -

                                                                                Event Bus 服务是一种服务代理，是基于Event Bus实现的一种异步RPC服务。当从一个Event Bus服务中获取一个服务对象时，你实际上得到的某个服务类的服务代理。你也可以使用 EventBusService 接口的辅助方法来获得服务代理。

                                                                                -

                                                                                注意服务代理（服务实现和服务接口）都需要用Java语言开发。

                                                                                -

                                                                                发布Event Bus 服务

                                                                                -

                                                                                要发布一个Event Bus服务，你需要创建一个 Record 对象：

                                                                                -
                                                                                Record record = EventBusService.createRecord(
-    "some-eventbus-service", // The service name
-    "address", // the service address,
-    "examples.MyService", // the service interface as string
-    new JsonObject()
-        .put("some-metadata", "some value")
-);
-
-discovery.publish(record, ar -> {
-  // ...
-});
-
                                                                                -

                                                                                你也可以直接传递服务接口类：

                                                                                -
                                                                                Record record = EventBusService.createRecord(
-"some-eventbus-service", // The service name
-"address", // the service address,
-MyService.class // the service interface
-);
-
-discovery.publish(record, ar -> {
-// ...
-});
-
                                                                                -

                                                                                调用 Event Bus 服务

                                                                                -

                                                                                要调用（消费）Event Bus服务，你可以通过先获取到服务记录然后获取服务引用的方式，也可以直接通过 EventBusService 接口，将两步合并成一次方法调用。

                                                                                -

                                                                                当使用服务引用的方式，你需要如下方式：

                                                                                -
                                                                                discovery.getRecord(new JsonObject().put("name", "some-eventbus-service"), ar -> {
-  if (ar.succeeded() && ar.result() != null) {
-    // Retrieve the service reference
-    ServiceReference reference = discovery.getReference(ar.result());
-    // Retrieve the service object
-    MyService service = reference.getAs(MyService.class);
-
-    // Dont' forget to release the service
-    reference.release();
-  }
-});
-
                                                                                -

                                                                                当使用 EventBusService 接口时，你可以通过如下方式获得代理对象：

                                                                                -
                                                                                EventBusService.getProxy(discovery, MyService.class, ar -> {
-  if (ar.succeeded()) {
-    MyService service = ar.result();
-
-    // 不要忘记释放服务对象！
-    ServiceDiscovery.releaseServiceObject(discovery, service);
-  }
-});
-
                                                                                -

                                                                                消息源服务

                                                                                -

                                                                                消息源服务，就是通过Event Bus发送消息到某个地址的组件。消息源服务的Client是 MessageConsumer。

                                                                                -

                                                                                消息源服务的location是消息所发送的Event Bus 地址。

                                                                                -

                                                                                发布消息源服务

                                                                                -

                                                                                和其他服务类型一样，发布一个消息源服务包含两个步骤：

                                                                                -
                                                                                  -
                                                                                1. 通过 MessageSource 接口创建一条服务记录
                                                                                  2. -
                                                                                2. 发布这条服务记录
                                                                                  3. -
                                                                                -
                                                                                Record record = MessageSource.createRecord(
-    "some-message-source-service", // The service name
-    "some-address" // The event bus address
-);
-
-discovery.publish(record, ar -> {
-  // ...
-});
-
-record = MessageSource.createRecord(
-    "some-other-message-source-service", // The service name
-    "some-address", // The event bus address
-    "examples.MyData" // The payload type
-);
-
                                                                                -

                                                                                在第二个 Record 创建时，我们同时指明了消息体（payload）的类型，这不是必须的。

                                                                                -

                                                                                在Java中，你可以使用 Class 类型的参数：

                                                                                -
                                                                                Record record1 = MessageSource.createRecord(
-"some-message-source-service", // The service name
-"some-address", // The event bus address
-JsonObject.class // The message payload type
-);
-
-Record record2 = MessageSource.createRecord(
-"some-other-message-source-service", // The service name
-"some-address", // The event bus address
-JsonObject.class, // The message payload type
-new JsonObject().put("some-metadata", "some value")
-);
-
                                                                                -

                                                                                消费消息源服务

                                                                                -

                                                                                在服务消费端，你可以手动获取服务记录和服务引用，也可以使用 MessageSource 接口提供的辅助方法直接获取。

                                                                                -

                                                                                第一种方式对应的代码示例如下：

                                                                                -
                                                                                discovery.getRecord(new JsonObject().put("name", "some-message-source-service"), ar -> {
-  if (ar.succeeded() && ar.result() != null) {
-    // Retrieve the service reference
-    ServiceReference reference = discovery.getReference(ar.result());
-    // Retrieve the service object
-    MessageConsumer<JsonObject> consumer = reference.getAs(MessageConsumer.class);
-
-    // Attach a message handler on it
-    consumer.handler(message -> {
-      // message handler
-      JsonObject payload = message.body();
-    });
-
-    // ...
-    // when done
-    reference.release();
-  }
-});
-
                                                                                -

                                                                                如果使用 MessageSource 接口，代码如下：

                                                                                -
                                                                                MessageSource.<JsonObject>getConsumer(discovery, new JsonObject().put("name", "some-message-source-service"), ar -> {
-  if (ar.succeeded()) {
-    MessageConsumer<JsonObject> consumer = ar.result();
-
-    // Attach a message handler on it
-    consumer.handler(message -> {
-      // message handler
-      JsonObject payload = message.body();
-    });
-    // ...
-
-    // Dont' forget to release the service
-    ServiceDiscovery.releaseServiceObject(discovery, consumer);
-
-  }
-});
-
                                                                                -

                                                                                JDBC 数据源

                                                                                -

                                                                                数据源指的是数据库或数据存储。JDBC数据源通过JDBC驱动访问数据库，JDBC数据源服务对象是是 JDBCClient 实例。

                                                                                -

                                                                                发布 JDBC 数据源服务

                                                                                -

                                                                                和其他服务类型一样，发布 JDBC 数据源服务共两个步骤：

                                                                                -
                                                                                  -
                                                                                1. 通过 JDBCDataSource 接口创建服务记录
                                                                                  2. -
                                                                                2. 发布服务记录
                                                                                  3. -
                                                                                -
                                                                                Record record = JDBCDataSource.createRecord(
-    "some-data-source-service", // The service name
-    new JsonObject().put("url", "some jdbc url"), // The location
-    new JsonObject().put("some-metadata", "some-value") // Some metadata
-);
-
-discovery.publish(record, ar -> {
-  // ...
-});
-
                                                                                -

                                                                                JDBC 数据源可以代表各种类型的数据库，而这些数据库的访问方式一般是不同的，服务记录很难有统一结构。在服务记录中，location 由一个简单的JSON对象组成，里面包含访问数据源的各种属性（JDBC URL、用户名、密码等）。这些属性既依赖于数据库，同时也依赖于所使用的连接池。

                                                                                -

                                                                                消费 JDBC 数据源服务

                                                                                -

                                                                                如前所述，访问数据源的方式依赖于数据源本身。要创建一个 JDBCClient，你需要同时提供：服务记录位置信息、元数据以及服务消费者提供的JSON对象：

                                                                                -
                                                                                discovery.getRecord(
-    new JsonObject().put("name", "some-data-source-service"),
-    ar -> {
-      if (ar.succeeded() && ar.result() != null) {
-        // Retrieve the service reference
-        ServiceReference reference = discovery.getReferenceWithConfiguration(
-            ar.result(), // The record
-            new JsonObject().put("username", "clement").put("password", "*****")); // Some additional metadata
-
-        // Retrieve the service object
-        JDBCClient client = reference.getAs(JDBCClient.class);
-
-        // ...
-
-        // when done
-        reference.release();
-      }
-    });
-
                                                                                -

                                                                                你也可以使用 JDBCDataSource 接口的辅助方法，来查询和获取服务对象：

                                                                                -
                                                                                JDBCDataSource.<JsonObject>getJDBCClient(discovery,
-    new JsonObject().put("name", "some-data-source-service"),
-    new JsonObject().put("username", "clement").put("password", "*****"), // Some additional metadata
-    ar -> {
-      if (ar.succeeded()) {
-        JDBCClient client = ar.result();
-
-        // ...
-
-        // Dont' forget to release the service
-        ServiceDiscovery.releaseServiceObject(discovery, client);
-
-      }
-    });
-
                                                                                -

                                                                                Redis 数据源

                                                                                -

                                                                                Redis 数据源服务是专门为Redis提供的服务类型，对应服务对象是 RedisClient。

                                                                                -

                                                                                发布 Redis 数据源服务

                                                                                -

                                                                                发布一个 Redis 数据源服务共两个步骤：

                                                                                -
                                                                                  -
                                                                                1. 通过 RedisDataSource 接口创建一条服务记录
                                                                                  2. -
                                                                                2. 发布这个服务记录
                                                                                  3. -
                                                                                -
                                                                                Record record = RedisDataSource.createRecord(
-  "some-redis-data-source-service", // The service name
-  new JsonObject().put("url", "localhost"), // The location
-  new JsonObject().put("some-metadata", "some-value") // Some metadata
-);
-
-discovery.publish(record, ar -> {
-  // ...
-});
-
                                                                                -

                                                                                这里的 location 是一个JSON对象，包含访问Redis数据源的属性（URL、端口等）。

                                                                                -

                                                                                消费 Redis 数据源服务

                                                                                -

                                                                                如前所述，访问数据源的方式依赖于数据源本身。要创建一个 RedisClient，你需要同时提供：服务记录位置信息、元数据以及服务消费者提供的JSON对象：

                                                                                -
                                                                                discovery.getRecord(
-  new JsonObject().put("name", "some-redis-data-source-service"), ar -> {
-    if (ar.succeeded() && ar.result() != null) {
-      // Retrieve the service reference
-      ServiceReference reference = discovery.getReference(ar.result());
-
-      // Retrieve the service instance
-      RedisClient client = reference.getAs(RedisClient.class);
-
-      // ...
-
-      // when done
-      reference.release();
-    }
-  });
-
                                                                                -

                                                                                你也可以利用 RedisDataSource 接口的辅助方法来查询和获取服务对象：

                                                                                -
                                                                                RedisDataSource.getRedisClient(discovery,
-  new JsonObject().put("name", "some-redis-data-source-service"),
-  ar -> {
-    if (ar.succeeded()) {
-      RedisClient client = ar.result();
-
-      // ...
-
-      // Dont' forget to release the service
-      ServiceDiscovery.releaseServiceObject(discovery, client);
-
-    }
-  })
-
                                                                                -

                                                                                Mongo 数据源

                                                                                -

                                                                                Mongo 数据源服务是专门为 MongoDB 提供的一种服务类型，对应的服务对象是 MongoClient。

                                                                                -

                                                                                发布 Mongo 数据源服务

                                                                                -

                                                                                发布一个 Mongo 数据源服务需要两步：

                                                                                -
                                                                                  -
                                                                                1. 通过 MongoDataSource 接口创建一条服务记录
                                                                                  2. -
                                                                                2. 发布这条服务记录
                                                                                  3. -
                                                                                -
                                                                                Record record = MongoDataSource.createRecord(
-  "some-data-source-service", // The service name
-  new JsonObject().put("connection_string", "some mongo connection"), // The location
-  new JsonObject().put("some-metadata", "some-value") // Some metadata
-);
-
-discovery.publish(record, ar -> {
-  // ...
-});
-
                                                                                -

                                                                                其中location是一个JSON对象，包含了访问Mongo数据源的所有属性（URL、端口等）

                                                                                -

                                                                                消费 Mongo 数据源服务

                                                                                -

                                                                                如前所述，访问数据源的方式依赖于数据源本身。要创建一个 MongoClient，你需要同时提供：服务记录位置信息、元数据以及服务消费者提供的JSON对象：

                                                                                -
                                                                                discovery.getRecord(
-  new JsonObject().put("name", "some-data-source-service"),
-  ar -> {
-    if (ar.succeeded() && ar.result() != null) {
-      // Retrieve the service reference
-      ServiceReference reference = discovery.getReferenceWithConfiguration(
-        ar.result(), // The record
-        new JsonObject().put("username", "clement").put("password", "*****")); // Some additional metadata
-
-      // Retrieve the service object
-      MongoClient client = reference.get();
-
-      // ...
-
-      // when done
-      reference.release();
-    }
-  });
-
                                                                                -

                                                                                你也可以利用 MongoDataSource 接口中的辅助方法来完成服务对象的查找和获取：

                                                                                -
                                                                                MongoDataSource.<JsonObject>getMongoClient(discovery,
-  new JsonObject().put("name", "some-data-source-service"),
-  new JsonObject().put("username", "clement").put("password", "*****"), // Some additional metadata
-  ar -> {
-    if (ar.succeeded()) {
-      MongoClient client = ar.result();
-
-      // ...
-
-      // Dont' forget to release the service
-      ServiceDiscovery.releaseServiceObject(discovery, client);
-
-    }
-  });
-
                                                                                -

                                                                                监听服务的上线与下线

                                                                                -

                                                                                每当服务发布或者取消发布，都会有相应的事件发送到 vertx.discovery.announce 这个地址。这个地址可以通过ServiceDiscoveryOptions配置。

                                                                                -

                                                                                收到的Record中有个status字段，用来表示服务的状态：

                                                                                -
                                                                                  -
                                                                                • UP：服务已经可以使用了
                                                                                  • -
                                                                                • DOWN：服务不再可用
                                                                                  • -
                                                                                • OUT_OF_SERVICE：服务目前不可用，但是过段时间会继续提供服务。
                                                                                  • -
                                                                                -

                                                                                监听服务的使用

                                                                                -

                                                                                每当有一个服务引用被绑定或者被释放，都会有相应的事件发送到 vertx.discovery.usage 这个地址。这个地址可以通过ServiceDiscoveryOptions配置。

                                                                                -

                                                                                通过这个事件，可以监听服务的使用和服务的映射。

                                                                                -

                                                                                收到的消息是一个包含如下内容的JsonObject对象：

                                                                                -
                                                                                  -
                                                                                • 在 record 属性中，包含了服务记录信息
                                                                                  • -
                                                                                • 在 type 属性中记录了事件的类型，类型分为bind和release
                                                                                  • -
                                                                                • 在 id 属性中记录了服务发现实例的ID（服务发现实例的名称或节点ID）
                                                                                  • -
                                                                                -

                                                                                其中 id 可以通过 ServiceDiscoveryOptions 进行配置。默认情况下，在单节点时它的值是localhost，在集群模式时是节点的ID。

                                                                                -

                                                                                你也可以通过setUsageAddress方法，将事件发送地址设置为null，这样就可以禁用服务使用情况的监听功能了。

                                                                                -

                                                                                服务发现桥接器

                                                                                -

                                                                                通过桥接器（bridge），你可以从其他服务发现组件中导入和导出服务，比如Docker，Kubernetes，Consul等。每种类型的桥接器，决定了服务如何导入和导出，并且不一定都是双向的。

                                                                                -

                                                                                要想自定义桥接器，你可以通过实现 ServiceImporter 接口，然后再使用 registerServiceImporter 方法注册一下。你可以通过第二个参数传递一些可选的配置信息给桥接器。

                                                                                -

                                                                                当桥接器注册后，start 方法将会被调用，这样你可以对桥接器进行一些配置。当桥接器配置好了，已经准备导入导出初始的服务时，必须 complete 所传递的 Future。如果桥接器的启动方法是阻塞型的，那么就必须使用 executeBlocking 方法进行封装，并且complete所传递的 Future 对象。

                                                                                -

                                                                                当服务发现实例被关闭的时候，对应的桥接器也一块被关闭了。执行关闭操作的时候，服务发现组件会调用 close 方法以进行资源的释放以及移除导入/导出的服务。这个方法必须调用所传递的 Future 的complete方法，来通知调用者关闭操作已经完成。

                                                                                -

                                                                                需要提醒的是，在一个集群中，只需要有一个节点注册了服务桥接器，集群中所有成员就都能使用了。

                                                                                -

                                                                                可用的服务发现桥接器

                                                                                -

                                                                                Vert.x 服务发现组件除了支持桥接器机制以外，还提供了一些现成的桥接器。

                                                                                -

                                                                                Consul 桥接器

                                                                                -

                                                                                Consul 桥接器可以将 Consul 中的服务导入到Vert.x的服务发现组件中。

                                                                                -

                                                                                这个桥接器可以连接 Consul agent（服务器），并且会进行周期性的扫描，来更新服务情况：

                                                                                -
                                                                                  -
                                                                                • 新的服务被导入
                                                                                  • -
                                                                                • 维护模式下的服务或已经从 Consul 中移除的服务将会被移除
                                                                                  • -
                                                                                -

                                                                                这个桥接器使用的是 Consul 的HTTP API接口。它不能将服务导出到Consul，并且也不支持服务的修改。

                                                                                -

                                                                                服务的类型是通过tags推断出来的，如果有一个tag和已知的服务类型一样，那么就使用这种服务类型，如果没有匹配的，那么服务导入后将标记为unknown类型。目前暂时只支持http-endpoint类型。

                                                                                -

                                                                                桥接器的使用

                                                                                -

                                                                                要使用该服务发现桥接器，需要将如下的依赖包加入到依赖配置文件中：

                                                                                -
                                                                                  -
                                                                                • Maven（在 pox.xml 文件中）：
                                                                                  • -
                                                                                -
                                                                                <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-service-discovery-bridge-consul</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                                -
                                                                                  -
                                                                                • Gradle（在 build.gradle 文件中）：
                                                                                  compile 'io.vertx:vertx-service-discovery-bridge-consul:3.4.1'
-
                                                                                  -
                                                                                  • -
                                                                                -

                                                                                然后，在创建服务发现对象的时候，像下面这样注册桥接器：

                                                                                -
                                                                                ServiceDiscovery.create(vertx)
-    .registerServiceImporter(new ConsulServiceImporter(),
-        new JsonObject()
-            .put("host", "localhost")
-            .put("port", 8500)
-            .put("scan-period", 2000));
-
                                                                                -

                                                                                你可以做一些配置：

                                                                                -
                                                                                  -
                                                                                • host 属性，配置 agent 的地址，默认是localhost
                                                                                  • -
                                                                                • port 属性，配置 agent 的端口，默认的端口是 8500
                                                                                  • -
                                                                                • scan-period 属性，配置扫描的频率，扫描的单位是毫秒（ms），默认是 2000 ms
                                                                                  • -
                                                                                -

                                                                                Kubernetes 桥接器

                                                                                -

                                                                                Kubernetes 桥接器可以从Kubernetes（或者 Openshift v3）中导入服务到Vert.x的服务发现组件中。

                                                                                -

                                                                                Kubernetes的所有服务，都将映射为一条 Record。目前桥接器只支持将服务从Kubernetes中导入到Vert.x中（反过来不行）。

                                                                                -

                                                                                Kubernetes中的服务，在导入到Vert.x后都会创建对应的服务记录（Record）。服务类型是通过 service.type.lable 推断出来的。如果该属性没有设置，那么服务类型被设置为unknown。目前暂时只支持 http-endpoint 服务类型。

                                                                                -

                                                                                桥接器的使用

                                                                                -

                                                                                要使用该服务发现桥接器，需要将如下的依赖包加入到依赖配置文件中：

                                                                                -
                                                                                  -
                                                                                • Maven（在 pox.xml 文件中）：
                                                                                  • -
                                                                                -
                                                                                <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-service-discovery-bridge-kubernetes</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                                -
                                                                                  -
                                                                                • Gradle（在 build.gradle 文件中）：
                                                                                  compile 'io.vertx:vertx-service-discovery-bridge-kubernetes:3.4.1'
-
                                                                                  -
                                                                                  • -
                                                                                -

                                                                                桥接器的配置

                                                                                -

                                                                                桥接器的配置项有：

                                                                                -
                                                                                  -
                                                                                • OAuth token（默认是使用/var/run/secrets/kubernetes.io/serviceaccount/token中的内容）
                                                                                  • -
                                                                                • 服务搜索的命名空间（默认是default）
                                                                                  • -
                                                                                -

                                                                                请注意，应用程序必须能够访问 Kubernetes 并且能够读取所选择的命名空间。

                                                                                -

                                                                                服务记录的映射

                                                                                -

                                                                                服务记录按照如下的步骤进行创建：

                                                                                -
                                                                                  -
                                                                                • 从 service.type 中推断出服务类型；如果没有设置，那么服务类型被设置为unknown
                                                                                  • -
                                                                                • 服务记录的名称就是服务的名称
                                                                                  • -
                                                                                • 服务的标签（label）都被映射为服务记录的元数据
                                                                                  • -
                                                                                • 此外还会加上：kubernetes.uuid, kubernetes.namespace, kubernetes.name
                                                                                  • -
                                                                                • location信息将从服务的第一个端口推断出来
                                                                                  • -
                                                                                -

                                                                                对于 HTTP 端点，如果服务带有ssl标签的话，那么服务记录的ssl(https)属性将被设置为true。

                                                                                -

                                                                                动态性

                                                                                -

                                                                                Kubernetes 桥接器将会在启动(start)的时候导入所有的服务，在停止(stop)的时候移除所有的服务。在运行期间，它将监听 Kubernetes 的服务，并且动态地导入新加入的服务，移除被删除的服务。

                                                                                - -

                                                                                Docker Links 桥接器可以从 Docker Links 中导入服务到 Vert.x 的服务发现组件中。

                                                                                -

                                                                                当你将一个Docker容器与另外一个Docker容器链接在一起(link)的时候，Docker将会注入一组环境变量。该桥接器将分析这些环境变量，并且针对每个链接(link)，生成一个服务记录。服务记录的类型从service.type.lable属性中推断；如果没有设置，那么服务类型将被设置为unknown。目前暂时只支持 http-endpoint 服务类型。

                                                                                -

                                                                                由于Docker容器只在启动的时候创建链接，所以这个桥接器只会在启动的时候导入服务记录，然后此后就都不改变了。

                                                                                -

                                                                                桥接器的使用

                                                                                -

                                                                                要使用该服务发现桥接器，需要将如下的依赖包加入到依赖配置文件中：

                                                                                -
                                                                                  -
                                                                                • Maven（在 pox.xml 文件中）：
                                                                                  • -
                                                                                -
                                                                                <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-service-discovery-bridge-docker-links</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                                -
                                                                                  -
                                                                                • Gradle（在 build.gradle 文件中）：
                                                                                  compile 'io.vertx:vertx-service-discovery-bridge-docker-links:3.4.1'
-
                                                                                  -
                                                                                  • -
                                                                                -

                                                                                然后，在创建服务发现对象的时候，像下面这样注册桥接器：

                                                                                -
                                                                                ServiceDiscovery.create(vertx)
-    .registerServiceImporter(new DockerLinksServiceImporter(), new JsonObject());
-
                                                                                -

                                                                                这种桥接器不需要任何进一步的配置。

                                                                                -

                                                                                其他存储后端

                                                                                -

                                                                                Vert.x服务发现框架还提供了一些现成的后端存储机制支持。

                                                                                -

                                                                                Redis 存储后端

                                                                                -

                                                                                服务发现组件通过实现 ServiceDiscoveryBackend SPI提供了一种可插拔的存储后端扩展机制。

                                                                                -

                                                                                Vert.x Service Discovery Redis Backend组件是基于Redis的后端存储实现。

                                                                                -

                                                                                使用 Redis 存储后端

                                                                                -

                                                                                要使用 Redis 存储后端，需要将如下的依赖包加入到依赖配置文件中：

                                                                                -
                                                                                  -
                                                                                • Maven（在 pom.xml 文件中）：
                                                                                  • -
                                                                                -
                                                                                <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-service-discovery-backend-redis</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                                -
                                                                                  -
                                                                                • Gradle（在 build.gradle 文件中）：
                                                                                  compile 'io.vertx:vertx-service-discovery-backend-redis:3.4.1'
-
                                                                                  -
                                                                                  • -
                                                                                -

                                                                                需要注意的是，你只能在 classpath 中指定一个SPI的实现；如果没有指定，那么将使用默认的存储后端。

                                                                                -

                                                                                配置

                                                                                -

                                                                                Redis存储后端是基于 Vert.x Redis Client 实现的，所以配置内容和 RedisClient 的配置内容一致。

                                                                                -

                                                                                下面是一个示例：

                                                                                -
                                                                                ServiceDiscovery.create(vertx, new ServiceDiscoveryOptions()
-    .setBackendConfiguration(
-        new JsonObject()
-            .put("host", "127.0.0.1")
-            .put("key", "records")
-    ));
-
                                                                                -
                                                                                -
                                                                                -

                                                                                原文档最后更新于 2017-03-15 15:54:14 CET

                                                                                -
                                                                                - - -
                                                                                - -
                                                                                -
                                                                                -
                                                                                - -

                                                                                results matching ""

                                                                                -
                                                                                  - -
                                                                                  -
                                                                                  - -

                                                                                  No results matching ""

                                                                                  - -
                                                                                  -
                                                                                  -
                                                                                  - -
                                                                                  -
                                                                                  - -
                                                                                  - - - - - - - - - - -
                                                                                  - - -
                                                                                  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/mqttserver/MQTTServer.md b/docs/mqttserver/MQTTServer.md deleted file mode 100644 index 37ceb5b..0000000 --- a/docs/mqttserver/MQTTServer.md +++ /dev/null @@ -1 +0,0 @@ -# Vert.x MQTT Server diff --git a/docs/reactive/Reactive.html b/docs/reactive/Reactive.html deleted file mode 100644 index 7feee3a..0000000 --- a/docs/reactive/Reactive.html +++ /dev/null @@ -1,1060 +0,0 @@ - - - - - - - Reactive · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                  -
                                                                                  - - - - - - - - -
                                                                                  - -
                                                                                  - -
                                                                                  - - - - - - - - -
                                                                                  -
                                                                                  - -
                                                                                  -
                                                                                  - -
                                                                                  - -

                                                                                  Vert.x Reactive

                                                                                  -

                                                                                  Vert.x 提供了数个组件，可以使你的应用更具有响应性（reactive）。

                                                                                  - - -
                                                                                  - -
                                                                                  -
                                                                                  -
                                                                                  - -

                                                                                  results matching ""

                                                                                  -
                                                                                    - -
                                                                                    -
                                                                                    - -

                                                                                    No results matching ""

                                                                                    - -
                                                                                    -
                                                                                    -
                                                                                    - -
                                                                                    -
                                                                                    - -
                                                                                    - - - - - - - - - - - - - - -
                                                                                    - - -
                                                                                    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/reactive/Reactivestreams.html b/docs/reactive/Reactivestreams.html deleted file mode 100644 index d5d586c..0000000 --- a/docs/reactive/Reactivestreams.html +++ /dev/null @@ -1,1124 +0,0 @@ - - - - - - - Reactive streams · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                    -
                                                                                    - - - - - - - - -
                                                                                    - -
                                                                                    - -
                                                                                    - - - - - - - - -
                                                                                    -
                                                                                    - -
                                                                                    -
                                                                                    - -
                                                                                    - -

                                                                                    Vert.x Reactive Streams

                                                                                    - -

                                                                                    中英文对照表

                                                                                    -
                                                                                      -
                                                                                    • publisher(n.)：发布者
                                                                                      • -
                                                                                    • subscriber(n.)：订阅者
                                                                                      • -
                                                                                    • read stream(n.)：可读流
                                                                                      • -
                                                                                    • write stream(n.)：可写流
                                                                                      • -
                                                                                    • subscribe(v.)：注册
                                                                                      • -
                                                                                    • back pressure：背压机制
                                                                                      • -
                                                                                    -

                                                                                    为了支持在 JVM 上进行非阻塞的带背压机制的异步流处理， Reactive Streams 做了一些初创性的工作来提供这样一份标准。

                                                                                    -

                                                                                    这个库提供了 Vert.x 上 Reactive Streams 标准的实现。

                                                                                    -

                                                                                    在处理流式数据方面，Vert.x 有自己的机制；通过这三个类：io.vertx.core.streams.ReadStream 、 io.vertx.core.streams.WriteStream 和 io.vertx.core.streams.Pump，可以在将数据从一个流泵到另一个流时，实现流量控制。更多关于 Vert.x 流方面的信息请查阅 Vert.x Core 部分的手册。

                                                                                    -

                                                                                    这个库为可读流、可写流都提供了实现，这两者分别扮演了 Reactive Streams 中发布者和订阅者的角色；这使得我们能够以对待 Vert.x 中读写流的方式处理任意 Reactive Streams 的发布者和订阅者。

                                                                                    -

                                                                                    使用 Vert.x Reactive Streams

                                                                                    -

                                                                                    要使用 Vert.x Reactive Streams 组件，需要在构建描述符中添加如下依赖：

                                                                                    -
                                                                                      -
                                                                                    • Maven（在 pom.xml 文件中）：
                                                                                      • -
                                                                                    -
                                                                                    <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-reactive-streams</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                                    -
                                                                                      -
                                                                                    • Gradle（在 build.gradle 文件中）：
                                                                                      • -
                                                                                    -
                                                                                    compile 'io.vertx:vertx-reactive-streams:3.4.1'
-
                                                                                    -

                                                                                    Reactive Read Stream

                                                                                    -

                                                                                    我们为 Vert.x 的 ReadStream 接口提供了实现类 ReactiveReadStream ，它同样也实现了 Reactive Streams 的订阅者角色。

                                                                                    -

                                                                                    你可以把这个类的实例传递给任意的 Reactive Streams 发布者（例如来自 Akka 的发布者），随后你就可以像从其他任意的 Vert.x ReadStream中一样读取数据（例如使用一个 Pump 把数据从这个流泵到一个 WriteStream）。

                                                                                    -

                                                                                    这里有个例子，从某个其他的 Reactive Streams 实现中（例如 Akka）获得一个发布者，并将其数据泵入到服务端的 HTTP 响应体中。其间，背压机制是自动执行的。

                                                                                    -
                                                                                    ReactiveReadStream<Buffer> rrs = ReactiveReadStream.readStream();
-
-// 在另外的发布者上注册订阅者
-otherPublisher.subscribe(rrs);
-
-// 将数据从可读流泵入 HTTP 响应
-Pump pump = Pump.pump(rrs, response);
-
-pump.start();
-
                                                                                    -

                                                                                    Reactive Write Stream

                                                                                    -

                                                                                    同样的，我们为 WriteStream 接口提供了实现类 ReactiveWriteStream ，它也是 Reactive Streams 的发布者角色的实现。拿到任意的 Reactive Streams 订阅者（例如来自 Akka 的订阅者）之后，你就可以像处理其他任意的 Vert.x WriteStream一样，往其中写入数据（例如使用一个 Pump 把从 ReadStream 来的数据泵入其中）。

                                                                                    -

                                                                                    在手动处理 Vert.x 可读流的背压时，你会用到 pause，resume，writeQueueFull 这些方法；它们会在内部被自动转换成 Reactive Streams 中背压机制传播方面的方法（在请求更多数据项时）。

                                                                                    -

                                                                                    这里有个例子，从其他的 Reactive Streams 实现拿到订阅者之后，将服务端的请求体泵入其中。其间背压机制将自动运行。

                                                                                    -
                                                                                    ReactiveWriteStream<Buffer> rws = ReactiveWriteStream.writeStream(vertx);
-
-// 在可写流上注册另外的订阅者
-rws.subscribe(otherSubscriber);
-
-// 将 HTTP 请求泵入可写流
-Pump pump = Pump.pump(request, rws);
-
-pump.start();
-
                                                                                    -
                                                                                    -
                                                                                    -

                                                                                    原文档最后更新于 2017-03-15 15:54:14 CET

                                                                                    -
                                                                                    - - -
                                                                                    - -
                                                                                    -
                                                                                    -
                                                                                    - -

                                                                                    results matching ""

                                                                                    -
                                                                                      - -
                                                                                      -
                                                                                      - -

                                                                                      No results matching ""

                                                                                      - -
                                                                                      -
                                                                                      -
                                                                                      - -
                                                                                      -
                                                                                      - -
                                                                                      - - - - - - - - - - - - - - -
                                                                                      - - -
                                                                                      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/reactive/Rx.html b/docs/reactive/Rx.html deleted file mode 100644 index a360358..0000000 --- a/docs/reactive/Rx.html +++ /dev/null @@ -1,1470 +0,0 @@ - - - - - - - Vert.x Rx · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                      -
                                                                                      - - - - - - - - -
                                                                                      - -
                                                                                      - -
                                                                                      - - - - - - - - -
                                                                                      -
                                                                                      - -
                                                                                      -
                                                                                      - -
                                                                                      - -

                                                                                      Vert.x Rx

                                                                                      - -

                                                                                      中英文对照表

                                                                                      -
                                                                                        -
                                                                                      • observable sequences：可观察序列
                                                                                        • -
                                                                                      • Rxified：Rx化
                                                                                        • -
                                                                                      • operator：操作符
                                                                                        • -
                                                                                      • lift：变换
                                                                                        • -
                                                                                      • flow：流
                                                                                        • -
                                                                                      • read stream：可读流
                                                                                        • -
                                                                                      • write stream：可写流
                                                                                        • -
                                                                                      • observer：观察者
                                                                                        • -
                                                                                      • subscriber：订阅者
                                                                                        • -
                                                                                      • item：对象
                                                                                        • -
                                                                                      • handler：（事件）处理器
                                                                                        • -
                                                                                      • timer：定时器
                                                                                        • -
                                                                                      • subscription(n.)：订阅
                                                                                        • -
                                                                                      • unmarshall：重组
                                                                                        • -
                                                                                      -

                                                                                      Vert.x API for RxJava

                                                                                      -

                                                                                      RxJava 是 JVM 上一个流行的库，用于组合异步的、使用可观察序列的、基于事件的程序。

                                                                                      -

                                                                                      Vert.x 与 RxJava 集成起来很自然：它使得无论什么时候，只要我们能使用流和异步结果，就能使用 Observable。

                                                                                      -

                                                                                      要使用 Vert.x 的 RxJava API，有两种方式：

                                                                                      -
                                                                                        -
                                                                                      • 通过原始的 Vert.x API 辅以 RxHelper 类，这个辅助类提供了用于 Vert.x Core API 和 RxJava API 之间互相转化的静态方法。
                                                                                        • -
                                                                                      • 通过基于 Vert.x Core API 增强的Rx化的 Vert.x API。
                                                                                        • -
                                                                                      -

                                                                                      可读流支持

                                                                                      -

                                                                                      RxJava 中 Observable 的概念和 Vert.x 中 ReadStream 类是一对完美的匹配：都提供了一个对象流。

                                                                                      -

                                                                                      静态方法 RxHelper.toObservable 用于将 Vert.x 可读流转换为 rx.Observable：

                                                                                      -
                                                                                      FileSystem fileSystem = vertx.fileSystem();
-fileSystem.open("/data.txt", new OpenOptions(), result -> {
-  AsyncFile file = result.result();
-  Observable<Buffer> observable = RxHelper.toObservable(file);
-  observable.forEach(data -> System.out.println("Read data: " + data.toString("UTF-8")));
-});
-
                                                                                      -

                                                                                      而 Rx化的 Vert.x API 在 ReadStream 类上提供了 toObservable 方法：

                                                                                      -
                                                                                      FileSystem fs = vertx.fileSystem();
-fs.open("/data.txt", new OpenOptions(), result -> {
-  AsyncFile file = result.result();
-  Observable<Buffer> observable = file.toObservable();
-  observable.forEach(data -> System.out.println("Read data: " + data.toString("UTF-8")));
-});
-
                                                                                      -

                                                                                      这样的 Observable 是所谓 hot observable，即不管是否有订阅，它们都会产生通知。

                                                                                      -
                                                                                      -

                                                                                      译者注：在 RxJava 里，Observable 有“冷热”(cold/hot)之分。区别在于 cold observable 只有当订阅发生时，才会开始发射数据，而 hot observable 在创建完成后就会开始发射数据。更进一步的信息请查阅 RxJava 关于 Observable 的文档。

                                                                                      -
                                                                                      -

                                                                                      同样的，将一个 Observable 转变为 Vert.x ReadStream 也是可以的。

                                                                                      -

                                                                                      静态方法 RxHelper.toReadStream 用于将 rx.Observable 转换为 Vert.x 可读流：

                                                                                      -
                                                                                      Observable<Buffer> observable = getObservable();
-ReadStream<Buffer> readStream = RxHelper.toReadStream(observable);
-Pump pump = Pump.pump(readStream, response);
-pump.start();
-
                                                                                      -

                                                                                      处理器支持

                                                                                      -

                                                                                      RxHelper 类可以创建 ObservableHandler 对象。这是一个 Observable 对象，它的 toHandler 方法会返回 Handler<T> 接口的实现：

                                                                                      -
                                                                                      ObservableHandler<Long> observable = RxHelper.observableHandler();
-observable.subscribe(id -> {
-  // Fired
-});
-vertx.setTimer(1000, observable.toHandler());
-
                                                                                      -

                                                                                      Rx化的 Vert.x API 未提供针对 Handler 的 API。

                                                                                      -

                                                                                      异步结果支持

                                                                                      -

                                                                                      以一个现有的 Vert.x Handler<AsyncResult<T>> 对象为基础，你可以创建一个 RxJava Subscriber，然后将其注册在 Observable 或 Single 上：

                                                                                      -
                                                                                      observable.subscribe(RxHelper.toSubscriber(handler1));
-
-// Subscribe to a Single
-single.subscribe(RxHelper.toSubscriber(handler2));
-
                                                                                      -

                                                                                      在构造(construct)发生时，作为异步方法的最后一个参数的 Vert.x Handler<AsyncResult<T>> 可以被映射为单个元素的 Observable：

                                                                                      -
                                                                                        -
                                                                                      • 当回调成功时，观察者的 onNext 方法将被调用，参数就是这个对象；且其后 onComplete 方法会立即被调用。
                                                                                        • -
                                                                                      • 当回调失败时，观察者的 onError 方法将被调用。
                                                                                        • -
                                                                                      -

                                                                                      RxHelper.observableFuture 方法可以创建一个 ObservableFuture 对象。这这是一个 Observable 对象，它的 toHandler 方法会返回 Handler<AsyncResult<T>> 接口的实现：

                                                                                      -
                                                                                      ObservableFuture<HttpServer> observable = RxHelper.observableFuture();
-observable.subscribe(
-    server -> {
-      // Server is listening
-    },
-    failure -> {
-      // Server could not start
-    }
-);
-vertx.createHttpServer(new HttpServerOptions().
-    setPort(1234).
-    setHost("localhost")
-).listen(observable.toHandler());
-
                                                                                      -

                                                                                      我们可以从 ObservableFuture<Server> 中获取单个 HttpServer 对象。如果端口监听失败，订阅者将会得到通知。

                                                                                      -

                                                                                      RxHelper.toHandler 方法为观察者（Observer）和事件处理器（Handler）做了适配：

                                                                                      -
                                                                                      Observer<HttpServer> observer = new Observer<HttpServer>() {
-  @Override
-  public void onNext(HttpServer o) {
-  }
-  @Override
-  public void onError(Throwable e) {
-  }
-  @Override
-  public void onCompleted() {
-  }
-};
-Handler<AsyncResult<HttpServer>> handler = RxHelper.toFuture(observer);
-
                                                                                      -

                                                                                      下面的代码也是可以的（直接基于Action）：

                                                                                      -
                                                                                      Action1<HttpServer> onNext = httpServer -> {};
-Action1<Throwable> onError = httpServer -> {};
-Action0 onComplete = () -> {};
-
-Handler<AsyncResult<HttpServer>> handler1 = RxHelper.toFuture(onNext);
-Handler<AsyncResult<HttpServer>> handler2 = RxHelper.toFuture(onNext, onError);
-Handler<AsyncResult<HttpServer>> handler3 = RxHelper.toFuture(onNext, onError, onComplete);
-
                                                                                      -

                                                                                      Rx化的 Vert.x API 复制了类似的每一个方法，并冠以 rx 的前缀，它们都返回 RxJava 的 Single 对象：

                                                                                      -
                                                                                      Single<HttpServer> single = vertx
-  .createHttpServer()
-  .rxListen(1234, "localhost");
-
-// 订阅绑定端口的事件
-single.
-    subscribe(
-        server -> {
-          // Server is listening
-        },
-        failure -> {
-          // Server could not start
-        }
-    );
-
                                                                                      -

                                                                                      这样的 Single 是 “冷的”(cold)，对应的 API 方法将在注册时被调用。

                                                                                      -
                                                                                      -

                                                                                      注意：类似 rx* 的方法替换了以前版本中 *Observable 的方法，这样一个语义上的改变是为了与 RxJava 保持一致。

                                                                                      -
                                                                                      -

                                                                                      调度器支持

                                                                                      -

                                                                                      有时候 Reactive 扩展库需要执行一些可调度的操作，例如 Observable#timer 方法将创建一个能周期性发射事件的定时器并返回之。缺省情况下，这些可调度的操作由 RxJava 管理，这意味着定时器线程并非 Vert.x 线程，因此（这些操作）并不是在 Vert.x Event Loop 线程上执行的。

                                                                                      -

                                                                                      在 RxJava 中，有些操作通常会有接受一个 rx.Scheduler 参数的重载方法用于设定 Scheduler。RxHelper 类提供了一个 RxHelper.scheduler 方法，其返回的调度器可供 RxJava 的这些方法使用。比如：

                                                                                      -
                                                                                      Scheduler scheduler = RxHelper.scheduler(vertx);
-Observable<Long> timer = Observable.timer(100, 100, TimeUnit.MILLISECONDS, scheduler);
-
                                                                                      -

                                                                                      对于阻塞型的可调度操作（blocking scheduled actions），我们可以通过 RxHelper.blockingScheduler 方法获得适用的调度器：

                                                                                      -
                                                                                      Scheduler scheduler = RxHelper.blockingScheduler(vertx);
-Observable<Integer> obs = blockingObservable.observeOn(scheduler);
-
                                                                                      -

                                                                                      RxJava 也能被配置成使用 Vert.x 的调度器，这得益于 RxHelper.schedulerHook 方法创建的调度器钩子对象。对于 IO 操作这里使用了阻塞型的调度器：

                                                                                      -
                                                                                      RxJavaSchedulersHook hook = RxHelper.schedulerHook(vertx);
-RxJavaHooks.setOnIOScheduler(f -> hook.getIOScheduler());
-RxJavaHooks.setOnNewThreadScheduler(f -> hook.getNewThreadScheduler());
-RxJavaHooks.setOnComputationScheduler(f -> hook.getComputationScheduler());
-
                                                                                      -

                                                                                      Rx化的 Vert.x API 在 RxHelper 类中也提供了相似的方法：

                                                                                      -
                                                                                      Scheduler scheduler = io.vertx.rxjava.core.RxHelper.scheduler(vertx);
-Observable<Long> timer = Observable.interval(100, 100, TimeUnit.MILLISECONDS, scheduler);
-
                                                                                      -
                                                                                      RxJavaSchedulersHook hook = io.vertx.rxjava.core.RxHelper.schedulerHook(vertx);
-RxJavaHooks.setOnIOScheduler(f -> hook.getIOScheduler());
-RxJavaHooks.setOnNewThreadScheduler(f -> hook.getNewThreadScheduler());
-RxJavaHooks.setOnComputationScheduler(f -> hook.getComputationScheduler());
-
                                                                                      -

                                                                                      基于一个命名的工作线程池（named worker pool）创建调度器也是可以的，如果你想为了调度阻塞操作复用特定的线程池，这将会很有帮助：

                                                                                      -
                                                                                      Scheduler scheduler = io.vertx.rxjava.core.RxHelper.scheduler(workerExecutor);
-Observable<Long> timer = Observable.interval(100, 100, TimeUnit.MILLISECONDS, scheduler);
-
                                                                                      -

                                                                                      JSON解码

                                                                                      -

                                                                                      RxHelper.unmarshaller 方法创建了一个 rx.Observable.Operator 对象，这个操作符的作用是将 Observable<Buffer> 变换为对象的 Observable：

                                                                                      -
                                                                                      fileSystem.open("/data.txt", new OpenOptions(), result -> {
-  AsyncFile file = result.result();
-  Observable<Buffer> observable = RxHelper.toObservable(file);
-  observable.lift(RxHelper.unmarshaller(MyPojo.class)).subscribe(
-      mypojo -> {
-        // 处理对象
-      }
-  );
-});
-
                                                                                      -

                                                                                      Rx化的辅助类也能做同样的事：

                                                                                      -
                                                                                      fileSystem.open("/data.txt", new OpenOptions(), result -> {
-  AsyncFile file = result.result();
-  Observable<Buffer> observable = file.toObservable();
-  observable.lift(io.vertx.rxjava.core.RxHelper.unmarshaller(MyPojo.class)).subscribe(
-      mypojo -> {
-        // 处理对象
-      }
-  );
-});
-
                                                                                      -

                                                                                      部署Verticle

                                                                                      -

                                                                                      Rx化的 API 不能部署一个已经存在的 Verticle 实例。RxHelper.observableFuture 方法为此提供了一个解决方案。

                                                                                      -

                                                                                      所有工作都在 RxHelper.deployVerticle 方法里自动完成，它会部署一个 Verticle 并返回包含部署 ID 的 Observable<String>。

                                                                                      -
                                                                                      Observable<String> deployment = RxHelper.deployVerticle(vertx, verticle);
-
-deployment.subscribe(id -> {
-  // 部署成功
-}, err -> {
-  // 部署失败
-});
-
                                                                                      -

                                                                                      HttpClient GET on subscription

                                                                                      -

                                                                                      对于通过订阅执行一个 HTTP GET 请求这样的需求，利用 RxHelper.get 方法是很适合的：

                                                                                      -
                                                                                      Observable<HttpClientResponse> get = RxHelper.get(client, "http://the-server");
-
-// 执行请求
-get.subscribe(resp -> {
-  // 获得响应
-}, err -> {
-  // 出错了
-});
-
                                                                                      -
                                                                                      -

                                                                                      警告：执行 GET 请求时，这个 API 和 HttpClient 是不同的。当方法被调用时，它会返回一次性的 Observable。

                                                                                      -
                                                                                      -

                                                                                      Rxified API

                                                                                      -

                                                                                      Rx化的 API 是 Vert.x API 的一个代码自动生成版本，就像 Vert.x 的 JavaScript 或 Groovy 版本一样。这个 API 以 io.vertx.rxjava 为包名前缀，例如 io.vertx.core.Vertx 类被转化为 ·io.vertx.rxjava.core.Vertx·类。

                                                                                      -

                                                                                      Embedding Rxfified Vert.x

                                                                                      -

                                                                                      只需使用 Vertx.vertx 方法：

                                                                                      -
                                                                                      Vertx vertx = io.vertx.rxjava.core.Vertx.vertx();
-
                                                                                      -

                                                                                      作为Verticle

                                                                                      -

                                                                                      通过继承 AbstractVerticle 类，它会做一些包装（你将获得一个 RxJava Verticle）：

                                                                                      -
                                                                                      class MyVerticle extends io.vertx.rxjava.core.AbstractVerticle {
-  public void start() {
-    // Use Rxified Vertx here
-  }
-}
-
                                                                                      -

                                                                                      部署一个 RxJava Verticle 不需要特别的部署器，使用 Java 部署器即可。

                                                                                      -

                                                                                      API 样例

                                                                                      -

                                                                                      让我们通过研究一些样例来了解相关 API 吧。

                                                                                      -

                                                                                      Event Bus 消息流

                                                                                      -

                                                                                      很自然地，MessageConsumer 类提供了相关的 Observable<Message<T>>：

                                                                                      -
                                                                                      EventBus eb = vertx.eventBus();
-MessageConsumer<String> consumer = eb.<String>consumer("the-address");
-Observable<Message<String>> observable = consumer.toObservable();
-Subscription sub = observable.subscribe(msg -> {
-  // 获得消息
-});
-
-// 10秒后注销
-vertx.setTimer(10000, id -> {
-  sub.unsubscribe();
-});
-
                                                                                      -

                                                                                      MessageConsumer 类提供了 Message 的流，如果需要，还可以通过 body 方法获得消息体组成的新流：

                                                                                      -
                                                                                      EventBus eb = vertx.eventBus();
-MessageConsumer<String> consumer = eb.<String>consumer("the-address");
-Observable<String> observable = consumer.bodyStream().toObservable();
-
                                                                                      -

                                                                                      RxJava 的 map/reduce 组合风格在这里是相当有用的：

                                                                                      -
                                                                                      Observable<Double> observable = vertx.eventBus().
-    <Double>consumer("heat-sensor").
-    bodyStream().
-    toObservable();
-
-observable.
-    buffer(1, TimeUnit.SECONDS).
-    map(samples -> samples.
-        stream().
-        collect(Collectors.averagingDouble(d -> d))).
-    subscribe(heat -> {
-      vertx.eventBus().send("news-feed", "Current heat is " + heat);
-    });
-
                                                                                      -

                                                                                      定时器

                                                                                      -

                                                                                      定时器任务可以通过 timerStream 方法来创建：

                                                                                      -
                                                                                      vertx.timerStream(1000).
-    toObservable().
-    subscribe(
-        id -> {
-          System.out.println("Callback after 1 second");
-        }
-    );
-
                                                                                      -

                                                                                      周期性的任务可以通过 periodicStream 方法来创建：

                                                                                      -
                                                                                      vertx.periodicStream(1000).
-    toObservable().
-    subscribe(
-        id -> {
-          System.out.println("Callback every second");
-        }
-    );
-
                                                                                      -

                                                                                      通过注销操作可以取消对 Observable 的订阅：

                                                                                      -
                                                                                      vertx.periodicStream(1000).
-    toObservable().
-    subscribe(new Subscriber<Long>() {
-      public void onNext(Long aLong) {
-        // 回调
-        unsubscribe();
-      }
-      public void onError(Throwable e) {}
-      public void onCompleted() {}
-    });
-

                                                                                      HTTP客户端请求

                                                                                      -

                                                                                      toObservable 方法提供了带有 HttpClientResponse 对象的一次性回调，请求错误同样会在 Observable 中反映处理。

                                                                                      -
                                                                                      HttpClient client = vertx.createHttpClient(new HttpClientOptions());
-HttpClientRequest request = client.request(HttpMethod.GET, 8080, "localhost", "/the_uri");
-request.toObservable().subscribe(
-    response -> {
-      // 处理响应
-    },
-    error -> {
-      // 无法连接
-    }
-);
-request.end();
-
                                                                                      -

                                                                                      通过 toObservable 方法可以将响应当成 Observable<Buffer> 来处理：

                                                                                      -
                                                                                      request.toObservable().
-    subscribe(
-        response -> {
-          Observable<Buffer> observable = response.toObservable();
-          observable.forEach(
-              buffer -> {
-                // 处理 buffer
-              }
-          );
-        }
-    );
-
                                                                                      -

                                                                                      flatMap 操作也能获得同样的流：

                                                                                      -
                                                                                      request.toObservable().
-    flatMap(HttpClientResponse::toObservable).
-    forEach(
-        buffer -> {
-          // Process buffer
-        }
-    );
-
                                                                                      -

                                                                                      通过静态方法 RxHelper.unmarshaller ，我们也能将 Observable<Buffer> 重组为对象。这个方法创建了一个 Rx.Observable.Operator（Rx 操作符）供重组操作使用：

                                                                                      -
                                                                                      request.toObservable().
-    flatMap(HttpClientResponse::toObservable).
-    lift(io.vertx.rxjava.core.RxHelper.unmarshaller(MyPojo.class)).
-    forEach(
-        pojo -> {
-          // Process pojo
-        }
-    );
-
                                                                                      -

                                                                                      HTTP服务端请求

                                                                                      -

                                                                                      requestStream 方法对到达的每个请求都提供了回调：

                                                                                      -
                                                                                      Observable<HttpServerRequest> requestObservable = server.requestStream().toObservable();
-requestObservable.subscribe(request -> {
-  // 处理请求
-});
-
                                                                                      -

                                                                                      HttpServerRequest 可以被适配为 Observable<Buffer>：

                                                                                      -
                                                                                      Observable<HttpServerRequest> requestObservable = server.requestStream().toObservable();
-requestObservable.subscribe(request -> {
-  Observable<Buffer> observable = request.toObservable();
-});
-
                                                                                      -

                                                                                      RxHelper.unmarshaller 方法可以用来解析 JSON 格式的请求并将其映射为对象：

                                                                                      -
                                                                                      Observable<HttpServerRequest> requestObservable = server.requestStream().toObservable();
-requestObservable.subscribe(request -> {
-  Observable<MyPojo> observable = request.
-      toObservable().
-      lift(io.vertx.rxjava.core.RxHelper.unmarshaller(MyPojo.class));
-});
-
                                                                                      -

                                                                                      WebSocket客户端

                                                                                      -

                                                                                      当 WebSocket 连接上或失败时，websocketStream 方法对此提供了一次性的回调：

                                                                                      -
                                                                                      HttpClient client = vertx.createHttpClient(new HttpClientOptions());
-client.websocketStream(8080, "localhost", "/the_uri").toObservable().subscribe(
-    ws -> {
-      // Use the websocket
-    },
-    error -> {
-      // Could not connect
-    }
-);
-
                                                                                      -

                                                                                      WebSocket 对象可以轻松地转换为 Observable<Buffer>：

                                                                                      -
                                                                                      socketObservable.subscribe(
-    socket -> {
-      Observable<Buffer> dataObs = socket.toObservable();
-      dataObs.subscribe(buffer -> {
-        System.out.println("Got message " + buffer.toString("UTF-8"));
-      });
-    }
-);
-
                                                                                      -

                                                                                      WebSocket服务端

                                                                                      -

                                                                                      每当有新连接到达时，websocketStream 方法都会提供一次回调：

                                                                                      -
                                                                                      Observable<ServerWebSocket> socketObservable = server.websocketStream().toObservable();
-socketObservable.subscribe(
-    socket -> System.out.println("Web socket connect"),
-    failure -> System.out.println("Should never be called"),
-    () -> {
-      System.out.println("Subscription ended or server closed");
-    }
-);
-
                                                                                      -

                                                                                      ServerWebSocket 对象可以轻松地转换为 Observable<Buffer>：

                                                                                      -
                                                                                      socketObservable.subscribe(
-    socket -> {
-      Observable<Buffer> dataObs = socket.toObservable();
-      dataObs.subscribe(buffer -> {
-        System.out.println("Got message " + buffer.toString("UTF-8"));
-      });
-    }
-);
-
                                                                                      -
                                                                                      -
                                                                                      -

                                                                                      原文档最后更新于 2017-03-15 15:54:14 CET

                                                                                      -
                                                                                      - - -
                                                                                      - -
                                                                                      -
                                                                                      -
                                                                                      - -

                                                                                      results matching ""

                                                                                      -
                                                                                        - -
                                                                                        -
                                                                                        - -

                                                                                        No results matching ""

                                                                                        - -
                                                                                        -
                                                                                        -
                                                                                        - -
                                                                                        -
                                                                                        - -
                                                                                        - - - - - - - - - - - - - - -
                                                                                        - - -
                                                                                        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/reactive/Sync.html b/docs/reactive/Sync.html deleted file mode 100644 index 1980069..0000000 --- a/docs/reactive/Sync.html +++ /dev/null @@ -1,1150 +0,0 @@ - - - - - - - Vert.x Sync · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                        -
                                                                                        - - - - - - - - -
                                                                                        - -
                                                                                        - -
                                                                                        - - - - - - - - -
                                                                                        -
                                                                                        - -
                                                                                        -
                                                                                        - -
                                                                                        - -

                                                                                        Vert.x Sync

                                                                                        - -

                                                                                        中英文对照表

                                                                                        -
                                                                                          -
                                                                                        • bytecode instrumentation：字节码修改/增强
                                                                                          • -
                                                                                        • kernel thread：内核线程
                                                                                          • -
                                                                                        -

                                                                                        简介

                                                                                        -

                                                                                        Vert.x Sync 是一组工具集，其特点是在不阻塞内核线程的同时，允许用户以同步的方式接收事件、执行异步操作。

                                                                                        -

                                                                                        比起很多历史遗留的应用系统，Vert.x 的一个关键优点是完全非阻塞(于内核线程而言) —— 这使它用少量的内核线程就可以处理大量的并发(例如，处理很多的连接、消息之类)，具有优异的可扩展性。

                                                                                        -

                                                                                        Vert.x 非阻塞性的特性产生了异步的 API 。异步 API 可以有多种风格，包括回调、Promise和Rx风格。Vert.x 在绝大多数地方使用回调(尽管它也支持Rx)。

                                                                                        -

                                                                                        某些情况下，使用异步 API 编程比直接使用同步 API 要更具挑战，特别是当你有好几个操作要按顺序完成时。同时，使用异步 API 时，错误的传递也会变得更复杂。

                                                                                        -

                                                                                        Vert.x Sync 可以让你在熟悉的同步风格下继续使用异步 API 。

                                                                                        -

                                                                                        在此，通往自由之路的功臣乃 Fiber(译者注：这个词国内有译作纤程，类似协程-coroutine)。Fiber 是超轻量级的线程，并不是对应于底层的那种内核线程，它们被阻塞时不会导致内核线程也被阻塞。

                                                                                        -

                                                                                        Vert.x 借助 Quasar 库来实现 Fiber。

                                                                                        -
                                                                                        -

                                                                                        注意：Vert.x Sync 当前只适用于 Java 。

                                                                                        -
                                                                                        -

                                                                                        SyncVerticle

                                                                                        -

                                                                                        要使用 Vert.x Sync 库，你的代码需要继承 io.vertx.ext.sync.SyncVerticle 类，并重载start()方法和stop()方法(stop 非必需)。

                                                                                        -

                                                                                        这些方法还必须加上 @Suspendable 注解。

                                                                                        -

                                                                                        写好的 Sync Verticle，其部署方法和其他 Verticle 完全一样。

                                                                                        -

                                                                                        Instrumentation

                                                                                        -

                                                                                        Vert.x 用到了 Quasar 库，这个库借助字节码增强(bytecode instrumentation)的技术实现了 Fiber。字节码增强工作是在运行时使用 Java Agent 技术完成的。

                                                                                        -

                                                                                        为了使这个特性正常工作，需要在启动 JVM 时指定 quasar-core jar包为 Java Agent jar 包：

                                                                                        -
                                                                                        -javaagent:/path/to/quasar/core/quasar-core.jar
-
                                                                                        -

                                                                                        如果你用的是 vertx 命令行工具，可以在执行 vertx 前设置环境变量 ENABLE_VERTX_SYNC_AGENT 为 ture，这样可以启用 Agent 的配置。

                                                                                        -

                                                                                        你也可以使用 quasar-maven-plugin 达成离线增强(offline instrumentation，指非运行时织入字节码)的效果。更多细节请参考 Quasar 官方文档。

                                                                                        -

                                                                                        获得一次性的异步操作结果

                                                                                        -

                                                                                        在Vert.x 的领域里，很多操作都会接受一个 Handler<AsyncResult<T>> 作为最后的参数，例如用 Vert.x 的 Mongo 客户端执行一次查询或者发送一个 Event Bus 消息然后拿到回应。

                                                                                        -

                                                                                        Vert.x Sync 可以让你用同步的方式得到这种一次性的异步操作的结果。这是通过调用 Sync.awaitResult 方法完成的。调用这个方法时，需将想要执行的异步操作包装成 Consumer 的形式。Handler 参数会在运行时传给此 Consumer 。

                                                                                        -

                                                                                        看下面的例子：

                                                                                        -
                                                                                        EventBus eb = vertx.eventBus();
-
-// Send a message and get the reply synchronously
-
-Message<String> reply = awaitResult(h -> eb.send("someaddress", "ping", h));
-
-System.out.println("Received reply " + reply.body());
-
                                                                                        -

                                                                                        上面的例子中，在回应返回前，Fiber 会一直被阻塞住，而内核线程不会。

                                                                                        -

                                                                                        获得一次性的事件

                                                                                        -

                                                                                        Vert.x Sync 也能以同步的方式获得一次性的事件，例如定时器的触发，或者 end handler（译者注：关于 end handler 的例子可以参见 Vert.x Core 文档中 HTTP 服务器与客户端 一节）的执行。这是通过 Sync.awaitEvent 方法完成成的。

                                                                                        -

                                                                                        看下面的例子：

                                                                                        -
                                                                                        long tid = awaitEvent(h -> vertx.setTimer(1000, h));
-
-System.out.println("Timer has now fired");
-
                                                                                        -

                                                                                        事件流

                                                                                        -

                                                                                        很多时候，Vert.x 的 Handler 接收到的是事件流，例如 Event Bus 消息的消费者(Consumer)、HTTP 服务端里的 HTTP 服务端请求(server request)。

                                                                                        -

                                                                                        Vert.x Sync 使你能以同步的方式从这种流中接收事件。

                                                                                        -

                                                                                        你需要一个同时实现了 Handler 和 Receiver 接口的 HandlerReceiverAdaptor 类实例。Sync.streamAdaptor 方法可以创建这样一个实例。

                                                                                        -

                                                                                        你可以把它当成一个普通的 Handler ，然后可以用实现自 Receiver 接口的方法来同步地接收事件。

                                                                                        -

                                                                                        下面是一个 Event Bus 消息消费者的例子：

                                                                                        -
                                                                                        EventBus eb = vertx.eventBus();
-
-HandlerReceiverAdaptor<Message<String>> adaptor = streamAdaptor();
-
-eb.<String>consumer("some-address").handler(adaptor);
-
-// Receive 10 messages from the consumer:
-for (int i = 0; i < 10; i++) {
-
-  Message<String> received1 = adaptor.receive();
-
-  System.out.println("got message: " + received1.body());
-
-}
-
                                                                                        -

                                                                                        使用 FiberHandler

                                                                                        -

                                                                                        如果你想在一般的 Handler 中使用 Fiber —— 例如 HTTP 服务端的请求处理器（request handler） ，那得首先把这个一般的 Handler 转换为 Fiber Handler 。

                                                                                        -

                                                                                        Fiber Handler 会在 Fiber 里运行那个一般的 Handler 。

                                                                                        -

                                                                                        看例子：

                                                                                        -
                                                                                        EventBus eb = vertx.eventBus();
-
-vertx.createHttpServer().requestHandler(fiberHandler(req -> {
-
-  // Send a message to address and wait for a reply
-  Message<String> reply = awaitResult(h -> eb.send("some-address", "blah", h));
-
-  System.out.println("Got reply: " + reply.body());
-
-  // Now end the response
-  req.response().end("blah");
-
-})).listen(8080, "localhost");
-
                                                                                        -

                                                                                        更多示例

                                                                                        -

                                                                                        在 Examples Repository 这里有一些示例，展示了 vertx-sync 的用法。

                                                                                        -
                                                                                        -
                                                                                        -

                                                                                        原文档最后更新于 2017-03-15 15:54:14 CET

                                                                                        -
                                                                                        - - -
                                                                                        - -
                                                                                        -
                                                                                        -
                                                                                        - -

                                                                                        results matching ""

                                                                                        -
                                                                                          - -
                                                                                          -
                                                                                          - -

                                                                                          No results matching ""

                                                                                          - -
                                                                                          -
                                                                                          -
                                                                                          - -
                                                                                          -
                                                                                          - -
                                                                                          - - - - - - - - - - -
                                                                                          - - -
                                                                                          - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/search_index.json b/docs/search_index.json deleted file mode 100644 index 6eeedbb..0000000 --- a/docs/search_index.json +++ /dev/null @@ -1 +0,0 @@ -{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["./","3.4.1。","buil","chines","cli","dev","doc","g","git","gitbook","github","https://nodejs.org/en/download/","instal","master","nodej","npm","page","sudo","translat","vert.x","vert.x中国用户社区默认获得所有翻译内容的发布权。","上。使用","中国用户组发动社区内的志愿者翻译","为主版本分支，主要进行里程碑式的发布；dev","为开发分支，日常的提交都在","主要分为两个分支，master","介绍","使用本仓库进行翻译工作的协作。git","具体见翻译计划文档。","分支上边。基本两个分支足够使用，但可以根据每个人的喜好创建个人分支，不做约束。","分支的","协作","命令行工具","和","在中国越来越受到关注，使用人数也越来越多，但相关的中文文档却寥寥可数，在这样的背景下，vert.x","在线地址：https://vertxchina.github.io/vertx","安装","官方文档。","官方文档中文翻译","官方文档中文翻译的仓库。","归属与发布","当前文档翻译对应版本：vert.x","我们力求做到第一境界即可。信：即译文要准确，不偏离，不遗漏，也不要随意增减意思。","本着开源的精神，贡献先于索取，自愿自发的为社区，为社会贡献，才能为后人造福。","本项目的在线版本部署在","构建","构建方法","每个模块由一人主导翻译，二人主导校对，校对的人反馈给翻译的人修改，或获得同意后直接修改，三人都确认无误后，合并到主分支上。","每个翻译模块归属于翻译者所有，如果需要发布不属于自己翻译的模块，那么需要与翻译者协商获得许可后发布。","注意一定要输出到","理念","目录作为生成的","目录，才能被","目标","确定翻译内容后，将会把内容分模块，每人根据自己实际的时间情况领取翻译","站点。以下是构建方法：","翻译三个境界：信，达，雅。","翻译人员在领取翻译任务后尽可能在自己评估的时间内完成，校对人员校对任务同理，如无法完成则告知大家，多次无理由延期的，自动退出翻译小组。","翻译协作","翻译计划","背景","识别","这是针对","进入项目根目录","随着"],"start/Start.html":["\"/\",","\"localhost\",","\"text/plain\")","${main.class}","${main.verticle}","${project.build.directory}/${project.artifactid}","${project.version}","${vertx.version}","*","*/",".end(\"hello",".putheader(\"cont","/**","1.0","1.8","2.4.2","26/04/2017.","3.3","3.4.1","3以上版本需要java","4.0.0","4.12","8以上版本方能运行；","=",">","@after","@befor","@runwith(vertxunitrunner.class)","@test","abstractverticl","args){","async","async.complete();","chengen","class","clean","compil","context)","context.asserttrue(body.tostring().contains(\"hello\"));","context.async();","context.asyncassertsuccess());","core","creat","ee或者是java","exampl","extend","final","hello","import","io.exampl","io.example.main","io.example.mainverticl","io.example;","io.vertx","io.vertx.core.abstractverticle;","io.vertx.core.launch","io.vertx.core.vertx;","io.vertx.ext.unit.async;","io.vertx.ext.unit.junit.vertxunitrunner;","io.vertx.ext.unit.testcontext;","jar","jar。","java","java基础知识，您不需要了解java","java的知识点。请注意：vert.x","junit","main","main(string[]","main.java","mainverticl","maven","maven相关知识，您需要知道什么maven是做什么用的，以及如何使用maven；","me的知识，但是需要您对java有所了解，在此文档中，我们不会介绍任何关于java","myfirstverticl","myfirstverticle.java","myfirstverticletest","org.apache.maven.plugin","org.junit.after;","org.junit.before;","org.junit.runner.runwith;","org.junit.test;","packag","package命令打包。","package命令打包，随后在src的同级目录下会出现target目录，进入之后，会出现vert","plugin","plugin和maven","plugin插件的manifestentries的main","plugin，前者用来将.java的源文件编译成.class的字节码文件，后者可将编译后的.class字节码文件打包成可执行的jar文件，俗称fat","pom.xml","privat","prod.jar","prod.jar两个jar文件，后者是可执行文件，在有图形界面的操作系统中，您可双击执行，或者用以下命令：java","prod.jar执行。","public","req.response()","resourc","respons","response.handler(bodi","setup(testcontext","se又称cor","shade","snapshot","snapshot.jar和vert","src","start","start()","static","teardown(testcontext","test","testapplication(testcontext","type\",","unit","vert","verticle对应的值，最后修改main.class为io.vertx.core.launcher，修改后的pom.xml如下：","vertx","vertx.close(context.asyncassertsuccess());","vertx.createhttpclient().getnow(8080,","vertx.createhttpserver().requesthandler(req","vertx.deployverticle(myfirstverticle.class.getname());","vertx.deployverticle(myfirstverticle.class.getname(),","vertx.vertx();","vertx;","void","world","world!\");","world!。","world!啦。","world例子，但在此之前，我们需要您具备有以下基础知识：","world字符串。","world开始，下面我们将引导您制作一个最基本简单的hello","{","}","}).listen(8080);","});","│","└──","├──","下面我们将会介绍测试部分，首先引入两个新的测试依赖，修改后的pom.xml如下：","互联网的基础知识，知道什么是网络协议，尤其是tcp，http协议。","便可看到熟悉的hello","启动器","开始使用","我们也可以使用launcher来替代main类，这也是官方推荐的方式，在pom.xml中加入main.verticle属性，并将该属性值设置为maven","执行该测试案例便可得到期望的结果，理解测试代码并不难，留给读者作为练习。","本文将会建立一个基本的http服务器，并监听8080端口，对于任何发往该服务器以及端口的请求，服务器会返回一个hello","欢迎来到vert.x的世界，相信您在接触vert.x的同时，迫不及待想动手试一试，如您在学习计算机其它知识一样，总是从hello","测试","然后在src/main/java/io/example目录下新增mainverticle.java文件，代码如下：","然后我们在src/main/java/io/example目录下新建两个java文件，分别是main.java和myfirstverticle.java，代码如下：","然后用maven的mvn","然后重新打包后执行，便可再次看到hello","至此，大功告成，欢迎来到vert.x的世界。","请注意：重新打包之前，您可能需要清除之前编译后留下的文件，用mvn","跟其它maven项目一样，我们首先定义了项目的groupid，artifactid以及版本号，随后我们定义了两个属性，分别是：vertx.version，也就是vert.x的版本号，此处我们使用最新的vert.x版本，也就是3.4.1；以及main.class，也就是我们要使用的包含有main函数的主类。之后我们引入了两个maven插件，分别是maven","随后在pom.xml中加入相关的依赖和插件，如下所示：","随后在src/test/java/io/example目录下新增myfirstverticletest.java文件：","随后打开浏览器，在浏览器的地址栏中输入：http://localhost:8080/","首先新建一个maven项目，一个基本的maven项目目录结构如下所示："],"start/SimpleStart.html":["\"io.example.main\"//指定main函数所在的类","\"io.example.mainverticle\"//新增main","\"io.vertx.core.launcher\",//改为launch","\"main","\"text/plain\")","'1.0","'4.12'","'io.example'","'io.example'//对应刚刚向导中输入的","'io.vertx:vertx","'java'","'junit',","*","*/","...",".end(\"hello",".putheader(\"cont","/**","//以下部分新增","1.0","1.8","1.8//新增","1.8版本的基础知识，因为vert.x","26/04/2017.","3以上版本要求java","8以上版本方可运行，且大量应用了1.8加入的新语法糖，比如匿名函数lambda。",":","=",">",">build",">gradle项目",">jar，双击执行，便可在build/libs文件夹下生成可执行的jar文件，我生成的是vertxexampl",">next",">task",">勾选use",">填入groupid（也就是你所在组织的名字，例如io.example）和artifactid（也就是项目的名字，例如vertxexample）","?","abstractverticl","appli","args){","attribut","auto","automatically（为空内容建立文件夹结构）","build.gradl","chengen","class","class\":","compil","configurations.compile.collect","content","core:3.4.1'","core:3.4.1'//新增","core的依赖","creat","depend","directori","ee的支持，幸运的是，我们不需要使用这些貌似很牛逼其实无用的功能，用社区版就好了。下载后安装。","empti","extend","finish，随后会建立以下文件结构，跟maven文件夹结构几乎一样：","foolish.","group","group:","groupid，artifactid在settings.gradle中","hello","hungry.","idea，有两个版本，社区版（community）和终极版（ultimate），后者需要付费使用，相比起前者而言，多了很多java","idea，选择创建新项目","import","import（自动引入）以及cr","io.example;","io.vertx.core.abstractverticle;","io.vertx.core.vertx;","it.isdirectory()","jar","jar文件本质上就是一个zip文件，可以用打开zip的压缩工具解压，读者可自行解压拆开jar包，看看相关依赖的文件是否在里面。比如例子中的代码除了生成io.example.myfirstverticle.class和io.example.mainverticle.class文件以外，还同时将依赖的io.vertx.core中的内容压入jar包。","java","main","main(string[]","main.java","mainverticl","manifest","mavencentral()","myfirstverticl","myfirstverticle.java","name:","packag","plugin:","public","repositori","req.response()","resourc","root","settings.gradl","simplestart","simplestart将会使用gradle，而非maven来简化相关设置。","simplestart将会使用ide，也就是集成开发环境来简化开发流程；","snapshot'","snapshot.jar执行。","snapshot.jar，在有图形界面的操作系统中，您可双击执行，或者用以下命令：java","sourcecompat","src","start()","static","stay","targetcompat","test","testcompil","type\",","version","version:","vert.x","verticle\":","verticle属性，对应mainverticle类","vertx","vertx.createhttpserver().requesthandler(req","vertx.deployverticle(myfirstverticle.class.getname());","vertx.vertx();","vertxexampl","void","world","world!\");","world!。","world!啦。","world字符串。与start部分不同的是：","ziptree(it)","{","}","}).listen(8080);","│","└──","├──","一点知识","便可看到熟悉的hello","免费下载集成开发环境（ide）intellij","启动器","如果您是java新手，对于命令行感到发怵的话，我们特意为您准备了可视化傻瓜化入门教程，以降低vert.x的入门门槛。但是再怎么傻瓜，也还是需要您具备有基本的java语法知识，我们并不会在此介绍任何关于java的语法知识，尤其是java","我们也可以使用launcher来替代main类，这也是官方推荐的方式，修改build.gradle如下：","本文将会建立一个基本的http服务器，并监听8080端口，对于任何发往该服务器以及端口的请求，服务器会返回一个hello","然后启动intellij","然后在src/main/java/io/example目录下新增mainverticle.java文件，代码如下：","然后我们在src/main/java/io/example目录（是的，您需要新建io和example两级文件夹）下新建两个java文件，分别是main.java和myfirstverticle.java，代码如下：","然后重新打包后执行，便可再次看到hello","简易教程","至此，大功告成，欢迎来到vert.x的世界。","随后修改build.gradle为：","随后打开浏览器，在浏览器的地址栏中输入：http://localhost:8080/","随后点开ide右边的gradle窗口","首先去jetbrain官方网站：www.jetbrains.com"],"start/FAQ.html":["\"***\")","\"...\")","\"...\");","\"db","\"message\",","\"somemessage\",","'message');","(3.4.0+)","(except","(res.failed())",")",").compose((msg)",").sethandler((res)",");","*","*/",".put(\"jdbcurl\",",".put(\"maximumpoolsize\",",".put(\"password\",",".put(\"provider_class\",",".put(\"username\",","/**","//blablabla","//deal","//use","//以上和以下两种写法是等效的","//以下程序先向address1发送一个message，然后等address1回复之后，将address1的回复消息发送给address2，最后将address2的回复打印到控制台上","//使用future之后，用completer方法填充参数","//创建客户端","//将回调函数存入future中，从而实现代码的扁平化","//将客户端对象与verticle对象绑定，这里选取了三种不同的客户端作为示范","//或","//未使用future时，回调函数嵌在send方法内部，以匿名函数的形式作为send的参数","0;//属性变量","21/04/2017.","30)","=",">",">ctx.reroute(\"/static/index.html\"));",">{",">{//blablabla}就是一个处理器（handler），在随后的例子中，我们用1sthandler以及2ndhandler来指代具体的匿名函数，让代码更加清晰明了，放在verticle中类似：","abstractverticl","abstractverticle{","actor","address1","address2","address3","akka","api","asyncresult","asyncresult.result().body(),","asyncresult2","asyncresult，而是具体的返回内容），需要返回一个新的需要链接的","bean","bean(singleton)","callable,","catch","chengen","class","client","completablefuture.thencompose()，也很接近于","compos","config","config);","creat","e)","ecmascript6","ejb","eventbu","except","executor,","executorservice等这些并发和线程相关的东西就不再需要使用了，可以由verticle全面接管，如果您不得不在vert.x代码中使用上诉内容，则多少暗示着您的设计或者使用vert.x的姿势出现了问题，建议再斟酌商榷一下。","extend","f","f)","f;","false，可以通过","faq","function","function方法当且仅当前一个异步流程执行成功时才会被调用。","function，funct","function，该","futur","future)","future);","future.>future((future)","future.>future(f","future.completer());","future.compos","future.compose(messag","future.futur","future.future();","future.sethandler(asyncresult","future1","future1);","future1.sethandler(asyncresult","future2","future2);","future2.sethandler(asyncresult","future>","future。","future，针对每一个异步的过程，需要在代码中声明中间变量","go","goroutin","handler","handler，res.successed()","handler，因此你可以将它直接作为回调的","hashtable,","here?\");","http://localhost:8080","http://localhost:8081","httpclient","httpclient;","https://en.wikipedia.org/wiki/futures_and_promis","i++;","if(asyncresult.failed()){","if(asyncresult.succeeded()){","import","int","io.vertx.core.abstractverticle;","io.vertx.core.http.httpclient;","io.vertx.core.json.jsonobject;","io.vertx.ext.jdbc.jdbcclient;","io.vertx.ext.web.client.webclient;","java中，lambda本身也是一个对象，是一个@functionalinterface的对象，verticle对象中包含了一个或者多个处理器（handler）对象，比如上述例子中myverticle中就包含有两个handler。在vert.x中，完成verticle的部署之后，真正调用处理逻辑的入口往往是处理器（handler），vert.x保证同一个普通verticle（也就是eventloop","jdbcclient","jdbcclient.createshared(vertx,","jdbcclient;","jdk1.8","jsonarray）还有buffer，这些对象在传递过程中是不可变的。","jsonobject","jsonobject()","messag","message.body(),","msg.body(),","msg1","msg1);","msg2","msg2);","msg3","multipl","myverticl","name\")","new","node.j","promis","public","reactor","req.response().end();//要关闭请求，否则连接很快会被占满","req.response().end(“”+i);","res.cause()","res.result()","res.successed()","result","return","return;","router.route(\"/\").handler(ctx","runnable,","safe/线程安全的，verticle之间传递的数据是immutable/不可改变的。","send","send('address1',","send('address2',","send('address3',","session","spring","standard","start()","start(){","stateless","string","system.out.println(\"whi","system.out.println(asyncresult.cause());","system.out.println(asyncresult.result().body());","system.out.println(asyncresult2.result().body());","system.out.println(i);","task,","theverticl","thread","thread,","threadedwork","throw","tri","true，可以通过","user","vector,","vert.x","vert.x的handler内部是atomic/原子操作，verticle内部是thread","vert.x线程模型保证verticle内部代码线程安全，同时要求在verticle之间传递的消息是不可变的，通过此方法保证verticle之间传递的消息也是线程安全的，从而进一步保证vert.x内部整体是线程安全的，从而将开发人员从繁琐的，容易错的各种多线程并发问题中解脱出来。","verticl","verticle中。","verticle则没有此限制，需要开发者手工处理并发冲突，我们并不推荐这类操作。","verticle对象则会被worker线程所共享，会依次顺序访问，但不会并发同时访问，如果声明为multipl","verticle）内部的所有处理器（handler）都只会由同一个eventloop线程调用，由此保证verticle内部的线程安全。所以我们可以放心地在verticle内部声明各种线程不安全的属性变量，并在handler中分享他们，比如：","verticle，否则verticle内部环境全部都是线程安全的，不会出现多个线程同时访问同一个verticle内部代码的情况。","verticle，非work","vertx.createhttpclient();","vertx.createhttpserver().requesthandler(1sthandler).listen(8080);","vertx.createhttpserver().requesthandler(2ndhandler).listen(8081);","vertx.createhttpserver().requesthandler(req","vertx.eventbus().send(\"address\",","vertx.eventbus().send(\"address\",\"message\",","vertx.eventbus().send(\"address\",message.body(),f.completer());","vertx.eventbus().send(\"address1\",","vertx.eventbus().send(\"address1\",\"message\",","vertx.eventbus().send(\"address2\",","vertx.eventbus().send(\"address3\",","void","webclient","webclient.wrap(httpclient);","webclient;","web中如何将根路径对应到某个特定的html文件？","worker","{","}","}).listen(8080);","}).listen(8081);","});","}els","}else{","一个vert.x实例/进程内有多个eventloop和worker线程，每个线程会部署多个verticle对象并对应执行verticle内的handler，每个verticle内有多个handler，普通verticle会跟eventloop绑定，而work","一个复杂一点的例子：","一个简单粗暴的判断标准：任何涉及到io操作的代码，都可以认为是可能造成阻塞的代码，纯粹内存操作的代码，只要执行时间没有明显超长（例如执行循环几万次的处理便可认为是执行时间超长），都可以认为是非阻塞代码。","上述的例子描述了这样一个流程：","下面我们将这个","为","为了在短时间内完成调度循环，就需要用户正确估算出，哪些程序代码会相对长时间地占用eventloop线程的执行时间，然后将该部分代码的执行交由其它线程去处理。值得注意的是，这里所说的其它线程，可能是内核线程，也就是操作系统的线程，也有可能是用户线程，用户线程中包括了其它应用程序的线程，也就是其它进程中的线程，或者是我们用户自定义的线程。","以上是未使用future时的代码，以下是使用future改造后的代码：","以下两种写法是等效的：","会以一个新的","会抛出一些异常（注意，以下代码只是同步代码的示例，和","传入到异步方法里。该方法的返回值是提供给异步调用使用的","使用","使用组合来实现链式调用","值得注意的是，示范代码可能会抛出nullpointerexception，因为当操作失败时，asyncresult.result()方法返回值为null，此时调用.body()方法会抛出空指针异常，在生产环境中正确写法应该是：","假设我们拿到两个数万个节点的链表（linkedlist），要求删除两个链表的交集，那么在没有任何算法优化的前提下，该操作的时间复杂度是o(n^2)，又因为内存中该链表节点数庞大，多达数万个节点，所以如果在eventloop中执行该操作，将有可能使得执行时间超长，此时需要将这部分代码交由其它线程予以执行，vert.x提供了除了eventloop线程池以外的线程池，名曰worker线程池。此时就需要用户自行将该部分代码包装成worker线程执行的代码，并交给worker线程予以执行，执行完成之后再由eventloop线程执行回调函数处理其结果。注意：vert.x中将代码交给worker线程执行的方式有两种，一种是通过executeblocking函数包装，另外一种是写入work","到","发送消息","变量，使代码更为简洁。","可以看到此时为了保证顺序结构，产生了两层缩进，回调金字塔开始形成，多次缩进之后便会出现所谓的回调地狱，这便是异步开发中为了保证顺序所可能会遇到的问题，那么我们可以通过以下方式解决代码过多缩进的问题：","可以看到，使用了future之后，原先的两层缩进被抽取出来，变成了最多单层的缩进，从而使得代码可读性更强，更加美观。","各个组件的常见问题以及相应的注意事项和解决方案。","在最新的版本中(3.4.0+)，可以通过","在这个例子里，如果任意一个","复杂一点的例子：","如果以上三步全都成功，则同样执行","如果以上任何一步失败，则不会继续执行下一个异步流程，直接执行最终的","如果第一步成功，则发送第一步的消息的返回值到","如果第二步成功，则发送第二部的消息的返回值到","实例。由此可以避免为嵌套的多个异步操作定义不同的","实例为参数被调用。由于","将会看到具体的计数。同理，也可以将i替换成hashmap等线程不安全对象，不需要使用concurrenthashmap或hashtable，可在verticle内部安全使用。","就会使计数器加1，访问","我们来看一个简单的例子：某个程序要求，当前线程发送一个请求给网络上另外一个服务器，然后获取到结果之后作出相应的处理。那么此时有一个明显的io操作，就是发送网络请求并等待对方返回结果。因为网络的速度要远远慢于内存处理的速度，所以此时的操作便是非纯粹内存操作，就有可能造成线程的阻塞，那么此时应该将这个操作交给其它线程予以处理，在处理完成之前，释放当前线程，等处理完成之后，再由当前线程执行回调函数。vert.x自带的网络客户端（netclient，httpclient等）已经帮您包装好了这部分逻辑代码，直接使用netclient等客户端，vert.x就会将发送请求并等待返回结果这部分代码交给另外一个线程予以执行，此时这另外一个线程是内核线程，这部分的异步处理由jvm以及操作系统完成，您不需要自己定义一个线程并执行。类似的，数据库的处理同样涉及io操作，所以vert.x自带的jdbc客户端（jdbcclient）会帮您完成这部分的封装，您只需要直接调用jdbcclient的各种api便可完成操作，此时有可能是其它进程中的线程，比如postgresql会使用进程池来建立连接池，但是该线程亦不需要您去创建，vert.x帮您完成了这些操作。类似的，硬盘上的操作，比如文件系统的api，也有可能造成阻塞，所以vert.x的文件系统api提供了非阻塞api，但是值得说明的是，硬盘上的操作，如果只是少量操作，执行时间上也不会明显超长，所以vert.x同时提供了硬盘操作的阻塞和非阻塞两种api。最后我们来看一个纯粹内存操作同时又是阻塞的例子。","接口提供了","提供的","方法以函数式的方式直接用","方法抛出异常，则会立即跳转到","方法来组织代码最大的价值在于可以","方法来链式地组合多个异步操作。在介绍这个方法的用途时，我们先考虑一个传统的同步操作和异常处理的方式。假设我们有一个同步的方法","方法通过","方法需要传入一个","无关）：","早期版本的","替换为","有一个粗暴简单的判断同步还是异步的方法，就看给出的api或者方法中，是否有回调函数，如果有回调函数，且这个回调函数的参数是asyncresult，则可以判断该api或方法是异步的。","来包装一个异步的代码块，例如：","来包装异步代码块","来处理，不需要针对每一个异步操作都编写异常处理的逻辑。这对于编写复杂的异步流程时是非常有用的。","来对应异步回调，例如上文例子中的：","来获得异常对象","模式的信息还可以参考这里","模式的应用。关于更多","此处会列出常见的关于vert.x","每一个","每次使用客户端完之后，无需调用client.close();方法关闭客户端，频繁创建销毁客户端会在一定程度上消耗系统资源，降低性能，同时增加开发人员的负担，vert.x提供客户端的目的就在于复用连接以减少资源消耗，提升性能，同时简化代码，减轻开发人员的负担。如您关闭客户端，在下一次使用该客户端的时候，需要重新创建客户端。","注意：我们会尽量将原理讲得通俗易懂，但还是要求读者具备有线程，进程，内存，cpu，操作系统，数据库，算法等专业基础知识。","的","的代码块中。","的异步版本，如下：","的的接口约定，其实都是关于","的输入是前一个异步过程的返回值（此处的返回值不是","示范代码中为了解释future的用法简写了代码。","答：future对象提供了一种异步结果的包装，用户可使用future类中的sethandler方法来保存回调函数，然后在原先使用该回调函数的地方用completer方法予以填充，这样便可将回调函数从原参数中取出，以减少回调缩进，从而规避回调地狱，来看一个简单的例子：","答：vert.x中提供了各种预设客户端，例如httpclient，jdbcclient，webclient，mongoclient等，一般情况下，建议将客户端与verticle对象绑定，一个verticle对象内保留一个特定客户端的引用，并在start方法中将其实例化，这样vert.x会在执行deployverticle的时候执行start方法，实例化并保存该对象，在verticle生命周期内，不需要频繁创建和关闭同类型的客户端，建议在verticle的生命周期内对于特定领域，只创建一个客户端并复用该客户端，例如：","答：vert.x其实就是建立了一个verticle内部的线程安全机制，让用户可以排除多线程并发冲突的干扰，专注于业务逻辑上的实现，用了vert.x，您就不用操心多线程和并发的问题了。verticle内部代码，除非声明verticle是work","答：verticle对象往往包含有一个或者多个处理器（handler），在java代码中，后者经常是以lambda也就是匿名函数的形式出现，比如：","答：严格说来，不同框架和语言之间的概念无法一一对应，但如果我们不那么严格地去深究细节，vert.x定义的概念可以从其它框架以及语言中找到一些痕迹，以下是vert.x中定义概念跟其它框架和语言定义概念的比较，同一行中的概念可被认为是相似的：","答：严格说来，要认真看代码文档，比如javadoc，来判断方法是异步还是同步的，如果文档中没有明确说明，则默认是同步的，异步api往往出现在io相关的方法中，所谓io一般认为是涉及到硬盘（比如在硬盘上存取文件），网络（通过网络发送一个请求并获取相应结果），其它进程的操作（操作数据库）等，一般纯粹的，本进程内的内存操作并不被认为是涉及io操作，这个时候将方法或api制作成异步的并无实际意义，所以一般非io相关操作都被认为是同步的，同时并不会占用显著执行时间，所以不会阻塞线程。","答：初次接触vert.x的开发人员往往会在异步，显著执行时间，阻塞等概念理解上遇到一定的困难，在此一并做个解释和说明。","答：因为immutable（不可变的）的东西线程安全，可以被多个线程安全地并发访问，线程在使用的时候拷贝一份也不会有并发问题，java里面字符串（string）对象是immutable（不可变）的，所以缺省情况下事件总线（eventbus）上传递的消息是字符串，vert.x也实现了事件总线上消息类型的编解码器，除了字符串以外，还支持少量的其它类型，比如原始数据类型及其包装类，比如字节流（byte[]），比如json对象（jsonobject,","答：用reroute和statichandler：","自身实现了","获取最后一步的结果。","计算机本质上是计算的机器，任何一个指令的执行，都需要一定的时间予以完成，这个时间可能长可能短，而这些指令的执行，都会分配给一个具体的线程，并在线程中执行完成。在vert.x中，黄金原则是不阻塞eventloop线程，而eventloop顾名思义，是一个事件的循环，可以认为是一个在vert.x生命周期内，不停轮询事件是否发生，并将发生的事件交给handler予以处理的无限调度循环线程。那么为了不停地检查事件是否发生，该线程需要在短时间内完成一个调度循环。如果eventloop在完成一个调度循环的时间过长，就有可能导致新发生的事件得不到及时的处理，进而导致单次事件响应时间过长，影响客户体验。","让异步代码的执行顺序和代码的编写顺序看起来一致，并在任何一步抛出异常时直接退出到最后一个","访问","该","该方法的输入参数是一个","请注意：vert.x中绝大多数涉及io操作除非有明确说明，例如以sync后缀命名的方法，否则均是异步的，另外在vert.x中，eventbus的相关操作也被认为是涉及io操作。","请注意：一般情况下，用了vert.x的verticle之后，原则上synchronized，lock，volatile，static对象，java.util.concurrent,","这个方法的行为现在非常接近于","这里的lambda/匿名函数/req","通过","问：vert.x","问：vert.x中future该如何正确使用，怎样规避回调地狱？","问：vert.x中各种client该如何正确使用，用完是否需要关闭？","问：verticle对象和处理器（handler）是什么关系？vert.x如何保证verticle内部线程安全？","问：为什么verticle之间传递的消息要求是immutable（不可变）的？","问：什么是显著执行时间？什么是异步？如何正确理解文档中说的不要阻塞eventloop？","问：怎样正确理解vert.x机制？","问：我之前有过spring，akka，node.js或go的经验，请问vert.x的概念有我熟悉的吗？","问：我刚拿到一个第三方类库（lib/jars），怎么判断这个类库中的方法是异步还是同步的？有没有简单粗暴的方法可以一眼看出来？","首先通过","，并且"],"core/Core.html":["!=","\"","\"\";","\");","\"/\",","\"/bar\",","\"/blah\");","\"/main.js\",","\"/other","\"/some","\"0.0.0.0\",","\"10.0.0.1\");","\"10.0.0.1\",","\"10.0.0.2\",","\"100","\"1000\").putheader(\"cont","\"1000\");","\"230.0.0.1\",","\"[\\\"foo\\\",\\\"bar\\\"]\";","\"application/json\").","\"application/json\").putheader(\"oth","\"application/json\").set(\"oth","\"bar\").put(\"num\",","\"bar\");","\"bar\",","\"bar.txt\");","\"bar.txt\",","\"classes:lib/myjar.jar\"","\"close\")","\"com.mycompany.somepkg.someclass\",","\"f\",","\"flooble\");","\"foo","\"foo\");","\"foo\",","\"hello\");","\"hello\";","\"index.html\";","\"localhost\");","\"localhost\",","\"myhost.com\");","\"myhost.com\",","\"myserver.mycompany.com\",","\"name\")","\"name\",","\"name\":","\"not","\"num_widgets\":","\"ok\"","\"on","\"org.slf4j.impl.staticloggerbinder\".","\"org.somelibrary.*\"));","\"some","\"sync\"","\"target/classes/readme2.txt\",","\"text/html\").putheader(\"oth","\"text/html\");","\"text/plain\").end(body);","\"text/plain\").write(\"som","\"text/plain\").write(body).end();","\"text/plain\");","\"tim\").put(\"directory\",","\"utf","\"wibble\");","\"woobble\").puttrailer(\"x","\"woobble\").set(\"x","\"yay!","\"{\\\"foo\\\":\\\"bar\\\"}\";","#","$cwd/.vertx","${version}","${version}.jar","&&","'abc'","'io.vertx:vertx","'xyz'","(!","(!line.isvalid()","(!request.path().contains(\"..\"))","(!sock.writequeuefull())","(1)","(2)","(2.6.0)","(2.6.2)","(3)","(3.1.0)","(4)","(4.0.31.final)","(5)","(6)","(ar.succeeded())","(asyncresult.succeeded())","(asyncresult2.succeeded())","(byte","(caus","(context.iseventloopcontext())","(context.ismultithreadedworkercontext())","(context.isworkercontext())","(continue)","(dnsexception)","(err","(int","(l)","(mxrecord","(nop)","(numberformatexcept","(pushedrequest.path().equals(\"/main.js\"))","(rejectandclose)","(request.getheader(\"expect\").equalsignorecase(\"100","(request.method()","(request.path().equals(\"/\"))","(request.path().equals(\"/myapi\"))","(res.succeeded())","(resget.succeeded())","(response.statuscode()","(resput.succeeded())","(result.succeeded()","(result.succeeded())","(short)","(sock.writequeuefull())","(srvrecord","(streamresetexception)","(string","(websocket.path().equals(\"/myapi\"))",");","**，*","+","...","...\"",".addargument(new",".addchoice(\"blue\").addchoice(\"red\").addchoice(\"green\")",".addoption(",".addoption(new",".connecthandler(socket",".end();",".launcher",".listen(1234,",".listen(8080);",".pem",".putheader(\"connection\",",".requesthandler(req",".setargname(\"arg1\"))",".setargname(\"arg2\"));",".setargname(\"source\"))",".setargname(\"target\"));",".setclientauth(clientauth.required)",".setclusterpublichost(\"whatever\")",".setclusterpublicport(1234)",".setconverter(new",".setdefaultvalue(\"green\")",".setdefaultvalue(\"hello\")",".setdescription(\"a",".setdescription(\"an",".setdescription(\"en",".setdescription(\"th",".seteventbusoptions(new",".setflag(true))",".sethost(\"localhost\")",".sethost(\"localhost\").setport(1080)",".sethost(\"localhost\").setport(3128)",".setindex(0)",".setindex(1)",".setkeycertoptions(certificate.keycertoptions())",".setkeystoreoptions(new",".setlongname(\"color\")",".setlongname(\"directory\")",".setlongname(\"flag\").setshortname(\"f\").setflag(true).setdescription(\"a",".setlongname(\"mandatory\")",".setlongname(\"multiple\").setshortname(\"m\").setmultivalued(true)",".setlongname(\"optional\")",".setlongname(\"person\"));",".setlongname(\"single\").setshortname(\"s\").setdescription(\"a",".setmaxredirects(32));",".setport(8080)",".setproxyoptions(new",".setrequired(true)",".setshortname(\"r\")",".setssl(true)",".setssl(true),",".setstatuscode(405)",".setsummary(\"a",".settrustall(true);",".settrustoptions(certificate.trustoptions()))",".settrustoptions(certificate.trustoptions());",".settruststoreoptions(new",".settype(boolean.class)",".settype(file.class)",".settype(person.class)",".seturi(\"/\")",".setusealpn(true)",".setusername(\"username\").setpassword(\"secret\"));","/","//","//仅回传数据","//异常处理","/a/b/c/page.html","/page.html?param1=abc¶m2=xyz","0","0)","0.0.0.0，它表示：监听所有可用地址。默认端口号是","03","0;","0;i","0，这也是一个特殊值，它告诉服务器随机选择并监听一个本地没有被占用的端口。","0：","1","1\"));","1.8.0u74","10","10.0.0.1的反向查找类似的事：","10.0.0.2","100","10000,","10;","120000;","123).put(\"mybool\",","123);","1234,","14|activ","15","15:54:14","15;","15|activ","16\");","16|activ","16，您可使用","18|activ","19|activ","1|jackson","1|netty/buff","1|netty/codec","1|netty/codec/http","1|netty/codec/sock","1|netty/common","1|netty/handl","1|netty/transport","1|netty/transport/sctp","1|vert.x","1。","1代理不支持参数化消息。log4j","2","20","200","200)","200);","200。","200，表示","20458","20|activ","21|activ","22|activ","230.0.0.1","23|activ","24|activ","25|activ","26|activ","2xx","2分钟","2和slf4j提供了预设的实现，类名为：io.vertx.core.logging.log4jlogdelegatefactory，io.vertx.core.logging.log4j2logdelegatefactory和io.vertx.core.logging.slf4jlogdelegatefactory。如您要使用这些实现，还应确保相关的log4j或slf4j的jar在您的类路径上。","2的代理使用了像slf4j代理这样的{}语法，jul代理使用如{x}语法。","2）个","2，其中n是组中节点数。若集群中的q节点少于ha节点，ha部署将被撤销。如果/当","3","3);","3,","3.4.1","30","301","301、302","301、302、303","303","307","30x","404","40;","46","5","5.1.2","5.2.0上的工作部署：","500)","5};","5秒后我们释放该锁其他人可以得到它","6","8","8.1.7.v20160121。这个完整列表可以在","8.8.4.4。","8.8.8.8","8080","8859","8不支持alpn，所以alpn应该通过其他方式启用：","8发行版用以支持alpn。","8的jdk。","8的jdk环境。","8的编码方式写入一个字符串","8编码方式编码字符串和以指定方式编码编码字符串、或写buffer的方法：","8编码的字符串","8）。","9","9杀死进程来测试），运行mi",":","=","==",">","?），您也可以使用逗号（,）分隔它们来指定多个集合。模式相当于当前工作目录。","@argument(index","@description(\"som","@name(\"mi","@name(\"som","@option(longnam","@option(shortnam","@overrid","@summary(\"a","@summary(\"som","[","[2.6.0,3)","[2.6.2,3)","[4.0.31,5)","a/aaaa","a/b/c/page.html?param1=abc¶m2=xyz","a_n_other_verticle.rb","aaaa记录，您需要像下面那样做：","aaaa（ipv6）记录。第一个返回的（记录）将会被使用，因此它的操作方式与在操作系统上使用","aaaa（ipv6）记录时，第一条被返回的（记录）将会被使用。它的操作方式和操作系统上使用","absoluteuri","abstractverticl","accept","access等）中找到这些功能。","acknowledg","actor","actor。","actual","actualport","ad","add","addcertpath(\"/path/to/your/ca","addcertpath(\"/path/to/your/serv","addcertvalue(mycaasabuffer)","addcertvalue(mytruststoreasabuffer)","addcrlpath(\"/path/to/your/crl.pem\");","addcrlvalue(mycrlasabuffer);","addenabledciphersuite(\"cdh","addenabledciphersuite(\"ecdh","addenabledsecuretransportprotocol(\"tlsv1.1\").","addenabledsecuretransportprotocol(\"tlsv1.2\");","addr.arpa\",","addr.arpa的ptr概念。","address","addressresolveroptions().","addressresolveroptions().addsearchdomain(\"foo.com\").addsearchdomain(\"bar.com\"))","addserver(\"192.168.0.1\").","addserver(\"192.168.0.2:40000\"))","aes128","aes256","afterstartingvertx","agent","agent\"));","agent:","agent。agent是一个jvm代理，它会为运行它的jvm选择正确的alpn版本：","aliv","alive的连接将不会被客户端自动关闭，要关闭它们您可以关闭客户端实例。","alpn","alpn(appl","alpn支持","alpn是一个tls的扩展，它在客户端和服务器开始交换数据之前协商协议。","alpn是一个小型的jar，它覆盖了几种java","am\"));","annot","annotatedcli","annotatedcli();","anoth","ant","apach","api","api。","api不会阻塞线程，所以通过vert.x您可以只使用少量的线程来处理大量的并发。","api中的一些对象提供了简单的流程控制（回压）功能。","api使用","api却没绑定。slf4j记录的消息将会丢失。您应该将绑定加入您的类路径。参考","api在verticle内部可用。","api来处理事件。例如每隔一秒发送一个事件的计时器：","api的jar，并在缺省情况下使用它。","api的三个步骤如下：","api的拷贝示例：","api，它本质上是同步的，无论多么努力地去尝试，vert.x都不能像魔法小精灵撒尘变法一样将它转换成异步api。","api，毕竟不同的语言有不同的代码风格，若强行让","app","appendxxx","applic","application/x","application:","appropri","ar","ar.cause());","ar.cause().getmessage());","ar.cause();","ar.result().body());","ar.result().handler(buff","ar.result();","arg)","arg0","arg;","argnam","argument","argument\")","argument()","array","array.add(\"foo\").add(123).add(false);","array.getboolean(2);","array.getinteger(1);","array.getstring(0);","asyncfil","asyncfile,","asyncfile、netsocket、websocket","asyncfile。","asyncfile。关闭是异步的，如果希望在关闭过后收到通知，您可指定一个处理器作为函数（close）参数传入。","asyncfile实现了","asynchron","asyncmap","asyncresult","asyncresult.cause());","asyncresult.succeeded());","asyncresult2","asyncresult2.cause());","asyncresult2.succeeded());","asyncresult3","asyncresult3.succeeded());","attach","availability）的verticle。这种情况下，当运行verticle的vert.x实例突然挂掉时，该veritlce将迁移到另一个vert.x","availability：高可用性","awar","away","back","badkey","badsig","badtim","badver","ball","ball\");","ball\",","bar.txt","bare","befor","beforestartingvertx","behavior","best","between","bin","binari","binary），后边跟着零个或多个","bind","bind!\");","block","blockmulticastgroup(...)，如下所示：","block：阻塞","bodi","body:","bodyhandl","body：请求/响应体（有些地方翻译成请求/响应正文）","boolean","boolean）。","boolval","boot","boot${version}.jar","box：标准环境（开箱即用）","brain）。","bu","buff","buff.appendint(123).appendstring(\"hello\\n\");","buff.setint(1000,","buff.setstring(0,","buff.setunsignedbyte(pos,","buff.tojsonobject();","buffer","buffer);","buffer.appendint(123).appendlong(245l);","buffer.buff","buffer.buffer(\"content\");","buffer.buffer(\"foo\");","buffer.buffer(\"hello\"),","buffer.buffer(\"som","buffer.buffer(),","buffer.buffer().appenddouble(12.34d).appendlong(432l);","buffer.buffer().appendfloat(12.34f).appendint(123);","buffer.buffer().appendfloat(12.3f).appendint(321);","buffer.buffer().appendint(12).appendstring(\"foo\");","buffer.buffer().appendint(123));","buffer.buffer().appendint(123).appendfloat(1.23f);","buffer.buffer();","buffer.buffer(1000);","buffer.buffer(10000);","buffer.buffer(128);","buffer.buffer(bytes);","buffer.length());","buffer1:hello","buffer1:hello\\nhow","buffer2:how","buffer2:ou?\\ni","buffer3:","buffer3:i","buffer4:\\n","buffer。","buffer。buff","buffer。您也可以将","buffer。若您知道您的","buffer将会在添加到map之前拷贝","buffer长度","buffer，在写入请求体之前，vert.x","buffer，它也存在各种不同数据类型的方法。所有的","buffer，当数据从网络到达时，处理器可以多次被调用，这取决于请求体的大小。","buffer，这个","buffer，这个和先调用带","buffer，这个字符串可以用指定的编码方式编码，例如：","buffer：","buffer：缓冲区（一些地方使用的","buffer：要写入的缓冲","buffer：读取数据的","build.gradl","build/libs/mi","builder","bundl","bundle则需要：","bundle，因此可以在任何osgi","bus:","bus。","bus。默认为false（非集群模式）。","bus上注册处理器时，注册信息会花费一些时间才能传播到集群中的所有节点。","bus上的","bus上相互通信。","bus中使用ssl连接替换传统的tcp连接。","bus中注册一个处理器，当这个处理器中收到任意","bus也支持","bus会尝试将消息传递到注册在ev","bus可形成跨越多个服务器节点和多个浏览器的点对点的分布式消息系统。","bus地址感兴趣）","bus支持","bus支持发布/订阅、点对点、请求/响应的消息通信方式。","bus的api很简单。基本上只涉及注册处理器、撤销处理器和发送和发布消息。","bus节点之间的传输，这是由","bus：","bus：事件总线","byte","byte[]","bytebuffer）。","bytes:","c","ca.pem\")","ca.pfx\");","cach","call","canceltim","catch","caus","cause;","cert.pem\")","cert.pem\");","certif","cet","check","chunk","chunk.length());","chunk：块（http","cipher","class","class=io.vertx.cor","class=io.vertx.core.launch","class=io.vertx.core.launcher。要触发重新部署，您需要显示构造项目或模块（build","class=io.vertx.core.launcher，您还可以添加其他参数。随着","classes:lib/otherscripts:jars/myjar.jar:jars/otherjar.jar。始终使用路径引用您的verticle需要的任何资源，不要将它们放在系统类路径上，因为这会导致部署的verticle之间的隔离问题。","classpath","classpath），您可使用","class设置为io.vertx.core.launch","cli","cli.create(\"copy\")","cli.create(\"som","cli.create(\"test\")","cli.create(annotatedcli.class);","cli.parse(collections.singletonlist(\"","cli.parse(usercommandlinearguments);","cli.usage(builder);","cliconfigurator.inject(commandline,","client","client.connect(1234,","client.connect(4321,","client.get(\"/index.html\",","client.get(\"som","client.getnow(\"/som","client.getnow(\"foo.othercompany.com\",","client.getnow(\"som","client.getnow(8080,","client.getnow(new","client.headnow(\"/oth","client.lookup(\"nonexisting.vert.xio\",","client.lookup(\"vertx.io\",","client.lookup4(\"vertx.io\",","client.lookup6(\"vertx.io\",","client.post(\"som","client.put(\"som","client.redirecthandler(respons","client.request(httpmethod.get,","client.request(httpmethod.post,","client.resolvea(\"vertx.io\",","client.resolveaaaa(\"vertx.io\",","client.resolvecname(\"vertx.io\",","client.resolvemx(\"vertx.io\",","client.resolvens(\"vertx.io\",","client.resolveptr(\"1.0.0.10.in","client.resolvesrv(\"vertx.io\",","client.resolvetxt(\"vertx.io\",","client.reverselookup(\"10.0.0.1\",","client.websocket(\"/som","clientopt","client、data","client：客户端","cliexcept","cli可以转换的类：","cli提供了一个描述命令行界面的模型，同时也是一个解析器，这个解析器可支持不同的语法：","close","closed\");","closed,","closehandl","closehandler：","cluster","clustermanag","cluster开关，因为若要使用ha就假定是集群。","cluster：此选项确定vert.x实例是否尝试与网络上的其他vert.x实例形成集群，集群vert.x实例允许vert.x与其他节点形成分布式ev","code","codec","codec/common","codec/handl","codec/sock","codec/transport","color\"));","com.acme.foo中，com.acme.foo是一个参数。","com.acme.myverticl","com.mycompany.myproject","com.mycompany.myproject.*","com.mycompany.myproject.engine.myclass；也可以是包含通配符的可匹配某个包或子包的任何类，例如","com.mycompany.myverticl","command","command\")","command.\")","commandfactory：","commandlin","commandline.getargumentvalue(\"source\");","commandline.getargumentvalue(\"target\");","commandline.getargumentvalue(0);","commandline.getoptionvalue(\"mi","commandline.getoptionvalue(\"r\");","commandline.isflagenabled(\"mi","command条目来配置默认命令。若在没有命令的情况下启动","compil","compilation）。","complet","complete（或","compose(handler,","compose(mapper)：当前","compositefuture.al","compositefuture.all(arrays.aslist(future1,","compositefuture.all(httpserverfuture,","compositefuture.any(arrays.aslist(f1,","compositefuture.any(future1,","compositefuture.join(arrays.aslist(future1,","compositefuture.join(future1,","composition：并发合并","comput","concurr","conf","config","config().getstring(\"name\"));","connect","connect:","connected\");","connecthandler：","connection.close();","connection.goaway(0);","connection.goawayhandler(goaway","connection.pinghandler(p","connection.remotesettingshandler(set","connection.shutdown();","connection.shutdownhandler(v","connection.updatesettings(new","connection:","connect、socks4a","consist","consum","consumer.completionhandler(r","consumer.handler(messag","consumer.unregister(r","consumer：消费者","content","content\",","contentlength","contenttyp","context","context\");","context.get(\"data\");","context.isonvertxthread())","context.put(\"data\",","context.runoncontext((v)","context:","context。","context（根据配置不同，可以是ev","context），之后此","context，它绑定到了一个特定的","context，并且所有的操作运都会运行在","context：上下文环境","continu","continue\"))","continue\");","continuehandler。它将在服务器发回一个状态","continue持续响应","continue，并且在发送剩余请求体之前先发送请求头。然后服务器可以通过回复临时响应状态","cooki","cookie头。","copi","copied\");","copy、move、truncate、chmod","core","core:3.4.1'","core、您的jar和所有依赖项）。","core。","core。很酷的是：我们并不强迫您在书写诸如","core中的功能相当底层","core主题，该api也可在","core以提供资源或处理文件上传。","core提供了一个用于解析传递给程序的命令行参数api。","core被打包成了","corner","counter","cp","cpu核数","creat","customframehandler，每次当自定义的帧数据到达时，这个处理器会被调用。这而是一个例子：","customframehandler，每次自定义帧到达时就会调用它。以下是一个例子：","d...）。若您使用","data","data\");","data\",","data()：保存接收数据的buff","databind","datagrampacket","datagrampacket。","datagramsocket","datagramsocket,","datagramsocketoptions());","datagramsocket。","datagramsocket本地地址","datagram：数据报","data）包含的功能允许您可以安全地在应用程序的不同部分之间、同一","data：保存接收数据的buffer。","debug","default","defaultcommand","defaultcommandfactori","deflat","deleg","delet","deleted\");","delivery)。","deliveryopt","deliveryoptions().setcodecname(mycodec.name());","deliveryoptions();","depend","deploy","deployed）。稍后，您完成了所有您需要做的事（如：启动其他verticle），您就可以调用","deploymentopt","deploymentoptions().setconfig(config);","deploymentoptions().setinstances(10);","deploymentoptions().setinstances(16);","deploymentoptions().setisolationgroup(\"mygroup\");","deploymentoptions().setworker(true);","deploymentoptions().setworkerpoolname(\"th","deployverticl","depth=1）","description\")","destination\")","destroyed：销毁","details.","differ","directori","djava.awt.headless=tru","djava.net.usesystemproxies=tru","dkey=value。","dn","dnsclient","dnsexcept","dnsexception)","dnsresponsecod","dnsresponsecode，如：","dns客户端","dns查询服务器列表","do","don't","done\");","don’t","drainhandler：若writestream被认为不再满，则处理器将被调用。","dvertx","dvertx.cachedirbase=/tmp/vertx","dvertx.disablednsresolver=tru","dvertx.disablefilecaching=tru","dvertx.disablefilecpresolving=true完全禁用高速缓存。这个设置不是没有后果的。vert.x将无法从类路径中读取任何文件（仅从文件系统）。使用此设置时要非常小心。","e)","e.g.","e.getmessage());","e.printstacktrace();","eb","eb.consumer(\"news.uk.sport\");","eb.consumer(\"news.uk.sport\",","ebsocket","ecdsa","eclips","eclipse：创建一个运行配置，使用io.vertx.core.launcher类作为主类。在","effort","empti","enabl","encod","encodeprettili","encoding)。","encoding:","end","end(\"alert(\\\"push","end);","endhandl","endhandler：当流到达时将被调用。这有可能是到达了描述文件的eof、达到http请求的请求结束、或tcp","endpoint","engin","entry\"","entry：条目（一条key=value的键值对）","enum","equinox，（这个）bundle导出io.vertx.core*。","err;","etc","event","eventbu","eventbus);","eventbus.consumer(\"news.uk.sport\");","eventbus.publish(\"news.uk.sport\",","eventbus.registercodec(mycodec);","eventbus.registerdefaultcodec(mypojo.class,","eventbus.send(\"news.uk.sport\",","eventbus.send(\"orders\",","eventbusopt","eventbusoptions()","eventbusoptions还允许您指定","eventloop","exactli","exampl","except","exception);","exception.code();","exception:","exceptionhandl","exceptionhandler若readstream发生异常，将被调用","exceptionhandler：若writestream发生异常，则被调用。","execut","executeblock","executor","executor.close();","executor.executeblocking(futur","executor。","exist","expect:","explicitli","ext","extend","f2,","f3));","factori","factory。","factory会从","factory：通过","factory？","fail","failed!\");","failed\"","failed\");","failur","fals","false);","false。这样任何","fat","fat.jar","felix","file","file);","file.endhandler((r)","file.endhandler(v","file:","files.","files.\")","filesystem","filesystem.open(\"myfile.txt\",","final","final。","fine\");","fired!\");","first","flag","flag\"))","flag\");","flag)","flag;","fli","fluent：流式的","flush","flush：刷新（指将缓冲区中已有的数据一次性压入，用这种方式清空缓冲区，传统上翻译成刷新）","follow","foo.c）","foo.j","foo.tar.gz）","foo.txt","fooverticle.groovi","foo）","form","formattribut","formerror","found","found\".","frame","frame\");","frame.payload().tostring());","frame.type()","frame1","frame2","frame3","frame:","framestatu","framestatus,","frametyp","framework","frame：帧","franca)。但是若您不想用","fs","fs.copy(\"foo.txt\",","fs.copyblocking(\"foo.txt\",","fs.createfile(\"/foo\",","fs.move(\"/foo\",","fs.writefile(\"/foo\",","full","fulli","further","fut1","fut1.completer());","fut1.compose(v","fut1中文件创建完成后执行","fut2","fut2.completer());","fut2;","fut2文件写入完成后执行","futur","future.complete(result);","future.future();","future.succeededfuture(client.getabs(absoluteuri));","future/promis","future2).sethandler(ar","future2,","future3));","future3).sethandler(ar","future。","future。当返回的","future（startfuture）会是成功的；其中任何一步失败，则最终","future，以此来汇报处理成功或者失败。","future，否则就标记为失败。（译者注：3.4.0","future：","future；当任一个","g1","g2","gcm","getclusterport","getclusterwidemap","getcount","getdefaultcommand","getlock","getmainverticl","getmaxconcurrentstreams：按照","getnow。这些方法会创建http","getorcreatecontext","getsslengineopt","getter/setter）时，并且有一个","getunsignedxxx、appendunsignedxxx","getxxx","get、opt","go","goaway","grace","gradl","gradle（您的","gradle（译者注：两种常用的项目构建工具），将以下依赖项添加到您的项目描述文件的","grass\",","groovy:com.mycompany.somegroovycompiledverticl","groovy:io.vertx.example.mygroovyverticl","group","gzip","gzip,","gzip/defl","h","h\"));","h2","h2c","h2c。","h2c之上的","h2c（未加密http/2服务器）的连接可能不受","h2c，所以在建站时，您应该使用","h2和tcp","ha","hagroup","hagroup开关。","hagroup：该参数需要和","handl","handler","handler.j","handler/handle：处理器/处理，有些特定处理器未翻译，如complet","handler。","handler传入一个","handler等。","handler，以毫秒为单位计时。","handler，当操作完成或发生错误时调用该处理器。","handler：结果处理器","handler：设置一个处理器，它将从readstream读取项","happened\");","hashmap<>();","hazelcastclustermanager。","ha一起使用，它指定此节点将加入的ha组。集群中可以有多个ha组，节点只会故障转移到同一组中的其他节点。默认为__default__。","ha一起使用，它指定集群中所有ha部署id处于活动状态的最小节点数，默认为0。","ha参数到命令行：","ha开关时，您不需要提供","ha组","ha：若指定，该verticle将部署为（支持）高可用性（ha）。有关详细信息，请参阅相关章节。","head","header","header\",","headers.get(\"us","headers.set(\"cont","headers.set(\"oth","headers、path、queri","headers：","header允许一个特定的键包含多个值。","header：请求/响应头","hello","hello\\\")\");","hellocommandfactori","hellocommandfactory()","high","hops：跳数（一台路由器/主机到另外一台路由器/主机所经过的路由器的数量，经过路由转发次数越多，跳数越大）","host","host和clust","host：若指定了cluster选项，则可以确定哪个主机地址将用于其他vert.x实例进行集群通信。默认情况下，它将尝试从可用的接口中选一个。若您有多个接口而您想要使用指定的一个，就在这里指定。","html","http","http/1","http/1.0","http/1.0、http/1.1","http/1.1","http/1.1。","http/1.1升级","http/1.1）。","http/1.x","http/1.x，但可以连接到","http/2","http/2规范定义了可使用的","http/2，当响应到达时，可以使用","http/2：","http/http","http2set","http2settings().setmaxconcurrentstreams(100));","http2settings().setmaxconcurrentstreams(100),","http://www.slf4j.org/codes.html#staticloggerbind","http://www.somehost.com/path/file.html","http_2。","httpclient","httpclientopt","httpclientoptions()","httpclientoptions().","httpclientoptions().setdefaulthost(\"wibble.com\");","httpclientoptions().setkeepalive(false);","httpclientoptions().setlogactivity(true);","httpclientoptions().setprotocolversion(httpversion.http_2);","httpclientrequest","httpclientrequest,","httpclientrespons","httpclientresponse，并返回","httpclient可以在一个","httpconnect","httpmethod.put)","httpserver","httpserver.listen(httpserverfuture.completer());","httpserver.requesthandler(request","httpserverfileupload","httpserverfileupload,","httpserverfutur","httpserveropt","httpserveroptions()","httpserveroptions().setlogactivity(true);","httpserveroptions().setmaxwebsocketframesize(1000000);","httpserverrequest","httpserverrequest,","httpserverrequest。","httpserverrespons","httpserverresponse，websocket,","https。","http客户端。","http方法用于非标准http方法，当使用此方法时，必须使用","http请求通常包含我们需要读取的主体。如前所述，当请求头部达到时，请求处理器会被调用，因此请求对象在此时没有请求体。","human","i.v.e.h.s.httpserververticle@1","i.v.e.h.s.httpserververticle@2","i/o","id","id=mi","idea：创建一个运行配置（应用）,将主类设置为io.vertx.core.launcher。在程序参数中写：run","id可以在之后您想要撤销它时使用。","id：应用程序id，若未设置，则使用随机uuid","ignor","illustr","immut","implement","index.html","indexoutofboundsexception。","inetsocketaddress","inf/services/io.vertx.core.spi.launcher.commandfactori","inf/services/io.vertx.core.spi.launcher.commandfactory）。","instanc","instance);","instanceof","int","integ","intellij","interesting!\");","interfac","internalloggerfactory.setdefaultfactory(log4jloggerfactory.instance);","intval","io.netty.handler.logging.logginghandl","io.vertx","io.vertx.core.launch","io.vertx.core.launcher.example.hellocommandfactori","io.vertx.core.launcher。另外，将","io.vertx.core.net.impl.connectionbas","io.vertx.core.vertx。","io.vertx.example.mverticl","io.vertx.example.myverticl","io.vertx.examples.http.sharing.httpserververticl","is:","jackson","jar","jar.jar","jar。","jar一样可直接执行：","jar中时，您必须将下边信息写入manifest：","jar（或包含在其中）的类路径中，或放在vert.x发行版的lib目录中，您将可以执行：","jar，则使用默认命令。","java","java.io.ioexception:","javaagent:/path/to/alpn/ag","javaobject","javascript","jdbc","jdk","jdksslengineopt","jdksslengineoptions());","jdk中alpn可用时使用","jetti","jksoption","jksoptions().","jksoptions().setpath(\"/path/to/my/keystore\"));","jksoptions().setpath(\"keystore.jks\").setpassword(\"wibble\"))","jksoptions：","join","js:foo.j","json","jsonarray","jsonarray();","jsonarray(jsonstring);","jsonobject","jsonobject().put(\"name\",","jsonobject();","jsonobject(jsonstring);","jsonobject(map);","jsonobject.getinteger(\"som","jsonobject.getstring(\"som","jsonobject.mapto(user.class);","jsonstr","json数组。","json，我们并不强制您使用它。","jul","jvm必须将","keep","key\");","key.pem\").","key.pem\");","keycertoptions和","keystore\")","keystore\");","keystore.jks\").","keystore.jks\");","keystore.pfx\").","keystore.pfx\");","keytool","kick","kill","later","launcher","launcher，单您已使用了您自己的主类。","launcher：启动器","layer","lengh\");","length","length\",","length。","length。若您在使用http","length头，否则会出错。","length：要读取的数据的字节数","line","line.isaskingforhelp())","list","listen","listen(...)","listening!\");","list）。当任意一个","list）。当所有的","load","loader）功能查找集群管理器，以便在类路径中查找clustermanager的实例。","localaddress方法获取","localmap","locat","lock","lock!","lock.release());","log","logdelegatefactori","logger","logger.error(\"oops!\",","logger.info(\"someth","loggerfactory.getlogger(classname);","logging.properties的jul配置文件（例如在您的fatjar中），vert.x将使用该配置文件配置jul。","logging：动词翻译成","long","long.max_value;","long.parselong(request.getparam(\"end\"));","long.parselong(request.getparam(\"start\"));","lookup","lookup4","lookup6","loop","loop\");","loop。","loop。为了帮助您诊断类似问题，若","loop中执行（只要您不创建自己的线程并调用它！）","loop中直接使用","loop中访问socket","loop（如不同的","loop，任何一个特定的处理器永远不会被并发执行。大部分情况下（除了","loop，但是这并不能帮您避免在您自己的处理器中阻塞","loop，而且您希望每秒处理10000个","loop，那么您的应用就会完全停止！","main","main.js，并不在需要它。","make","manag","mandatori","manifest","manual","map","map.get(\"foo\",","map.put(\"foo\",","map.put(\"xyz\",","map1","map1.get(\"foo\");","map1.put(\"foo\",","map2","map2.get(\"eek\");","map2.put(\"eek\",","maps)允许从集群的任何节点将数据放到","mapto","map：动词翻译成","maven","maven/gradl","maven（您的","max","maxexecutetim","maxexecutetime);","messag","message.body());","message.reply(\"how","message:","messagecodec","messagecodec。消息编解码器有一个名称，您需要在发送或发布消息时通过","messageconsum","messageconsumer,","messageconsumer中。在某些情况下，发送者需要知道消费者何时收到消息并","messageconsumer，之后再来设置处理器。如：","messageproduc","message。","method","method（即get、post、put、delete、head、options等）。","metric","model","more","ms","multi","multicast","multicast：多播（组播）","multimap","multimap。","multipart","multipart/form","multiplexing：多路复用","mxrecord允许您通过下边提供的方法访问mx记录的优先级和名称：","my.verticl","my_verticle.conf","my_verticle.j","my_verticle.rb","mycaasabuff","mycertasabuff","mycodec);","mycommand","myconf.json","mycrlasabuff","mykeyasabuff","mykeystoreasabuff","myotherpojo","mypojo","mypojo());","mypojo(),","mytruststoreasabuff","myverticl","myverticle();","myverticle.groovi","myverticle.java","n","n)","n;","name","name\")","name)","name);","name;","name未设置，将生成一个随机的id，并在命令提示符中打印。您可以将run选项传递给start命令：","name的系统属性，该属性的值是一个实现了","naughi","naughti","need","negotiation)是应用层协议协商的tls扩展，它被http/2使用：在tls握手期时，客户端给出其接受的应用协议列表，之后服务器使用它所支持的协议响应。","negotiation：alpn，应用层协议协商","netclient","netclientopt","netclientoptions()","netclientoptions().","netclientoptions().setconnecttimeout(10000);","netclientoptions().setlogactivity(true);","netclientoptions().setssl(true).setkeystoreoptions(","netclientoptions().setssl(true).setpemkeycertoptions(","netclientoptions().setssl(true).setpfxkeycertoptions(","netserv","netserver.listen(netserverfuture.completer());","netserverfutur","netserverfuture).sethandler(ar","netserveropt","netserveroptions()","netserveroptions().","netserveroptions().setlogactivity(true);","netserveroptions().setport(1234).sethost(\"localhost\")","netserveroptions().setport(4321);","netserveroptions().setssl(true).setkeystoreoptions(","netserveroptions().setssl(true).setpemkeycertoptions(","netserveroptions().setssl(true).setpfxkeycertoptions(","netserveroptions。","netsocket","netsocket,","netsocket、http","netsocket：","netti","netty不依赖于外部日志配置（例如系统属性），而是根据netty类可见的日志记录库来实现日志记录：","netty日志记录","new","news.uk.sport","next","next)：当前","no_error(0)","no_error(0)错误代码，可发送另一个代码：","node.j","nodes\");","noerror","notimpl","notzon","now","nslookup","null","null)","null;","number,","nxdomain","nxrrset","o2","obj.dosomethingthattakestime(r","object","object.put(\"foo\",","objectmapper#convertvalue()","offset","offset);","offset,","offset：读取数据将被放到","oh","ok","ok!","ok!\");","ok\"));","ok\");","ok。","on","onc","once、at","once。不同语义情况下要考虑的情况不同。","open","openjdk","openopt","openoptions());","openoptions(),","openoptions();","openssl","opensslengineopt","opensslengineoptions());","openssl中alpn可用时使用","openssl提供了原生的alpn支持。","openssl提供比jdk引擎更好的性能和cpu使用率、以及jdk版本独立性。","openssl支持","openssl需要配置","oper","opt","option","option\"))","option\"));","option\");","option()","option().setlongname(\"help\").setshortname(\"h\").setflag(true).sethelp(true))","option().setlongname(\"mandatory\").setrequired(true));","options);","options,","options.addheader(\"som","options.setisolatedclasses(arrays.aslist(\"com.mycompany.myverticle.*\",","options上使用path设置客户端受信存储位置。如果服务器在连接期间提供不在客户端受信存储中的证书，则尝试连接将不会成功。","options上的功能路径设置客户端密钥库位置。","options：配置项，作为参数时候翻译成选项","opts来配置jvm（","opts配置调试器。每次重新部署后，请勿忘记重新插入(r","opts：java虚拟机选项，若未设置，则使用java_opts环境变量","order","order_worker.rb","org.acme.myverticl","osgi","out","output","output).start();","output：重定向生成的进程输出和错误流到父进程流","over：故障转移","package\"","packet","param","param1:","param1=abc¶m2=xyz","param2:","parser","parser.handle(buffer.buffer(\"\\n\"));","parser.handle(buffer.buffer(\"do","parser.handle(buffer.buffer(\"hello\\nhow","parser.handle(buffer.buffer(\"ou?\\ni","parser）允许您轻松解析由字节序列或固定尺寸带分隔符的记录的协议。","parse解析方法返回包含值的commandline对象。默认情况下，它验证用户命令行，并检查每个必填选项和参数的设置以及每个选项接收的值的数量。您可以通过传递","part","part/form","patch","path","path/to/dir/conf/cluster_xml","pattern","pause：暂停处理器，暂停时，处理器中将不会受到任何项","payload","payload\"","payload);","peer","pem","pemkeycertopt","pemkeycertoptions().","pemopt","pemtrustoptions().","per","period：停止应用程序后等待的时间（在启动用户命令之前）。这个在windows上非常有用，因为这个进程并没立即被杀死。时间以毫秒为单位，默认20m","period：在2次重新部署之间等待的时间（以毫秒为单位），默认为1000m","period：文件系统检查周期（以毫秒为单位），默认为250m","persist","personconverter())","pfxoption","pfxoptions().","ping","pipe","pipe：管道","pkcs＃12格式的密钥/证书（http://en.wikipedia.org/wiki/pkcs_12，通常为.pfx或.p12扩展名）也可以用与jks密钥存储相似的方式加载：","plug)调试器，因为它每次都会创建一个新进程。","po","pom.xml","pool","pool\"));","pool\");","pool\",","poolsiz","poolsize,","pool。当所有的","pool：事件轮询线程池，大部分地方未翻译","pool：工作者线程池，大部分地方未翻译","port","port:","port参数。","port：若指定了cluster选项，则可以确定哪个端口将用于与其他vert.x实例进行集群通信。默认为0——这意味着“选择一个空闲的随机端口”。除非您帧需要绑定特定端口，您通常不需要指定此参数。","position：一个整数指定在文件中写入缓冲的位置，若位置大于或等于文件大小，文件将被扩展以适应偏移的位置","position：从文件中读取数据的位置","post","pri*http/2.0\\r\\nsm\\r\\n","primitive：基本（描述类型）","printed\");","privat","probabl","process","program","projecthelp）","project）。","protocol","proxyopt","proxyoptions().settype(proxytype.http)","proxyoptions().settype(proxytype.socks5)","public","public（或者有","publish","pump","pump.pump(file,","pump.pump(request,","pump.pump(sock,","pump.start();","pump，所以即使","pump：泵（平滑流式数据读入内存的机制，防止一次性将大量数据读入内存导致内存溢出）","push","push)是","pushedrequest.handler(pushedrespons","pushedrequest.path());","pushedrequest.reset();","pushedrespons","pushedresponse.","put","puthead","putheader(\"cont","puttrail","qualifi","quora","quora。","quora（多数派机制）。quorum","quorum","quorum（法定人数）。","quorum，例如：","quorum：该参数需要和","quux\",","r","r,","r4.2+环境中使用，如","r]","re","reach","reactor","reactor即多反应器","reactor：反应器，multi","read","readabl","readfil","readi","readstream","readstream（可读流）","receiv","received,","receiver/recipient：接收者","record","record.name();","record.port();","record.priority();","record.protocol();","record.service();","record.target();","record.weight();","record:","recordpars","recordparser.newdelimited(\"\\n\",","recordparser.newfixed(4,","records)","redeploy","redeploy\"选项指定在应用程序关闭后和重新启动之前调用的命令。因此，如果更新某些运行时工作，则可以钩住构建工具。例如，您可以启动gulp或grunt来更新您的资源。","redeploy=\"**/*.class\"","redeploy=\"**/*.groovy\"","redeploy=\"**/*.groovy,**/*.rb\"","redeploy=\"**/*.java\"","redeploy=\"mvn","redeploy=\"src/**/*.java\"","redeploy='./gradlew","redeploy=**/*.class","redeploy=**/*.java","redirect","refus","regist","registerverticlefactori","registr","reject","rejectandclos","releas","remot","remoteaddress","remotesettingshandler：","repli","replied\");","reply:","req.response().end(\"hello!\"))","request","request\");","request);","request.bodyhandler(bodi","request.bodyhandler(buff","request.bodyhandler(totalbuff","request.connection();","request.connectionhandler(connect","request.continuehandler(v","request.customframehandler(fram","request.end(\"som","request.end());","request.end();","request.end(buffer);","request.endhandler(v","request.exceptionhandler(","request.exceptionhandler(err","request.formattributes();","request.handler(buff","request.handler(respons","request.headers();","request.path();","request.pushhandler(pushedrequest","request.putheader(\"cont","request.putheader(\"expect\",","request.reset();","request.reset(8);","request.response()","request.response().end(\"hello","request.response().end();","request.response().exceptionhandler(err","request.response().putheader(\"cont","request.response().reset();","request.response().reset(8);","request.response().sendfile(\"web/\"","request.response().sendfile(\"web/mybigfile.txt\",","request.response().setstatuscode(400).end();","request.response().writecontinue();","request.response();","request.setchunked(true);","request.setexpectmultipart(true);","request.upgrade();","request.uploadhandler(upload","request.write(\"som","request.write(body);","request.write(buffer);","request.writecustomframe(frametype,","requestabs：","requesthandler：","requestopt","requestoptions()","request。这些方法都不会立即发送请求，而是返回一个","request，允许您在运行时指定","requir","res.cause());","res.cause().getmessage());","res.result());","res.result();","reset","reset.getcode());","resget","resget.result();","resolv","resolvea","resolveaaaa","resolvecnam","resolvemx","resolven","resolveptr","resolvesrv","resolvetxt","resolveuri(response.request().absoluteuri(),","resourc","resp","resp.bodyhandler(bodi","respons","response).start();","response.bodyhandler(totalbuff","response.customframehandler(fram","response.end(\"hello","response.end());","response.end();","response.endhandler(v","response.getheader(\"location\")","response.getheader(\"location\"));","response.handler(buff","response.headers().get(\"cont","response.headers();","response.push(httpmethod.get,","response.putheader(\"cont","response.puttrailer(\"x","response.sendfile(\"\");","response.setchunked(true);","response.setstatuscode(400).end();","response.statuscode());","response.statusmessage());","response.trailers();","response.write(\"hello","response.write(\"som","response.write(buffer);","response.writecustomframe(frametype,","response，您可使用任意一个","resput","rest","result","result.cause());","result.result())","result.result();","result:","resume：恢复处理器，若任何项到达则处理器将被调用","return","return;","reus","reverselookup","rfc定义的。","rfc建议推荐值为100","robin：轮询","round","rrset不存在","rsa","rubi","run","run()","runoncontext","run命令可以使用几个可选参数，它们是：","same","scan","sd","sd.getclusterwidemap(\"mymap\",","sd.getcounter(\"mycounter\",","sd.getlocalmap(\"mymap1\");","sd.getlocalmap(\"mymap2\");","sd.getlock(\"mylock\",","sd.getlockwithtimeout(\"mylock\",","second","section","see","selfsignedcertif","selfsignedcertificate.create();","send","sender()：表示数据报发送方的inetsocketaddress","sender.j","sender：发送者","sender：表示数据发送方的inetsocketaddress。","sendfil","sendhead","server","server\");","server.actualport());","server.close(r","server.connecthandler(sock","server.connecthandler(socket","server.connectionhandler(connect","server.j","server.listen();","server.listen(0,","server.listen(1234,","server.listen(8080,","server.requesthandler(request","server.websockethandler(websocket","serveropt","serverwebsocket","server可配置成接收到","server：服务器","servfail","service:com.mycompany:myorderservic","set","setaddressresolveroptions(","setarg(str","setbroadcast设置或清除so_broadcast套接字选项，设置此选项时，数据报（udp）数据包可能会发送到本地接口的广播地址。","setcertpath(\"/path/to/your/cli","setcertpath(\"/path/to/your/serv","setcertvalue(mycertasabuffer);","setchunck","setclientauth(clientauth.required).","setclustered、getclusterhost和","setclustermanag","setcompressionlevel","setcompressionsupport","setcreatenew","setdecompressionsupport","setdeleteonclos","setdsync","setexpectmultipart(true)","setextraclasspath","setflag","setflag(boolean","sethandle100continueautomat","sethidden","sethostnameverificationalgorithm(\"https\");","sethostspath(\"/path/to/hosts\"))","sethost）","sethttp2cleartextupgrad","sethttp2maxpoolsize(3);","sethttp2multiplexinglimit","sethttp2multiplexinglimit(10).","setinitialset","setisolatedclass","setjdksslengineoptions(new","setkeepal","setkeypath(\"/path/to/your/cli","setkeypath(\"/path/to/your/serv","setkeystoreoptions(jksoptions);","setkeystoreoptions(keystoreoptions).","setkeystoreoptions(keystoreoptions);","setkeyvalue(mykeyasabuffer).","setmaxpools","setmaxredirect","setmulticastnetworkinterface设置或清除ip_multicast_loop套接字选项，设置此选项时，多播数据包也将在本地接口上接收。","setmulticasttimetolive设置ip_multicast_ttl套接字选项。ttl表示“活动时间”，单这种情况下，它指定允许数据包经过的ip跳数，特别是用于多播流量。转发数据包的每个路由器或网管会递减ttl，如果路由器将ttl递减为0，则不会再转发。","setmultivalu","setname(str","setndot","setopensslengineopt","setopensslengineoptions(new","setpassword(\"password","setpath(\"/path/to/your/cli","setpath(\"/path/to/your/serv","setpath(\"/path/to/your/truststore.jks\").","setpath(\"/path/to/your/truststore.pfx\").","setpemkeycertoptions(pemoptions);","setpemtrustoptions(","setperiod","setperm","setpfxkeycertoptions(pfxoptions);","setpfxtrustoptions(","setpipelininglimit","setprotocolvers","setprotocolversion(httpversion.http_2).","setrawmethod","setread、setwrit","setreceivebuffersize设置tcp接收缓冲区大小（以字节为单位）。","setreconnectattempt","setreconnectattempts(10).","setreconnectinterv","setreconnectinterval(500);","setreuseaddress若为true，则time_wait状态中的地址在关闭后可重用。","setrotateserv","setsendbuffersize以字节为单位设置发送缓冲区的大小。","setssl","setssl(true).","setssl(true)。","setstatuscod","setstatusmessag","setter","settim","settimeout设置一个特定","settings\");","settings_max_concurrent_stream","settrafficclass","settruncateexist","settrustall(true);","settruststoreoptions(","settruststoreoptions(trustoptions).","settryusecompress","setunsignedxxx","setusealpn","setusealpn(true).","setvalue(mykeystoreasabuffer).","setvalue(mytruststoreasabuffer).","setwork","setworkerpools","setwritequeuemaxs","setwritequeuemaxsize：与","setwritequeuemaxsize：设置写入队列被认为是","setxxx","severe:","sha256\").","sha384\").","sha384\");","shadowjar'","share","shareddata","shell中使用。","short","shutdown","shutdownhandl","side","side\");","signint。","simpl","singl","size!\");","slf4j","slf4j:","slf4j启动警告","slice","small","sock).start();","sock.drainhandler(don","sock.handler(buff","sock.pause();","sock.resume();","sock.write(buffer);","socket","socket.blockmulticastgroup(\"230.0.0.1\",","socket.closehandler(v","socket.handler(buff","socket.handler(packet","socket.listen(1234,","socket.listenmulticastgroup(\"230.0.0.1\",","socket.send(\"a","socket.send(buffer,","socket.unlistenmulticastgroup(\"230.0.0.1\",","socket.write(\"hello!\").end())","socket.write(\"som","socket.write(buff);","socket.write(buffer);","socket。","socket的连接被关闭","socket这边的地址，它将返回一个inetsocketaddress，否则返回null。","socket）","socket，则不会给我们任何加密的机会。","socket：套接字（有些地方未翻译，直接用的","socks4","socks4a","socks5","someapi.blockingmethod(\"hello\");","somejavasourcefile.java","someon","somescript.groovi","someth","sourc","source\")","specif","spi","src/main/resources/meta","srvrecord允许您访问srv记录本身中包含的所有信息：","ssl","ssl/tl","ssl/tls。默认是禁用的。","ssl/tls，该值设置成false将禁用ssl/tls。","ssl/tls，该值设置成true将启用ssl/tls，实际的客户端ssl/tls（如受信、密钥/证书、密码、alpn","ssl可以通过每个请求的","ssl引擎","standard","stardand","start","start()","start(futur","startfutur","startfuture)","startfuture);","startfuture.complete();","startfuture.completer());","startfuture.fail(res.cause());","start等","start：启动泵。","statu","status:","statuscod","statusmessag","step），等待下一步的指示。","step，英国父母会在家里选择一个角落作为小孩罚站或静坐的地方，被称为","stop","stop()","stop(futur","stopfuture)","stopfuture.complete();","stopfuture.fail();","stop：停止泵，当泵启动时它要处于停止模式。","store：受信存储","straight","stream","stream.print(builder.tostring());","streamresetexcept","streamresetexception)","streamtofilesystem","string","string\");","string\",","string,","string/buff","stringbuild","stringbuilder();","string、number、boolean","string是不可变的，所以不需要复制","succeeded?","successfulli","suite：密码套件","summary.\")","super(hellocommand.class);","support","support\")","support），因此我们提供了两个类，以便在","synchron","system.err.println(\"cannot","system.err.println(\"fail","system.err.println(\"oh","system.err.println(\"woops:","system.getenv(\"home\");","system.getproperty(\"prop\");","system.out.println(\"a","system.out.println(\"and","system.out.println(\"block","system.out.println(\"clos","system.out.println(\"configuration:","system.out.println(\"connect","system.out.println(\"connected!\");","system.out.println(\"context","system.out.println(\"copi","system.out.println(\"could","system.out.println(\"deploy","system.out.println(\"everyth","system.out.println(\"fail","system.out.println(\"failed:","system.out.println(\"fil","system.out.println(\"first","system.out.println(\"ful","system.out.println(\"got","system.out.println(\"hello","system.out.println(\"i","system.out.println(\"listen","system.out.println(\"read","system.out.println(\"receiv","system.out.println(\"registr","system.out.println(\"remot","system.out.println(\"send","system.out.println(\"serv","system.out.println(\"statu","system.out.println(\"stream","system.out.println(\"th","system.out.println(\"thi","system.out.println(\"tim","system.out.println(\"tot","system.out.println(\"un","system.out.println(\"undeploy","system.out.println(\"unexpect","system.out.println(\"unlisten","system.out.println(\"us","system.out.println(\"w","system.out.println(\"written","system.out.println(ar.result());","system.out.println(body.tostring(\"iso","system.out.println(buff.getunsignedbyte(pos));","system.out.println(buffer));","system.out.println(h.tostring());","system.out.println(record);","system.out.println(result.result());","target","target/mi","tcnativ","tcp","termin","text","text\").end();","text\");","thead.sleep()","then...","this);","this.arg","this.flag","this.nam","thread","thread\");","throw","throwabl","tid","time","timeoutstream,","timerid","timer：计时器","tl","tlsv1.2。","tls（传输层安全性协议）。早期版本的tls被称为ssl。","totalbuff","totalbuffer.appendbuffer(buffer);","totalbuffer.length());","trailer","trailers.set(\"x","trailers方法读取响应尾，尾数据也是一个","transfer","tri","true)","true);","true;","true，则客户端将信任所有服务端证书。连接仍然会被加密，但这种模式很容易受到中间人攻击。即您无法确定您正连接到谁，请谨慎使用。默认值为false。","true，让解析器使用轮询选择。它会在服务器之间传播查询负载，并避免所有的查找都找到列表中的第一个服务器。","trust","trustal","trustopt","truststore\")","type","type\");","type\",","type=\"","typedargument()","typedoption()","typedoption和typedargument可以指定一个类型，因此（string）原始值将转换为指定的类型。","udp是无连接的传输，这意味着您与远程客户端没有建立持续的连接。","un","undeploy","undeploy：撤销（反部署，对应部署）","unregist","unregister()","unregistercodec","unregisterverticlefactori","unregister：注销（反注册，对应注册）","up","updat","upgrade方法：","upload","upload.filename());","upload.handler(chunk","upload.name());","upload.streamtofilesystem(\"myuploads_directory/\"","uploadhandler。","uri","uri\");","uri\",","uri。","uri，path，param","url","urlencod","url。connect","url时，它要求代理使用","url时，它连接到代理服务器，并在http请求中提供完整url（get","us","us,","usag","usage:","usagemessageformatt","user","utf","val","valu","valuation.\")","value\"));","value\");","version","vert.x","vert.x\");","vert.x。","vert.x会尽它最大努力去传递消息，并且不会主动丢弃消息。这种方式称为","vert.x使用内置的日志api进行记录日志，默认实现使用jdk（jul）日志，不需要额外的依赖项。","vert.x使用地址解析器将主机名解析为ip地址，而不是jvm内置的阻塞解析器。","vert.x允许您很容易编写非阻塞的tcp客户端和服务器。","vert.x允许您运行支持高可用（ha，high","vert.x发行版中使用的默认集群管理器是使用的hazelcast集群管理器，但是它可以轻松被替换成实现了vert.x集群管理器接口的不同实现，因为vert.x集群管理器可替换的。","vert.x在这里有一点魔法。","vert.x将按照特定发送者发送消息的顺序来传递消息给特定处理器。","vert.x提供了异步文件访问的抽象，允许您操作文件系统上的文件。","vert.x支持","vert.x有多个对象可以用于文件的读取和写入。","vert.x本身只是一个库，您可以在自己的应用程序使用任何日志库的api来记录日志。","vert.x的工作方式有所不同。每个","vert.x还提供了一种更方便的方式指定配置文件，无需设置系统属性。您只需在您的类路径中提供名为vertx","vert.x，而","verticl","verticle\",","verticle.groovi","verticle.j","verticle.jar","verticle.js的vert.x","verticle.js）时，迁移才是可能的。","verticle.js，所以现在这个vert.x","verticle.rb","verticlefactory。","verticle。","verticle。为此，您需要下载并安装vert.x","verticle中的自动清理","verticle可以启用高可用方式（ha）部署。在这种方式下，当其中一个部署在","verticle名称到factory的映射规则","verticle实例","verticle并传入一些配置：","verticle指定要运行的main","verticle撤销时调用","verticle的名称。","verticle的实例","verticle的部署是异步方式，可能在","verticle部署时调用","verticle部署模型，避免在","verticle（java完全限定类名或脚本文件名）","verticle，也可用于其他目的，例如加载服务、运行时从maven中获取verticle实例等。","verticle，仅需要追加","verticle，以下是run命令的几个实例：","verticle，但是它可以由不同的线程同时执行。","verticle，在","verticle，并让它们彼此在网络上的其他任何服务器上集群在一起：","verticle，当父","verticle，您可以通过","verticle，您可以通过在命令行上使用","verticle：","verticle：这是最常用的一类","verticle：这类","vertx","vertx.cachedirbas","vertx.cachedirbase=/tmp/vertx","vertx.canceltimer(timerid);","vertx.clusteredvertx(options,","vertx.createdatagramsocket(new","vertx.creatednsclient(53,","vertx.createhttpclient(","vertx.createhttpclient().getnow(8080,","vertx.createhttpclient();","vertx.createhttpclient(clientoptions);","vertx.createhttpclient(options);","vertx.createhttpserver().requesthandler(request","vertx.createhttpserver();","vertx.createhttpserver(http2options);","vertx.createhttpserver(new","vertx.createhttpserver(options);","vertx.createnetclient();","vertx.createnetclient(clientoptions);","vertx.createnetclient(options);","vertx.createnetserver(","vertx.createnetserver();","vertx.createnetserver(options);","vertx.createnetserver(serveroptions)","vertx.createsharedworkerexecutor(\"mi","vertx.deployverticle(\"com.foo.otherverticle\",","vertx.deployverticle(\"com.mycompany.myorderprocessorverticle\");","vertx.deployverticle(\"com.mycompany.myorderprocessorverticle\",","vertx.deployverticle(\"com.mycompany.myverticle\",","vertx.deployverticle(\"com.mycompany.myverticle.verticleclass\",","vertx.deployverticle(\"th","vertx.deployverticle(\"verticles/my_verticle.rb\");","vertx.deployverticle(\"verticles/myverticle.js\");","vertx.deployverticle(myverticle);","vertx.eventbus();","vertx.executeblocking(futur","vertx.filesystem().copy(\"target/classes/readme.txt\",","vertx.filesystem().delete(\"target/classes/junk.txt\",","vertx.filesystem().exists(\"target/classes/junk.txt\",","vertx.filesystem().open(\"target/classes/hello.txt\",","vertx.filesystem().open(\"target/classes/les_miserables.txt\",","vertx.filesystem().openblocking(\"target/classes/plagiary.txt\",","vertx.filesystem().readfile(\"target/classes/readme.txt\",","vertx.filesystem().readfileblocking(\"/path/to/your/ca","vertx.filesystem().readfileblocking(\"/path/to/your/cli","vertx.filesystem().readfileblocking(\"/path/to/your/crl.pem\");","vertx.filesystem().readfileblocking(\"/path/to/your/serv","vertx.filesystem().readfileblocking(\"/path/to/your/truststore.jks\");","vertx.filesystem().readfileblocking(\"/path/to/your/truststore.pfx\");","vertx.filesystem().writefile(\"target/classes/hello.txt\",","vertx.filesystem();","vertx.getorcreatecontext().runoncontext(v","vertx.getorcreatecontext();","vertx.io","vertx.setperiodic(100,","vertx.setperiodic(1000,","vertx.settimer(1000,","vertx.settimer(5000,","vertx.shareddata();","vertx.undeploy(deploymentid,","vertx.vertx();","vertx.vertx(new","vertxopt","vertxoptions()","vertxoptions().","vertxoptions().setworkerpoolsize(40));","vertxoptions();","vertxoptions对象有很多配置，包括集群、高可用、池大小等。在javadoc中描述了所有配置的细节。","vertx工具也可以使用start、stop和list命令，start命令支持几个选项：","void","volatil","want...","web","websocket","websocket,","websocket.framehandler(fram","websocket.reject();","websocket.writebinarymessage(buffer);","websocket.writefinalbinaryframe(buff);","websocket.writefinaltextframe(\"geronimo!\");","websocket.writeframe(frame1);","websocket.writeframe(frame2);","websocket.writeframe(frame3);","websocket.writetextmessage(message);","websocketfram","websocketframe.binaryframe(buffer1,","websocketframe.binaryframe、websocketframe.textfram","websocketframe.continuationfram","websocketframe.continuationframe(buffer2,","websockethandler。","websocket。","websocket实例：","websocket等。","websocket，可使用writebinarymessag","web对请求中的路径进行了规范，以防止恶意客户端通过伪造url来访问web根目录以外的资源。","web应用程序的服务器场中的会话状态存储非常有用。","web提供上传到磁盘上已知位置的功能，且不依赖客户端提供的文件名，客户端提供的文件名可被恶意伪装成上传到硬盘上的不同位置。","web替代。","web而非直接使用vert.x","went","we’ll","wibble\",","wide","wire：报文","work","worker","worker\");","workerexecutor","worker：此选项可确定一个verticle是否为work","world!\");","world!\",","world\");","world”","worms）。","write","write:","writecontinu","writecustomfram","writefinalbinaryfram","writefinaltextfram","writefram","writehandlerid","writequeuefull：若写队列被认为已满，则返回true。","writestream","writestream。","writestream（可写流）接口的实现类包括：httpclientrequest,","writestream，然后启动它：","writestream，该方法将永远不会阻塞，内部是排队写入并且底层资源是异步写入。","writetextmessag","write：写入一个对象到","writing：编写（有些地方译为开发）","written\");","wrong","wrong!","www","x","xbootclasspath/p:/path/to/alpn","xxxblocking，它要么返回结果或直接抛出异常。很多情况下，一些潜在的阻塞操作可以快速返回（这取决于操作系统和文件系统），这就是我们为什么提供它。但是强烈建议您在","xxxnow","x，","y","y\"));","you?","yxdomain","yxreset","zxvf","{","{1,","|","}","}).compose(v","}).end(\"som","}).end();","}).listen();","}).listen(8080);","}).putheader(\"cont","}).setfollowredirects(true).end();","});","},","——","“hello","“压缩级别”","“映射”，名词为数据结构未翻译","“记录”，名词翻译成日志器","。","。当全部","一下是随机访问读的示例：","一个","一个json","一个jul日志记录配置文件可以使用普通的jul方式指定——通过提供一个名为java.util.logging.config.file的系统属性值为您的配置文件。更多关于此部分以及jul配置文件结构的内容，请参阅jul日志记录文档。","一个处理订单的消息消费者也许会用true确认这个订单已经成功处理并且可以从数据库中删除。","一个实现了持久化队列的消息消费者，当消息成功持久化到存储时，可以使用true来应答消息，或false表示失败。","一个应用程序通常是由在同一个","一个文件被创建（fut1）","一个最简单的方法是直接获取已经读取的数据，并立即将其写入netsocket：","一个泵可以启动和停止多次。","一个流式的api表示将多个方法的调用链在一起。例如：","一个独立的","一个简单地实现了返回当天时间的服务，在应答的消息里会包含当天时间信息。","一个非ssl/tls连接可以通过upgradetossl方法升级到ssl/tls连接。","一个非常简单的例子是从netsocket读取然后写回到同一个netsocket","一些东西被写入到文件（fut2）","一些代码","一些例子：","一些合法的地址形如：europe.news.feed1、acme.games.pacman、sausages和x。","一旦在后台启动，可以使用stop命令停止它：","一旦完成了","一旦您完成了","一旦您有了一个实例，您可以获取当前的计数，以原子方式递增、递减，并使用各种方法添加一个值。","一旦您的","一旦您的cli实例配置好后，您可以生成","一旦您这样做，您将发现echo服务器在功能上与之前相同，但是服务器上的所有核都可以被利用，并且可以处理更多的工作。","一次性计时器","一次性计时器会在一定延迟后调用一个","一般来说，不应该在不同的","一起使用。选项可以获取用法中显示的描述（见下文）。选项可以接受0、1或几个值。接受0值的选项是一个标志(flag)，必须使用","上下文环境之间共享客户端，因为它可能导致不可预知的意外。例如：保持活动连接将在打开连接的请求上下文环境调用客户端处理器，后续请求将使用相同上下文环境。","上传对象实现了","上传的文件可能很大，我们不会在单个缓冲区中包含整个上传的数据，因为这样会导致内存耗尽。相反，上传数据是以块的形式被接收的：","上发送消息来相互通信。","上发送的消息可包含头信息。这可通过在发送或发布时提供的","上所有的普通代码都会在此","上执行的操作总是在同一个","上执行（即对应的","上注册过的处理器。","上的ssl，可调用函数","上绑定的处理器（handler）会被调用。当一个操作失败（其中的某一个","上调用","上调用了","上边代码段描述了如何在event","上边生成的","上面的例子有一个问题：如果从socket读取数据的速度比写回socket的速度快，那么它将在netsocket的写队列中不断堆积，最终耗尽内存。这是有可能会发生，例如，若socket另一端的客户端读取速度不够快，无法快速地向连接的另一端回压。","下边例子中，值","下边是apach","下边是示例：","下面我们来看一下","下面有更多的例子：","不严格的轮询算法","不仅仅存在于单个","不会强迫您用这种方式创建您的应用程序。","不会自动关闭","不像在调用中提供响应处理器来创建客户端请求对象，相反您可以当请求创建时不提供处理器、稍后在请求对象中调用","不允许请求或响应流执行清除重置，如当客户端上传的资源已经存在于服务器上，服务器就需要接受整个响应。","不允许请求或响应流进行重置，如当客户端上传了服务器上存在的资源时，服务器依然要接收整个响应。","不兼容。","不同。","不同于","不同的","不支持alpn的客户端仍然可以执行经典的ssl握手。","不要阻塞我！","不难看出，若写入对象的速度比实际写入底层数据资源速度快，那么写入队列就会无限增长，最终导致内存耗尽。","与发布消息的不同之处在于，发送(send)的消息只会传递给在该地址注册的其中一个处理器，这就是点对点模式。vert.x","两个处理器过后，在流重置完成时您将会收到通知。","两个处理器过后，在流重置完成时您将会收到通知：","两者都支持。若找到这样的请求头，服务器将使用所支持的压缩算法之一自动压缩响应正文并发送回客户端。","中","中不同的概念和特性。","中会有一个内置的","中作为主类，由","中使用","中使用启动器","中使用它之前测试使用它们究竟需要耗费多长时间，以避免打破黄金法则。","中使用或者嵌入使用。","中使用时，verticl","中创建了计时器，当这个","中创建，那么","中加载，并在","中包含了响应体的这一分片（部分）内容：","中发送任何对象，只要你为这个对象类型注册一个编解码器","中发送任意对象。您可以通过为您想要发送的对象自定义一个","中启动：","中处理的非","中完成此操作。","中定义的。","中并行执行。","中开始写入数据的位置。buffer","中异步执行代码了。换句话说，您提交的任务将会在同一个","中您不能直接让线程休眠以引入延迟，因为它会阻塞","中执行它的","中执行，通过","中指定一个超时时间。如果在这个时间之内没有收到应答，则会以失败为参数调用应答处理器。默认超时是","中指定，但建议您将代码编写成verticle，并使用vert.x中的launcher类（io.vertx.core.launcher）作为您的主类。这是在命令行中运行vert.x使用的主类，因此允许您指定命令行参数，如","中撤销处理器，则同样会花费一些时间在节点中传播。若您想在完成后收到通知，可以使用unregister(handler)","中注册了","中的","中的一个通用模式，所以请适应这种代码风格。","中的偏移量","中的全部或部分发生故障时，则可能会丢失消息。","中的字符会以","中的操作同时运行。当组合的处理操作完成时，该方法返回的","中的方法并传入了处理器时，vert.x","中的某个线程来执行。","中的状态不会在响应中描述","中的线程上。一个实例可以由多个线程同时执行（译者注：因此需要开发者自己确保线程安全）。","中的线程上。一个实例绝对不会被多个线程同时执行。","中的线程执行。","中的自动清理","中的资源","中的资源写入socket。这种做法是非常高效的，它可以被操作系统内核直接处理。","中的通常做法是使用","中的部分api：仅关闭操作，实现了关闭处理器和异常处理器。该协议并不提供其他操作的语义。","中直接调用阻塞式操作，因为这样做会阻止","中自动清理","中自动清除定时器","中自定义","中英对照表","中获取","中被多个线程同时执行，但它可以在不同时间由不同线程执行。","中解析读取的，若您已经将表单属性存放在请求体中发送出去，并且该请求为","中设置了java","中访问环境变量","中读取或追加/设置到","中读取数据","中读取数据，它存在各种不同数据类型的方法，这些方法的第一个参数是从哪里获取数据的索引（获取位置）。","中运行了多个处理函数时，可能需要在它们之间共享数据。","中运行：","中（或构建工具的依赖中）包含","中）","中）之间安全共享数据。","中，写调用是立即返回的，而写操作的实际是在内部队列中排队写入。","中，并从任何其他节点读取。","中，您可以使用","中，想要延迟之后执行或定期执行操作很常见。","中，类路径中jar文件或其他文件）时，它会把文件复制到缓存目录。背后原因很简单：从","中，集群管理器可用于各种功能，包括：","临时响应信息。这个可通过","为","为了利用更多的服务器核，您将需要部署更多的服务器实例。您可以在代码中以编程方式实例化更多（server的）实例：","为了解决后边一个问题，vert.x也允许您调整原始的","为了解决这个问题，vert.x","为了进行调试，可以记录网络活动：","为了进行调试，可记录网络活动。","为了连接池（能）工作，配置客户端时，keep","为依赖，在项目中直接使用","为参数被调用。","为响应设置处理器","为当前请求推送资源","为此，您可以调用其中一个指定的请求方法，如","为此，您应该设置一个名为vertx.logg","为此，您需要下载并安装","为此，您需要使用loggerfactory获取一个logger对象以记录日志：","主机名使用以下方式解析为ip地址：","主机名解析","主机映射","之前","之后，您的应用另外一部分","之间分享对象，那这种情况您无需考虑。","之间设置一个对话窗口。这种消息模式被称作","也会运行在","也可以与ha组合使用，在这种情况下，每个特定组会解决","也可以从json表单中实例化选项。","也可以在ide中使用重部署功能：","也支持通过","也支持通过buffer来配置：","也是一个","了消息。","事件总线","事实是，很多，也非所有的库，特别是在jvm生态系统中有很多同步api，这些api中许多方法都是阻塞式的。一个很好的例子就是","仅仅遵循301状态代码","仅限java语言。","仍然使用缓存，但始终使用原始源刷新存储在缓存中的版本。因此，如果您编辑从类路径提供的文件并刷新浏览器，vert.x","从","从buffer中读取","从foo.txt拷贝到bar.txt","从map读取数据","从socket读取数据","从websocket","从命令行直接运行vert.x","从命令行运行verticl","从响应中读取cooki","从字符串创建一个","从字节数组","从磁盘中读取了一些数据","仓库中中的","代理。","代理可以在","代理支持，因为代理仅支持","代理的例子：","代理访问","代理（如squid）或","代理：","代码块会","以utf","以下是一个例子：","以下是一些事件的例子：","以下是二进制帧的示例：","以下是使用","以下是使用阻塞","以下是使用隔离组隔离","以下是文件异步拷贝的示例：","以便更轻松地扩展应用程序。","以及","以后不需要再使用","以外）它们总是在同一个","以指定的编码方式写入一个字符串","以满足任何希望升级到","任何可控制的写入流对象都实现了","任何服务都可能存在潜在的漏洞，无论是使用vert.x还是任何其他工具包，因此始终遵循安全最佳实践，特别是当您的服务面向公众。","任意一个","会从类路径读取它，将其复制到缓存目录并从中提供。不要在生产环境使用这个设置，它很有可能影响性能。","会使用轮询策略来管理请求处理。","会像对应的处理函数传入一个","会写入一定量的数据，您可以创建","会将事件传给处理器来处理。","会将文件复制到其缓存目录中，并随后读取该文件。这个行为也可配置。","会循环执行，处理所有到达的事件并传递给处理器处理。","会是一个","会自动在event","会自动撤销任何子","会被标记为失败。当所有的操作都成功时，返回的","会被销毁。","会运行在","传入之后，这个配置可以通过","传入配置","传递一个事件给处理器或者调用","传递给","传递给处理器的对象是一个","但不幸的是，java","但它可以满足服务器所要求的cpu周期的不可控的成本（注意现在vert.x不支持任何缓存形式的响应数据，如静态文件，因此压缩是在每个请求体生成时进行的）,它可生成压缩过的响应数据、并对接收的响应解码（膨胀）——","但是","但是……真实世界并非如此（您最近看新闻了吧？）","但是在某些情况下，您可能需要部署一个verticle，它包含的类要与应用程序中其他类隔离开来。比如您想要在一个vert.x实例中部署两个同名不同版本的verticle，或者不同的verticle使用了同一个jar包的不同版本。","但是要注意，即使数据包尺寸小于mtu，它仍然可能会发送失败。","但是，当","但是，您也可以从命令行直接运行","但是，若您愿意，也可以使用上述的vert.x日志记录工具为应用程序记录日志。","作为","作为parse的第二个参数来禁用验证。如果要检查参数或选项，即使解析的命令行无效，这也是有用的。","作为压缩级别，但是该参数可通过","作为参数（最多6个），并将结果归并成一个","作为参数（最多6个，或传入","作为可写流或可读流时，它只能用于不分割多个帧的二进制帧一起使用的","作为消息发送。不过在","作为缓存目录，它在此之间创建一个唯一的目录，以避免冲突。可以使用","作参数被调用。方法执行完时，verticl","你可以通过一个json","使用","使用buffer结束","使用cli","使用javascript的factori","使用openssl引擎","使用put","使用query读取uri中的查询部分。","使用setdefaultvalue设置默认值","使用sethidden隐藏","使用setmultivalued设置接收多个值——只有最后一个参数可以是多值的。","使用setrequired设置必填","使用不严格的轮询算法来选择绑定的处理器。","使用另一个日志框架","使用失败码拒绝并关闭这个连接，这可能是长连接最好的","使用失败码拒绝忽略请求体，若体很小，这是适用的","使用字符串紧跟着一个冒号，它用于查找存在的factory，参考例子。","使用所有默认选项创建","使用无符号数","使用注解","使用流式响应","使用流式请求","使用说明","使用集群模式运行groovy的verticl","使用静态valueof方法，如基础类型和枚举","使用静态的from或fromstring方法","使用高于","使用默认设置运行javascript的verticle：server.js：","例如，您可以将磁盘上的文件直接泵送到http","例如，您应该始终在dmz中运行它们，并使用具有受限权限的用户账户，以限制服务受到损害的程度。","例如，若您使用\\n分割的简单ascii文本协议，并输入如下：","例如，若您部署了一个创建netserver的verticle，该netserver在处理器中提供了netsocket","例如，请求的uri为：","例子中使用了：","依照udp的本质，它最适合一些允许丢弃数据包的应用（如监视应用程序）。","信息","信息如下：","信息，请查阅","信息：","值。","值，对于","做一些事","做一些其他的事情","做一些工作","允许单个","允许您传递一个handler，一旦查询完成将会传入一个asyncresult给handler并通知它。","允许您在同一个","允许您在客户端请求对象中设置一个","允许您轻松编写非阻塞的","全限定类名（fqcn）然后尝试实例化它。","共享","共享数据","共享数据包括本地共享map、分布式、集群范围map、异步集群范围锁和异步集群范围计数器。","共享数据（share","关于","关于高可用的功能和配置的更多细节可参考","关闭","关闭datagramsocket","关闭处理器","关闭底层连接","关闭操作也是异步的，可能直到方法调用返回过后一段时间才会实际关闭。若您想在实际关闭完成时收到通知，那么您可以传递一个处理器。","关闭时收到通知，可以设置一个","其中","其中my_verticle.conf也许会包含以下配置：","其他map操作","其他命令","其他很多情况","其他默认的","其优点是与tcp相比具有更少的开销，而且可以由netserver和netclient处理（参考前文）。","具有单个string参数的构造函数，例如file或jsonobject","具有附加值的短选项（即gcc","内创建了","内联阻塞式代码。","内设置","内部创建的","内部，大部分数据被重新组织（shuffle，表意为洗牌）成","写","写buffer","写utf","写一个简单文本消息","写一些块","写入","写入到http","写入字符串，这种请求字符串将使用","写入带编码方式的字符串，这种情况字符串将使用指定的编码方式编码，并将结果写入到报文中。","写入帧","写入操作是异步的，可能调用","写入数据的方式有两种：追加和随机写入。任何一种情况下","写入消息","写处理器","写指定编码的字符串","写数据到磁盘","写文件","写最终帧","写请求体","写请求头","出了些问题","出现一些错误","函数完成写入和请求的发送操作。","函数：","分块","分块传输编码(http","分块则不需要担心这点。","分块模式，则不需要","分块，则必须在写入请求之前设置content","分块，那么必须在写入响应之前设置","分布式map的支持","分布式计数器","分布式锁","列表。","列表。或者您可以在响应中自己解析set","列表传参：","列表（可能为空）：","列表：","创建","创建一个指定初始大小的","创建一个空的","创建客户端将使用的新的可用请求","创建客户端时可使用","创建的时候设置。","创建空的缓冲区","创建连接","创建集群模式的","初始化时分配了更多的内存，比数据写入时重新调整大小的效率更高。注意以这种方式创建的","到","到http请求中，您可以直接调用","前缀，而短名称与单个","功能。","加入多播组","包或任意子包中的任意类名。","区域（参数选项卡中），写入run","升级到","协议","协议。","协议中使用","协议之上实现。","协议使用","协议版本可以通过显式添加启用协议进行配置：","协议版本可在netserveroptions或netclientoptions配置项中指定。","协议达成一致，尽管服务器或客户端决定了仍然使用","协议，这样的连接是使用","单一线程的问题在于它在任意时刻只能运行在一个核上。如果您希望单线程反应器应用（如您的","单个连字符的长选项（即ant","单个连接的管道请求限制数由","即使客户端配置成不使用","即使客户端配置成使用","即异步开发模式中的","即最初不运行任何verticle的实例，它们也将为集群中的节点进行故障转移。要启动一个裸实例，您只需做：","压缩","压缩。","压缩功能。这意味着客户端可以让远程服务器知道它支持压缩，并且能处理压缩过的响应体（数据）。","压缩时，服务器将检查客户端请求头中是否包含了","压缩的客户端和不支持的客户端。","压缩算法。vert.x","压缩算法的","压缩级别允许根据所得数据的压缩比和压缩/解压的计算成本来配置","压缩级别是从","压缩，则它可以发回没有压缩过的请求。","压缩，它将包含例如下边的头：","原文档更新于2017","去考虑线程和扩展问题。您不用再考虑","参数","参数。","参数也可以从json表单中实例化。","参数没有名称，使用基于","参数的","参数的值设为","参数的变量，以指定多个的dns服务器来尝试查询解析dns。它将按照此处指定的相同顺序查询dns服务器，若在使用上一个dns服务器解析时出现了错误，下一个将会被继续调用。","参数：","又或者收到一个http请求：","发出请求","发回响应","发布/订阅模式","发布/订阅消息","发布消息","发布消息很简单，只需使用","发生了一个异常","发生这些情况时，应答处理器将会以这些失败为参数被调用。","发行版，并将安装目录中的bin添加到path环境变量中，还要确保您的path上有一个java","发送","发送100","发送buffer","发送buffer到多播地址","发送get请求","发送head请求","发送main.js响应","发送一个字符串","发送一帧到服务器","发送到一个","发送多播数据包","发送失败","发送数据。","发送数据包很容易，如下所示：","发送数据报包","发送文件或","发送文件是异步的，可能在调用返回一段时间后才能完成。如果要在文件写入时收到通知，可以在","发送消息","发送消息给接收者并等待回复","发送由单个最终二进制帧组成的websocket消息：","发送者：","发送请求的资源内容","发送通用请求","取决于jvm的版本，如","取消计时器","取消订阅/离开多播组","受信存储。","另一种单独提供服务器私钥和证书的方法是使用","另一种提供服务器证书颁发机构的方法是使用一个","另一种提供服务器证书颁发机构的方法是使用一个.pem文件列表。","另外一种分别提供服务器私钥和证书的方法是使用.pem文件。","另外一种运行阻塞式代码的方法是使用","只要不存在对象的循环引用，嵌套的","可以为不同的用途创建不同的池：","可以为您处理这种情况。在与现有服务端相同的主机和端口上部署另一个服务器时，实际上并不会尝试创建在同一主机/端口上监听的新服务端，它只绑定一次到socket，当接收到请求时，会按照轮询策略调用服务端的请求处理函数。","可以从字符串或字节数组初始化，或者直接创建空的","可以使用","可以使用静态方法","可以使用默认构造函数创建空的json对象。","可以使用默认构造函数创建空的json数组。","可以在事件到达时快速地分发到不同的处理器中。","可以在创建的时候配置：","可以在接收服务器推送的请求/响应的请求上设置一个推送处理器：","可以在服务器上设置连接处理器，任意连接传入时可得到通知：","可以在请求上设置连接处理器在连接发生时通知：","可以在部署配置项中指定不同的worker","可以在集群环境中的另一个","可以处理以","可以处理在客户端通过","可以将客户端配置为在无法连接的情况下自动重试。这是通过","可以嵌套在非","可以用utf","可以用来协调多个异步操作的结果。它支持并发组合（并行执行多个异步调用）和顺序组合（依次执行异步调用）。","可以调用","可以通过以下几种方式为服务端配置证书/密钥：","可以通过调用","可以通过配置证书吊销列表（crl）来吊销不再被信任的证书机构。crlpath配置了使用的crl：","可以非常迅速地处理数千个","可使用","可使用jdk随附的keytool实用程序来管理java","可发送请求体剩余部分","可在短时间内分发大量的事件。例如，一个单独的","可在部署时传给","可替换主机文件：","可用于实例化不同语言的","可用于提供自签名pem证书，并可以提供","可用的各种选项完整信息，可以直接在命令行键入","可能对应多个","可能的dnsresponsecode值是：","可选","可通过设置io.netty.util.internal.logging.internalloggerfactory强制netty使用某个特定实现。","同一个地址可以注册许多不同的处理器，一个处理器也可以注册在多个不同的地址上。","同任何花哨的寻址方案相比，vert.x的地址格式并不麻烦。vert.x中的地址是一个简单的字符串，任意字符串都合法。当然，使用某种模式来命名仍然是明智的。如：使用点号来划分命名空间。","同时也表示（客户端）可以发送请求的剩余部分。通常将其与","同时用作客户端和服务器，因此这些配置近似于","同样意味着您可以将您的应用中的所有代码用单线程方式编写，让","同样的，这儿也有一个异步版本的","同样，requestab","同步拷贝从foo.txt到bar.txt","名称","名称不在区域内","名称可以有一个前缀","名称或传入您已经创建好的","名称来记录网络活动。使用网络活动记录时，需要注意以下几点：","名称错误","后缀的请求方法，如","向","向buffer写入数据","向socket中写入数据","向其泵送数据，如","向客户端发送一帧","否则使用jdksslengineopt","否则失败","否则若log4j可见，再使用该库","否则退回使用java.util.log","启动会耗费一些时间，您想要在这个过程做一些事，并且您做的这些事并不想等到verticle部署完成过后再发生。如：您想在","启动器","启动器和退出代码","启动器子类","启动应用程序。使用此设置，vert.x","启动时注册。","启动服务端监听","启用时，vert.x","周期性、延迟性动作","周期性计时器","命令。","命令。但是，您可以通过设置","命令的参数最终会传递给应用程序，可使用","命令行","命令行实用程序调用。它可执行一组命令，如run、bar","命令行工具中使用。另外，它支持多语言（可用于任何支持的语言），并可在vert.x","命令行工具和更普遍的","命令行工具用于在终端中与","命令行接口api","命令运行verticle了，这儿是一些例子：","命令）：14","和","和其他一些语言不同，java","和客户端使用的方式一致，这种操作随着压缩级别的增长会变得更加倾向于cpu密集型。","和当前线程关联，那么它直接重用这个","和服务器上的","和服务器配置相同，也可通过以下几种方式配置受信客户端：","和许多其他文件操作。我们不会在这里列出所有内容，请参考","和选项不同，参数不具有","和集群端口","响应","响应、异步文件","响应。若底层操作系统支持，这会导致操作系统不通过用户空间复制而直接将文件内容中字节数据从文件传输到socket。这是使用","响应中。","响应中，或者写入任意","响应中，通常直接操作","响应体以块的形式写入，通常在响应体预先不知道尺寸、需要将很大响应正文以流式传输到客户端时使用。","响应写入数据","响应写入是异步的，并且在写操作进入队列之后会立即返回。","响应包含响应体（正文），它可能会在响应头被读取后的某个时间以分片的方式到达。在调用响应处理器之前，我们不要等待所有的响应体到达，因为它可能非常大而要等待很长时间、又或者会花费大量内存。","响应发送回来时调用该处理器来处理响应结果。","响应可包含头信息。您可以使用","响应和附加尾部","响应处理器","响应头中单个键可以关联多个值。","响应头可直接添加到","响应头和尾","响应头必须在写入响应正文消息之前进行设置。","响应头提供的重定向，并且响应处理器将传递重定向响应以替代原始响应。","响应完成处理器","响应模式","响应还可以包含响应尾(trailer)","响应附加尾部(trailers)写入响应，这种方式实际上是在写入响应的最后一块。","响应，则可使用","响应，可调用","响应：","唯一的保证是，它既不会被完全接收到，也不会完全不被接收到，即只有部分会被接收到。","唯一的区别是您可以将多播组的地址传递给","因为","因为http允许同一个键支持多个请求头的值。","因为netsocket既实现了readstream也实现了writestream","因为vert.x","因为协议不会将消息发送回客户端。","因为每一个数据包将会作为一个包发送，所以在通常情况下您不能发送大于网络接口的最大传输单元（mtu）的数据包。","因此，vert.x","因此，服务器可直接扩展可用的核，而每个","因此，要监听指定的地址和端口、并且接收多播组230.0.0.1的数据报，您将执行如下操作：","在","在cli定义中使用typedoption和typedargument，而不是option和argument。","在equinox上，您可能需要使用下边的框架属性禁用contextfilter：eclipse.bundle.settccl=false。","在vert.x中使用用户数据报协议（udp）就是小菜一碟。","在一个完美的世界中，不存在战争和饥饿，所有的api都将使用异步方式编写，兔兔和小羊羔将会在阳光明媚的绿色草地上手牵手地跳舞。","在一个标准的反应器实现中，有","在上述所有情况下，当您的线程在等待处理结果时它不能做任何事，此时这些线程并无实际用处。这意味着如果您使用阻塞式api处理大量并发，您需要大量线程来防止应用程序逐步停止运转。所需的内存（例如它们的栈）和上下文切换都是线程的开销。这意味着，阻塞式的方式对于现代应用程序所需要的并发级别来说是难于扩展的。","在不需要的时候必须被关闭：","在以前的版本中，只能通过操作指定的","在保存时会增量编译您的文件，重部署工作会顺利进行。","在出现错误的情况下，通知中将包含一个dnsexception，该异常会包含一个说明为何失败的dnsresponsecode。此dnsresponsecode可用于更详细检查原因。","在分块模式下，您还可以将响应的http","在分块模式下，每次调用","在单次调用中写buffer并结束请求（直接发送）","在同一个上下文环境中（如：同一个","在同一台计算机上运行两个javascript","在启动","在多数情况下，vert.x使用被称为","在容器中使用时，您也可以配置公共主机和端口号：","在应答的消息体中可以包含有用的信息。","在开发时，可以方便在文件更改时实时重新部署应用程序。vertx","在循环语句中长时间逗留","在撤销时","在文件已满时会暂停，但是当写队列处理完成时，我们需要取消暂停：","在最简单的情况下，如果","在服务端启用ssl/tl","在服务端处理","在服务端，vert.x","在某些情况下（例：若请求体很小），您将需要将这个请求体聚合到内存中，以便您可以按照下边的方式进行聚合：","在第一个终端运行：","在第一个终端：","在第三个控制台，您可以启动另一个vert.x的实例：","在第二个终端中，让我们使用相同组运行另一个verticle：","在第二个终端：","在编写vert.x","在被阻塞时就不能做任何事情。如果您阻塞了","在请求/响应期间随时支持流重置：","在请求中指定的","在运行单元/集成测试或是运行开发版的应用程序时都经常需要自签名证书。","在这一点上，您可能会问自己：如何让多台服务器在同一主机和端口上侦听？尝试部署一个以上的实例时真的不会遇到端口冲突吗？","在这里处理传入连接","在这里处理请求","在这里，我们的目标实现了。当写队列准备好接收更多的数据时，drainhandler事件处理器将被调用，它会恢复netsocket的状态，允许读取更多的数据。","在部署的时候都会被分配一个","在配置项中告诉服务器监听指定的主机和端口：","在集群模式下的event","地址(address)。","地址。","块被写出。","域名不应该存在","基本概念","声明。默认情况下，选项会接受一个值，但是您可以使用","处理","处理index.html响应","处理中","处理压缩体","处理器","处理器只是接到通知，确认被发送，这个功能旨在基于","处理器的地址由","处理完成之后，请使用","处理异常","处理数据报","处理文件上传","处理网络分区","处理请求","处理逻辑","多个event","多播","多播允许多个socket接收相同的数据包，该目标可以通过加入到同一个可发送数据包的多播组来实现。","多路复用","大多数vert.x","大小为q","大部分verticl","大部分都是事件驱动的。这意味着当您感兴趣的事情发生时，它会以事件的形式发送给您。","失败。","失败的","头","头。因此，若您不使用","头。当","头时自动发回","头，其值为可支持的压缩算法，（该值可）支持多种压缩算法。这种情况","头，否则会太迟。若您使用","头，因此您不必先计算大小。","如slf4j可见，则优先使用该库","如上所述，用户数据报协议（udp）将数据分组发送给远程对等体，但是以不持续的方式来传送到它们。","如下所示：","如之前讨论，您不能在","如何定位verticl","如前边部分所述，dnsclient","如您坚持使用标准的vert.x","如果","如果上述任何一种情况停止了","如果不指定前缀，vert.x将根据提供名字后缀来查找对应factory，如：","如果不设置参数索引，则基于声明顺序会自动计算。","如果任何一步失败，将startfuture标记成fail","如果可以立即提供结果，它将立即返回，否则您需要提供一个处理器（handler）来接收稍后回调的事件。","如果您不希望vert.x使用jul记录日志，您可以为其配置另一个日志记录框架，例如log4j或slf4j。","如果您不想使用","如果您不想使用默认值，则可以在创建实例时传入","如果您使用","如果您使用的是","如果您只有单个","如果您喜欢的话，可以直接实现该接口，但是通常直接从抽象类","如果您在","如果您在使用","如果您想创建一个集群模式的","如果您想要在部署完成时被通知则可以指定一个完成处理器：","如果您是在","如果您用嵌入方式使用vert.x，可通过以下代码创建实例：","如果您的应用程序没有响应，可能这是一个迹象，表明您在某个地方阻塞了event","如果您通过嵌入式的方式使用","如果想关闭这些警告或更改设置，您可以在创建","如果服务器需要客户端认证，那么当连接时，客户端必须向服务器提供自己的证书。可通过以下几种方式配置客户端：","如果终端1中的实例被杀掉，则它将故障转移到终端2中的实例，而不是具有不同组的终端3中的实例。","如果编写web","如果缺省的配置不适合您，可在创建","如果请求包含请求体，那么该请求体将在请求处理器被调用后的某个时间到达服务器。","如果运行了mi","如果这三个步骤全部成功，则最终的","如果这样做，该","如果选项值被限制为一个固定集合，您可以设置不同的可接受选项：","如果通过","如果部署成功，这个完成处理器的结果中将会包含部署id的字符串。这个部署","妙极！——","始终会使用","始终根据需要进行自动扩容。","子类可以：","它不会阻塞，但当锁可用时，将","它也可使用","它也支持buffer的配置：","它们可以在响应结束之前被多次调用，它们可以通过以下几种方式调用：","它们永远运行在","它们还允许您直接读写。","它只是一个标准的java密钥存储，与服务器端的密钥存储相同。通过在jsk","它失败的尺寸取决于操作系统等（其他原因），所以按照经验法则就是尝试发送小数据包。","它将输入缓冲区序列转换为已配置的缓冲区序列（固定大小或带分隔符的记录）。","它的增益不是线性的，并取决于要压缩的特定数据","它的键值不区分大小写，这意味着您可以执行以下操作：","它还可以打印帮助信息——详细说明命令行工具可用的选项。即使这些功能远离vert.x","安全注意事项","安全说明。","完全限定类名，也可以指定java","完成","完成时被调用。","完成时，执行相关代码，并完成下一个","完成时，执行相关代码，并返回","完成时，组合完成。","完成，无论成败。compositefuture.join","定义命令行接口","定义阶段","定时器。定时器可以是一次性或周期性的，两者我们都会讨论到。","实例","实例。","实例。它像一个普通的map或hash，并且它还允许同一个键支持多个值","实例。您可以通过","实例。此实例在启动时未部署任何verticle，但它若接收到若集群中的另一个节点死亡，则会在此节点运行之前挂掉的实例。如需要创建一个","实例。这个vert.x","实例。这是一个代表了实际连接的套接字接口，它允许您读取和写入数据、以及执行各种其他操作，如关闭","实例不会绑定到特定端口，如果您只想发送数据（如作为客户端）的话，这是没问题的，但更多详细的内容在下一节。","实例中","实例中。","实例中。我们称这个为","实例中。详细说明请参阅","实例中。通过您在网络上将不同的","实例中同时运行的许多","实例中向指定的","实例中或在不同的","实例中的","实例中的不同","实例中的不同应用程序之间或集群中的不同","实例中的所有","实例中设置异常处理器来处理请求时发生的异常：","实例中重新部署。","实例之间安全地共享数据。","实例也是readstream和writestream","实例也是一个","实例仍然严格使用单线程，您不需要像编写负载均衡器那样使用任何特殊技巧去编写，以便在多核机器上扩展服务器。","实例可使用任意","实例可访问对应的","实例失败或挂掉，则此verticle将自动重新部署到集群中的另一个vert.x","实例实现了","实例将数据泵入请求中。","实例将自动重新部署mi","实例并没有部署好（状态不是","实例并调用请求处理函数，此对象表示服务端","实例必须在同一个集群中。","实例数","实例时也可配置dn","实例时，您可以指示它在部署任何ha部署之前需要一个quorum。该上下文环境中，一个","实例有一个文件系统对象，您可以使用","实例来创建一个。","实例来说它是单例的。","实例来配置服务器：","实例正在运行两个verticle。","实例现在死了（您可以通过执行kill","实例的","实例的数量。","实例组合而成。不同的","实例组成一个集群需要一些时间（也许是几秒钟）。在这段时间内，我们不想去阻塞调用线程，所以我们将结果异步返回给您。","实例给它：","实例绝对不会在","实例维护了n（默认情况下n","实例维护了多个","实例维护的是","实例维护的线程不是守护线程，因此它们会阻止jvm退出。","实例能够让您读取在websocket","实例通过向","实例都有一个单独的","实例配置好后，您可以解析用户命令行来解析每个选项和参数：","实例配置成集群模式来获取集群模式的event","实例销毁的同时","实例集群在一起，它可以形成一个单一的、分布式的event","实例（vertx），则可以通过将","实例）被调用了多次，那么这些不同的","实例，使用任意一个","实例，例如：","实例，则最好始终从该verticle的ev","实例，因为","实例，因为可以有多个具有相同名称的参数。","实例，因此您可以从任何","实例，在其中去处理它。","实例，它可以从","实例，它可以用来写数据到请求体和请求头。","实例，您可以通过","实例，所以假设您已经有另一个已经启动的vert.x","实例，执行以下命令：","实例，无论您是要仅仅发送数据或者收发数据，这都是一样的。","实例，这些选项描述了访问文件的行为。例如：您可使用","实例，这意味着您可以泵送数据到任何","实例：","实时重部署","实现了","实现了完整的","实现了这种模式。","实现的并发组合不同，compos","实用程序来管理java密钥存储。","实际写入操作是异步的，它可能在调用返回一段时间后才发生。","实际的绑定也是异步的，因此服务器也许并没有在调用","实际的绑定也是异步的，因此服务器在调用了","客户端","客户端也可以轻松地配置为ssl。使用ssl和使用标准套接字具有完全相同的api。","客户端也可配置为信任所有证书：","客户端会发送","客户端受信配置","客户端可配置成遵循http","客户端向同一个主机/端口发送很多请求。为避免每次发送请求时重复设主机/端口，您可以为客户端配置默认主机/端口：","客户端启用ssl/tl","客户端启用压缩","客户端和服务端","客户端和服务端。","客户端和服务端可以通过配置来使用","客户端和服务端都支持","客户端推送","客户端支持开箱即用的","客户端支持连接池，它允许您重用请求之间的连接。","客户端支持通过http","客户端是很灵活的，您可以通过各种方式发出请求。","客户端的功能，需要先在本地解析","客户端的最简单方法如下：","客户端请求中指定处理器","客户端还支持连接上的请求管道(pipeline)。","客户端连接","客户端连接使用代理","客户端针对每个服务器都使用单一连接，同样服务器上的所有流都会复用到对应连接中。","客户端（通常是浏览器）之间实现全双工","密码套件可在netserveroptions或netclientoptions配置项中指定。","密码套件，该密码套件可以配置一套启用的密码：","密钥存储。使用jk","密钥库的位置，它只是一个常规的java","对","对tcp连接进行全面的配置。由于","对于","对于使用","对于客户端：","对于布尔值，布尔值将被评定为true:on，yes，1，true。","对于每一个","对于确定连接往返时间或检查连接有效性很有用：ping","对于第二个例子，处理器需要完成","对于这点，vert.x","对包进行处理","对应一个","对应发送或发布的对象。消息的头信息可以通过","对应的","对数据包进行处理","对此并不关心。","对用单个缓冲区：","对等连接重置","对象","对象。","对象。该对象随后可用于撤销处理器、或将处理器用作流式处理。","对象上注册一个","对象为参数调用处理器。","对象之前在","对象也支持","对象作为参数（最多6个，或者传入","对象可以从被不同的线程安全地访问，但在相同的上下文中访问它们时，性能才是最优的。","对象可以被序列化/反序列化为嵌套的json对象。","对象和","对象基本上只是一个","对象并填充字段值。如下所示：","对象或使用","对象打开并其传送到http","对象提供了存储和读取共享数据的方法。举例来说，它允许您将数据传递到","对象提供了许多操作文件系统的方法。","对象时指定配置项","对象来实例化一个java","对象来实现文件读写。从现在开始，流不再与","对象来执行。通常来说这个","对象的同时指定配置项：","对象的字段创建一个json","对象的引用。","对象直接设置处理器来接收到","对象编码成字符串","对象获取值","对象配置来配置代理（包括代理类型、主机名、端口和可选用户名和密码）。","对象间的映射","对象（jsonobject）的形式返回，因此您可以用下边代码读取数据：","对象（参考","对象，否则在vert.x领域中您做不了太多的事情。它是","对象，如下所示：","对象，如果没有则创建一个新的。您可以检查获取的","对象，您可直接使用该内置对象，无需重新创建。","对象，您就可以在","对集群中","寻址","将","将buffer写入到一个socket或其他类似位置后，buffer就不可被重用了。","将http","将一个","将为每一个","将为每一个发送的","将会匹配所有","将会发生什么？如果两个","将会成功完成。","将会自动关闭这个","将使用","将使用groovy的factori","将使用javascript的factori","将保证用与调用该方法时相同的","将其发回客户端。","将创建一个新连接，否则直接将请求添加到队列中。","将发出通知。","将向","将在运行它之前对","将数据刷新到底层存储","将数据放入map","将数组项添加到json数组","将添加以下头：","将自动关闭非","将自动发送确认，可设置处理器当收到","将自动计算并设置","将被调用：","将覆盖默认客户端设置：","将请求顺序委托给其中一个服务器：","将键值对放入","将集群管理器配置成加密的或强制安全的。参考集群管理器的文档获取更多细节。","小而轻，您可以只使用您需要的部分。它可整体嵌入现存应用中。我们并不会强迫您用特定的方式构造您的应用。","尝试对ipaddress进行反向查找，这与解析ptr记录类似，但是允许您只传递ipaddress，而不是有效的ptr查询字符串。","尝试查找给定名称的","尝试查找给定名称的a（ipv4）记录。第一个返回的（记录）将会被使用，因此它的操作方式与操作系统上使用nslookup类似。","尝试解析给定名称的ptr记录，ptr记录将ipaddress映射到名称。","尝试解析给定名称的所有aaaa（ipv6）记录，这与在unix操作系统上使用dig类似。","尝试解析给定名称的所有a（ipv4）记录，这与在unix操作系统上使用dig类似。","尝试解析给定名称的所有cname记录，这与在unix操作系统上使用dig类似。","尝试解析给定名称的所有mx记录，mx记录用于定义哪个邮件服务器接受给定域的电子邮件。","尝试解析给定名称的所有ns记录，ns记录指定哪个dns服务器托管给定域的dns信息。","尝试解析给定名称的所有srv记录，srv记录用于定义服务端口和主机名等额外信息。一些协议需要这个额外信息。","尝试解析给定名称的所有txt记录，txt记录通常用于定义域的额外信息。","就会被调用。","就变成已停止状态了。","就变成已启动状态。","就是失败的。","就能跑起来！","尽力传输","尽力传输(best","尽管我们已经知道，vert.x","屏蔽多播","属性","工作，如","带请求体的非分块","带超时的发送","帧","帧。","帧不受流量控制限制","帧之前完成。","帧到远程的连接，要求其停止创建流：客户端将停止发送新请求，并且服务器将停止推送响应。发送","帧到远端：","帧后，连接将等待一段时间（默认为30秒），直到所有当前流关闭和连接关闭。","帧将会在连接关闭之前被发送","帧时发送通知调用处理器：","帧时，vert.x","帧，和关闭主要的区别在于它将只是告诉远程连接停止创建新流，而没有计划关闭连接：","并且完成了操作，您可以调用","并且添加一行表示工厂类的完全限定名称：","并占用了","并发合并","并在类路径上使用","并指定它的大小。这使得这个","并支持常用的","并由其索引标识。例如，在java","应用","应用中处理","应用中安全调用\"传统\"阻塞api的方法。","应用中记录日志","应用层协议协商","应用的时候需要添加","应用程序时，这样做是很常见的，因此我们提供了一个名为pump的帮助类，它为您完成所有这些艰苦的工作。您只需要给","应用程序，强烈建议您直接使用vert.x","应用）扩展到多核服务器上，则需要启动并且管理多个不同的进程。","应用：","应答消息/发送回复","应该使用自己的客户端实例。","开发人员遵循","开启服务端监听","开头。","开始","开始的h2c直接连接。","异常。幸运的是，vert.x","异常处理","异步协调","异步启动和停止","异步地","异步文件访问","异步版本","引擎实现可以配置为使用","引擎选项可使用:","引擎选项可使用：","强制使用log4j日志记录","当","当getsslengineoptions被设置时，使用该选项","当vert.x启用ha运行时，若一个运行了verticle的vert.x","当vert.x找不到文件系统上的文件时，它尝试从类路径中解析该文件。请注意，类路径的资源路径不以","当一个消息达到您的处理器，该处理器会以","当从报文中读取到响应头时，响应处理器就会被调用。如果收到的http","当使用","当使用vert.x的高可用功能时，您可能需要创建一个vert.x的","当使用vert.x运行实例时，还可以选择指定的ha组。ha组表示集群中的逻辑节点组。只有具有相同ha组的节点能执行故障转移。若不指定ha组，则使用默认组__default__。","当使用传统的阻塞式api做以下操作时，调用线程可能会被阻塞：","当使用同一个名字创建了许多","当使用名称部署verticle时，会通过名称来选择一个用于实例化","当使用名称部署一个","当使用搜索域列表时，点数的阈值为1，或从linux上的/etc/resolv.conf加载，也可使用","当使用隔离组时，您需要用","当关闭操作完成后，绑定的处理器将被调用：","当创建datagramsocket时，您可以通过datagramsocketoptions对象来设置多个属性以更改它的功能。这些（属性）列在这儿：","当发送带有应答处理器的消息时，可以在","当启用http","当启用管道时，请求可以不等待以前的响应返回而写入到连接。","当启用连接池创建请求时，若存在少于已经为服务器创建的最大连接数，vert.x","当启用高可用方式时，不需要追加","当响应体的某部分（数据）到达时，handler","当响应结束时，vert.x","当在同一个","当在网络上的不同vert.x","当多个","当客户端收到100响应代码则可以发送剩余请求体","当客户端连接到","当客户端连接到http","当客户端需要使用连接池并使用超过一个连接时，则可使用sethttp2maxpools","当对服务端创建","当尝试为一个指定名称元素获取a（ipv4）或","当帧到达时，会传入一个websocketframe实例给帧处理器，并调用它，例如：","当建立连接时，客户端和服务器交换初始配置，初始设置由客户端上的","当您使用","当您写入请求时，第一次调用","当您在与现有服务器相同的主机和端口上部署另一个服务器实例时，实际上它并不会尝试创建在同一主机/端口上侦听的新服务器实例。","当您希望限制每个连接的多路复用流数量而使用连接池而不是单个连接时，可使用","当您想要在任何时间只在集群一个节点上执行某些操作或访问资源时，这很有用。","当您用完锁后，您可以调用","当您编辑资源（如html、css或javascript）时，这种缓存机制可能令人讨厌，因为它仅仅提供文件的第一个版本（因此，若您想重新加载页面，则不会看到您的编辑改变）。要避免此行为，请使用","当您获取了这个","当您需要监听一个特定地址和端口时，您可以像下边这样：","当所有当前流已经关闭并且可关闭连接时，shutdownhandl","当接收到","当接收到自定义帧时，不论请求是否暂停，自定义帧处理器都将立即被调用。","当接收者收到消息并且已经被处理时，它可以选择性决定回复该消息，若选择回复则绑定的应答处理器将会被调用。当发送者收到回复消息时，它也可以回复，这个过程可以不断重复。通过这种方式可以允许在两个不同的","当整个响应体被完全读取或者无响应体的响应头被完全读取时，响应的","当整个请求（包括任何正文）已经被完全读取时，请求中的","当服务器准备推送响应时，推送响应处理器会被调用，并会发送响应。","当服务器处理请求时，它可以向客户端推送请求/响应：","当服务器接受","当服务器每次接收到上传请求时，该处理器将被调用一次。","当服务器没有及时回应时，尝试从列表中选择下一个解析器，搜索（数量）的限制由setmaxqueries设置（默认值是4个查询）","当泵首次创建时，它不会启动，您需要调用","当请求到达时，vert.x","当返回的是","当这种情况发生时，vert.x会检测到并记录下边警告：","当这种情况发生时，它会将消息回复给发送者并且在发送者中调用应答处理器来处理回复的消息。","当连接建立时，处理器将被调用并且传入","当连接成功时，您可以在回调函数中处理得到的","当需要提供文件的一部分，从给定的字节开始，您可以像下边这样做：","待撤销证书颁发机构","很像，但它并不是由一个","很多时候我们需要在集群范围内维护一个原子计数器。","很类似。","必须","必须为服务器或客户端配置ssl/tls才能正常工作。请参阅ssl/tls章节来获取详细信息。","必须通过","您不能在您的","您之前也许听说过它，例如","您也可以不设置处理器而使用","您也可以以编程的方式在嵌入vert.x","您也可以使用","您也可以启动裸的vert.x","您也可以和调用write方法一样传","您也可以通过直接发送故障状态代码来拒绝该请求：这种情况下，请求体应该被忽略或连接应该被关闭（100","您也许注意到前边的例子里使用了一个流式（fluent）的api。","您亦可在其它vert.x支持的语言中使用vert.x","您会在读取任何正文","您可以为锁设置一个超时，若在超时时间期间无法获取锁，将会进入失败状态，处理器会去处理对应的异常：","您可以从","您可以从json格式的字符串创建一个json数组：","您可以从通过一个map创建json对象：","您可以传入一个","您可以使用","您可以使用isvalid来检查commandline是否有效。","您可以使用下边命令创建一个bare实例：","您可以使用响应对象回写一个响应到","您可以像下边代码打开一个","您可以创建自己的主类并在","您可以在","您可以在socket上调用","您可以在请求方法中指定处理器或通过","您可以实现","您可以将","您可以将系统属性vertx.disablefilecaching设置为true，禁用此（文件）缓存行为。文件缓存的路径默认为.vertx，它可以通过设置系统属性vertx.cachedirbase进行自定义。","您可以指定一个","您可以用","您可以用其他语言的前缀来指定verticle的名称进行部署。例如：若verticle是一个编译的groovi","您可以直接使用","您可以直接通过","您可以看到，您可以使用cli.create创建一个新的cli。传递的字符串是cli的名称。创建后，您可以设置摘要和描述，摘要的目的是简短（一行），而描述可以包含更多细节。每个选项和参数也使用addargument和addoption方法添加到cli对象上。","您可以设置一个","您可以调用","您可以调用reject","您可以调用其中任意一个","您可以通过","您可以通过一个","您可以通过下面的代码获取","您可以通过以下命令以集群模式运行","您可以通过在","您可以通过如下方式开启分块模式：","您可以通过实现自己的","您可以通过调用close方法来关闭socket，它将关闭socket并释放所有资源。","您可以配置","您可使用","您可调用","您可通过以下方式创建一个具有默认配置的","您同样可以使用","您同样可以使用编程的方式去注册或注销verticl","您同样可以指定","您同样可以重写","您在此不会找到诸如数据库访问、授权或高层web应用的功能。您可以在vert.x","您在消息处理器中接收到的对象的类型是","您应该阅读","您必须在响应结束之前调用","您提供处理器给vert.x","您甚至可以不必编译","您的一个选项可以被标记为“帮助”。如果用户命令行启用“帮助”选项，验证将不会失败，但是可以让您有机会检查用户是否需要帮助：","您的应用中的不同部分通过","您要等多久？它取决于您的应用程序和所需的并发数量。","您还可以从异步map中删除条目、清除map、读取它的大小。","您还可以使用一下方式列出后台启动的vert.x应用程序：","您还可以使用下边方式设置系统属性：","您还可以使用注解定义cli。在类和","您还可以使用泵将文件内容写入到http","您还可以创建","您还可以在后台启动应用程序：","您还可以在重新部署周期中挂接（hook）构建过程：","您还可以指定一个索引值，通过","您还可以提供您将传递给","您还可以通过","您还可以通过系统属性vertx.disablefilecpresolving设置为true来禁用整个类路径解析功能。","您还可用","您还需要实现一个","您需要确在您的","您需要设置","想成","想要将数据写入","想象成字节数组（译者注：类似于","成功得到结果，则该","成功执行完成，得到的","成功执行（或任一失败），ani","成功放入值","成功的","成功读取值","成功，它只意味着它可能已经写入了网络堆栈，但不保证它已经到达或者将到达远端。","成功；当所有的","我们不会将所有的内容重写成异步方式，所以我们为您提供一种在","我们不需要重定向","我们前边提过","我们可以通过","我们将在下一节中介绍如何加入多播组，从而接收数据包。","我们将这种模式称为","我们已经快达到我们的目标，但还没有完全实现。现在","我们有三个节点，这是","我们来看一个例子：","我们来看看相关代码：","我们现在想象一个客户端，如下：","我们用","我们称之为","我们还可以生成固定尺寸的块，如下：","或","或worker","或一个其他通用请求方法，如","或事情更简单","或从输入流读取文件是阻塞的。所以为了避免每次都付出代价，vert.x","或使用fluent的api","或可以在调用","或在调用","或您可以使用","或您可使用","或者","或者使用编程方式部署您的","或者当响应已被完全读取时，您可以使用","或者您发现自己使用相同的客户端向不同主机的主机/端口发送大量请求，则可以在发出请求时简单指定主机/端口：","或者您可以自己读取受信存储到buffer，并将它直接提供：","或者调用","或者，vert.x","或者，您可以使用setidletimeout设置空闲时间——这个时间内没有使用的任何连接将被关闭，注意，空闲时间以秒为单位，不是毫秒。","或者，您可以自己读取密钥库到一个buffer，并将它直接提供给","或者，您可使用setidletimeout设置空闲时间——在设置的时间内然后没使用的连接将被关闭。请注意空闲超时值以秒为单位而不是毫秒。","所以不要这样做！这是一个警告!","所以您要怎么做？","所以，什么是","所以，您发送和接收的数据包都要包含有远程的地址。","所有","所有已经加入多播组","所有服务器启动完成","所有流被关闭，连接也关闭","所有的代码都是在相同event","所有的都失败","所有被合并的","所有这些错误都由dns服务器本身“生成”，您可以从","所有都成功","所监听的地址和端口的","所监听的地址和端口的数据报，同时也可以接收被发送到该多播组的数据报。","打开","打开选项","执行一个复杂的计算，占用了可感知的时长","执行一个长时间数据库操作并等待其结果","执行其他有用的任务。那您该怎么做？","执行周期性/延迟性操作","执行失败时，得到的","执行失败，则返回一个","执行打包成","执行这种请求最简单的方式是使用加了","扩展","拒绝","拷贝buffer","拷贝完成","拷贝文件","指定一个计时器id并调用","指定客户端的密钥/证书","指定服务器信任","指定服务端的密钥/证书","指定端口和主机名","指定集群管理器。","接下来讨论","接口。","接口。您可以使用泵将数据与其他读取和写入流进行数据泵送。例如，这会将内容复制到另外一个asyncfile：","接口。请注意，这些操作适用于任何实现了readstream和","接口提供了处理http","接口的","接口的java","接口的实现类包括：httpclientresponse,","接口的对象，包括http","接口继承了","接口，因此您可以将它套用（pump）到其他的读写流上。","接口，因此您可以将文件和其他流对象配合","接口，因此您可以将请求体读取到任何","接口，我们可以在写入之前检查","接口，相应的，任何可控制的读取流对象都实现了","接口，这意味着您可以从任何","接收传入连接的通知","接收到数据时，会以","接收多播数据包","接收数据报包","接收者调用了","接收者：","接收自定义","控制台中显示","推送main.js到客户端","推送响应处理器客户能会接收到失败，如：客户端可能取消推送，因为它已经在缓存中包含了","描述option和argument类是无类型的，这意味着仅读取string值。","提供一个处理器。例如：","提供了一种方法，允许您在一个操作中将文件从磁盘或文件系统中读取并提供给http","提供了下列功能:","提倡使用服务器的单一连接，默认情况下，http","提醒：不要在生产设置中使用，这里生成的密钥非常不安全。","握手中的http","搜索域名","搭配其它工具包，使得编写不安全的应用程序成为可能，因此在开发时需谨慎，尤其是当您将其对公众发布的时候（如在互联网上发布）。","撤销verticl","撤销一个","撤销操作也是异步的，因此若您想要在撤销完成过后收到通知则可以指定另一个完成处理器：","撤销时自动被关闭。","操作系统的hosts文件","操作系统的hosts文件用于对ipaddress执行主机名查找。","支持","支持http/1.x","支持基于","支持的一个新功能，可以为单个客户端请求并行发送多个响应。","支持的所有语言都是非常容易创建、读取和解析的，因此它已经成为了vert.x中的通用语(lingua","支持的类型（如","支持的编程语言编写，而且一个简单的应用程序也可以包含多种语言编写的","收到了一些数据","收到传入请求的通知","放在它的","故事从","故障排除","故障转移","故障转移仍然适用，并将使用列表中的下一个服务器。","故障转移（failover）。","数据块，分块传输、分块模式中会用到）","数据对象来配置。","数据报套接字","数据报套接字（udp）","数组","数组中获取值","数组中获取值。例如：","数组同样可以包含","数组是一个值的序列（值的类型可以是","数组编码成字符串","文件。","文件列表。","文件系统支持诸如","文件系统访问","文件被移走（startfuture）","文件（这里是","文档","文档。","文档手册","方法","方法。","方法。当您在一个","方法。这种情况，它和先调用带","方法一样。例如：","方法一样它也会返回一个","方法一样：","方法一次性加载它，并直接将其写入响应。","方法上使用注解来定义：","方法中手工去撤销启动时部署的子","方法中设置一个处理器。","方法中读取。","方法中部署其他的","方法中阻塞等待其他的","方法为每个服务器配置连接池的最大连接数。","方法之后再调用无参","方法也会（在调用时）覆盖默认客户端设置。","方法也是异步的，一段时间过后它会通知处理器并传入结果。","方法从","方法从json","方法从json对象中获取值。例如：","方法从map读取数据。get","方法从响应中查询响应的状态码和状态消息：","方法从响应中获取","方法从文件系统中读取并提供文件：","方法以便读取整个响应体：","方法会被调用。","方法会返回一个","方法会返回客户端上的连接请求：","方法会返回服务器上的请求连接：","方法传递延迟时间和一个处理器来设置计时器的触发。","方法作用于顺序组合","方法关闭","方法关闭它。这将关闭所有内部线程池并关闭其他资源，允许jvm退出。","方法关闭底层的tcp","方法关闭服务端。关闭操作将关闭所有打开的连接并释放所有服务端资源。","方法关闭连接：","方法写入数据到","方法写入数据到socket：","方法写入请求，以下是一个例子：","方法创建","方法创建一个buffer的副本。","方法创建到服务器的连接。请指定服务器的端口和主机，以及用于处理","方法创建到远程主机的通道。","方法创建帧，并使用","方法发送出去。","方法发送消息时，event","方法可以将值放入到json对象里。","方法可用于非标准方法，在这种情况下，rawmethod","方法启用压缩，vert.x","方法和","方法和缓存的请求体执行重定向","方法在每次写入时启用/禁用内容的自动同步。这种情况下，您可以使用","方法均不接收异常处理器做为参数。","方法处理","方法完成的，对于大文件处理通常更有效，而这个方法对于小文件可能很慢。","方法将一个对象编码成字符串格式。","方法将先将请求头写入到请求报文中。","方法将其写入websocket。","方法将其直接写入响应中并发回到客户端。","方法将发送","方法将导致新的","方法将导致新的块被写入到报文，这种模式中，无需先设置请求头中的","方法将数据放入map。put方法是异步的，一旦完成它会通知处理器：","方法将文件和","方法将无符号数从","方法将版本设置成","方法将被调用，这个方法执行完成后","方法将额外的类路径添加到这里。","方法或","方法手动刷新os缓存中的数据写入。","方法执行重定向","方法指定一个地址去发布即可。","方法指定自定义状态消息。","方法接受多个","方法提供。","方法时指定主机和端口号，忽略配置项中的配置：","方法时指定主机和端口号，这样就忽略了配置项（中的主机和端口）：","方法时提供","方法时提供一个处理器。例如：","方法时，它会关联一个","方法显式声明失败","方法来串起一个带操作结果的或失败的","方法来做这个事。这个版本的方法会以一个","方法来关闭","方法来发送消息：","方法来发送该请求（结束请求）。","方法来取消一个周期性计时器。如：","方法来启动它。","方法来启用tls：","方法来应答这个消息。","方法来执行此操作。当所有请求体被收到时，bodyhandl","方法来执行该操作：","方法来拒绝一个","方法来指定阻塞式代码的执行以及阻塞式代码执行后处理结果的异步回调。","方法来提供一个您想隔离的类名列表。列表项可以是一个java","方法来撤销部署好的","方法来更改。","方法来注销处理器。","方法来获得对应的","方法来获得服务器实际监听的端口：","方法来设置。","方法来设置用于读取数据的处理器。","方法来设置需要发送到服务器的raw方法。","方法来设置：","方法来读取响应头。该方法返回的对象是","方法来读取实际的表单属性。","方法来部署verticle。","方法来释放它，以便另一个调用者可获得它。","方法检查响应实际http版本。","方法注册处理器：","方法注销某个消息编解码器。","方法添加/删除命令","方法添加数组项到json数组中：","方法的一段时间之后才会实际开始监听。若您希望在服务器实际监听时收到通知，您可以在调用","方法的合并会等待所有的","方法的合并会等待第一个成功执行的future。compositefuture.ani","方法的响应中的请求体，它为请求体使用了","方法的返回值也是一个唯一的计时器id，若之后该计时器需要取消则使用该id。传给处理器的参数也是这个唯一的计时器id。","方法的返回值就是","方法直接返回一个","方法相同。","方法绑定","方法绑定的回调函数将会被调用，其中传入的","方法编写头文件：","方法获取","方法获取asyncmap的实例。","方法获取buffer长度，buffer的长度值是buffer中包含的字节的最大索引","方法获取http","方法获取。","方法获取一个","方法获取一个实例：","方法获取它。","方法获取锁。","方法被关闭过后，对应的","方法裁剪一个buffer。","方法让客户端持续发送请求体：","方法设置。","方法设置一个周期性触发的计时器。第一次触发之前同样会有一段设置的延时时间。","方法设置一个处理器，每次请求体的一小块数据收到时，该处理器都会被调用。以下是一个例子：","方法设置不同状态代码。","方法设置成true。默认值为true。","方法设置配置项。默认情况下解压缩是被禁用的。","方法设置，此选项定义了发送到服务器的等待响应的最大请求数。这个限制可以确保和同一个服务器的连接分发到客户端的公平性。","方法访问","方法访问。","方法读取uri中的路径部分。","方法读取请求中的","方法读取请求中的uri路径。","方法读取请求发送者的地址。","方法调用返回后一段时间才会完成部署。","方法运行的某些操作中：","方法返回","方法返回http请求中的参数信息。像","方法返回客户端发送的实际","方法返回时监听，而是在一段时间过后才监听。","方法返回过后一段时间才会发生。","方法进行配置。","方法进行配置。默认情况下，未启用压缩。","方法追加数据到","方法都会将索引值作为第一个参数","方法配置。","方法配置文件访问权限。","方法配置特定值。","方法配置的。","方法配置该选项接收多个值：","方法配置默认的verticle和命令","方法隐藏选项，隐藏选项不在用法中列出，但仍可在用户命令行中使用（针对高级用户）。","方法）","方法，之后调用无参","方法，以下是一个例子：","方法，但是在推送响应过后依然可以写响应。","方法，如果您想做一些耗时的","方法，它将会通过用户空间进行复制，因为若内核将数据直接从磁盘复制到","方法，对于这种情况，我们提供通用请求方法","方法，当vert.x","方法，当任务执行完成时设置下一个计时器。","方法，然后在整个请求体都被读取后，您可以使用","方法，这儿有个例子：","方法：","无论是否使用ssl/tls，服务器和客户端的api都是相同的。通过创建客户端/服务器时使用的","无请求体的简单请求","日志的记录是由netty而不是vert.x的日志来执行","日志记录","时也适用。","时会被调用。","时使用","时它会被调用，这个方法执行完成后","时它都会被调用。","时收到通知：","时直接调用","时被调用,","时遇到","时，处理原始响应","时，它们将共享同一个","时，它会将数据写入到","时，它的","时，您可以传递一个","时，您可以指定您想要部署的","时，流量将通过未加密报文发送，因此若您有要发送的机密数据，而您的vert.x","时，请求失败时调用设置的异常处理器","时，请求将在它成功完成后发送","时：","时：建立连接后，客户端将发送","是","是一个包含了所有依赖项jar的可执行的jar，这意味着您不必在执行jar的机器上预先安装vert.x。它像任何可执行的java","是一个工具包，而不是来强迫您以某种方式做事情的框架。这赋予了开发人员以更强大的能力，同时也伴随着更大的责任（译者注：能力越大，责任越大，小蜘蛛他叔叔说的）。","是一个性能提示，并不是逻辑协议约束）：","是一个高级功能，大部分应用程序不会需要它。由于这些","是一种web技术，可以在","是分布式事务必须获得的最小票数才能被允许在分布式系统中执行操作的一个参数。","是可以读取或写入的0个或多个字节序列，并且根据需要可以自动扩容、将任意字节写入","是可以配置的，这对于以集群模式运行的","是可选的，并在消息中使用。","是否已满：","是否运行在集群模式下，以及它的主机信息和端口。您可使用","是失败状态的。","是并发的，您必须小心地使用标准的java多线程技术来保持","是成功状态的；当至少一个","是流式的吗？","是用于","是由","是由用户命令行中存在的","是相同的，特定的api功能也可用于处理","是集群中特定组的最小节点数。通常您选择","是非常有用的。event","显式使用jdk","显示vert.x的版本","显著执行时间，那您应该去罚站（译者注：原文此处为","显著执行时间？","更多关于quorum（多数派机制）的信息，请参考","更容易。","最后，在第三个终端中，使用不同组启动另一个verticle：","最后，您可以使用","最简单地使用所有默认配置项创建","最简单的注册处理器的方式是使用","有一个服务器启动失败","有一些依赖，若部署vert.x","有一段时间没有响应，将会自动记录这种警告。若您在日志中看到类似警告，那么您需要检查您的代码。比如：","有两种方法。","有些时候您的","有以下方法：","有关更多信息，请参阅","有关更多详细信息，请查看recordparser类。","有关详细信息，请参阅","有关详细信息，请参阅api文档。","有可能只需发送","有时候您想只在特定时间内接收多播组的数据包。","有时您在运行时不知道发送请求的","有时您想要发送一个包含了请求体的请求，或者也许您想要在发送请求之前写入头部到请求中。","有更多信息，请参阅","有类型选项和参数","服务器。","服务器准备推送响应","服务器列表轮询","服务器响应对象是一个","服务器将从其中（算法）选择一个，您可以通过服务器发回的响应中响应头","服务器拒绝查询","服务器推送","服务器推送(server","服务器收到了一个请求","服务器故障","服务器每次收到一个http请求时这个处理器将被调用","服务器没实现","服务器的默认端口为53，当服务器使用不同的端口时，可以使用冒号分隔符设置该端口：192.168.0.2:40000。","服务器，它使用","服务器，请注意，您想提供文件和类路径之外访问的位置","服务器：","服务端","服务端中的处理器总是在相同的","服务端共享","服务端可以使用证书颁发机构来验证客户端的身份。","服务端可以水平扩展到多个核，并且每个实例保持单线程环境不变。","服务端可以自由地使用自己支持的压缩算法之一进行压缩，也可以在不压缩的情况下将响应体发回。所以这仅仅是","服务端可能不支持","服务端和","服务端和客户端","服务端和客户端可以配置成和网络服务器完全相同的方式使用","服务端和客户端，则在撤销该verticle时，它们将自动关闭。","服务端和客户端，它们将会在verticl","服务端响应","服务端在同一个端口上监听时，vert.x","服务端时，它将向服务端发送其初始设置。设置定义服务器如何使用连接、客户端的默认初始设置是由","服务端的一个可能被随意忽略的提示。","服务端的方式如下：","服务端的最简单方法如下：","服务端连接","服务端通常向客户端提供证书，以便验证服务端的身份。","服务端，一种从磁盘中读取并提供文件的方法是将文件作为","服务端，如：","服务请求对象允许您检索","本地共享map","本地共享map仅允许将某些数据类型作为键值和值，这些类型必须是不可变的，或可以像buffer那样复制某些其他类型。在后一种情况中，键/值将被复制，然后再放到map中。","本地和远程地址","本地的map和分布式集群map","本身不提供这样的检查，所以这取决于开发者您自身如何实现了。","条目设置为您的main","来做到这一点。","来关闭客户端实例。","来创建","来启用/禁用，或在指定模式时调用","来启用tls/ssl。","来告诉客户端可以发送请求的剩余部分。","来实现。","来执行映射。关于字段和构造函数的可见性的影响、对象引用的序列化和反序列化的问题等等可参考","来执行这些处理器。","来执行阻塞式行为，例如","来执行，而是由vert.x中的","来指定。例如：","来指定了：","来指定：","来提交","来检测服务器是否适应这个正文。","来设置。如：","来设置请求头：","来说，会关联一个","来说，它会关闭底层的","来说，它将执行无延迟关闭，goaway","来读取由“run”或“bare”命令创建的vert.x实例","来运行阻塞式代码，您还可以在一个event","来部署","来部署它。","来配置代理类型、主机名、端口、可选的用户名和密码。","来配置：","构建包含命令的jar。确保包含了spi文件（meta","查看帮助。","查询/审问","查询/审问阶段","查询部分应该是：","标准安全最佳实践","标准的java","标记在关闭时或jvm停止时要删除的文件。","标识的命令行参数。选项至少必须有一个长名或一个短名。长名称通常使用","样式模式（使用","根据","根据您的集群配置，可能需要自定义集群管理器配置（默认为hazelcast）和/或添加集群主机","根据您的集群配置，您可能需要添加cluster","格式。","格式来发送消息。","格式的字符串创建json对象：","格式的配置","格式编码：","格式错误","检测到","检测存在以及删除","概念使用标准单词","模式","模式。","模式和","模式的实现。","模式的实现，但它确实有相似之处，特别是在并发、扩展性和部署等方面。","模式（反应器模式）。","模式（多反应器模式），区别于单线程的","模式（译者注：reactor","欲了解有关在命令行执行","正如您在java中可看到的，该verticle的名称要么是java","此外，您可以实现自己的转换器（converter）并指定cli使用此转换器：","此时，vert.x实例将启动但不部署模块（尚未）因为目前集群中只有1个节点，而不是3个。","此时，vert.x实例将启动但不部署模块（尚未）因为目前集群中只有2个节点，而不是3个。","每一个","每一个服务请求对象和一个服务响应对象绑定，您可以用","每个","每个vert.x","每个命令行界面必须定义将要使用的选项和参数集合。它也需要一个名字。cli","每个操作都提供了阻塞和非阻塞版本，其中非阻塞版本接受一个处理器","每个连接最多可用三个连接，每个连接可连接10个流","每次","水平扩展","没什么特别的，您可以使用任何java应用程序。","没有共享访问可变状态，因此您不必担心需要通过同步访问来保护该状态。","没有参数，直接结束响应，发回客户端：","没有可用的处理器来接收消息","没有对","没有找到给定查询的记录","没有放之四海而皆准的策略，缺省的重定向策略可能不能满足您的需要。默认重定向策略可使用自定义实现更改：","注册在该地址上的处理器。这和","注册处理器","注意要添加对应的集群管理器依赖，详情见集群管理器章节","注意，即使","注意：分块响应在","注意：压缩可以减少网络流量，单是cpu密集度会更高。","注意：对于","注意：目前如果连接失效，vert.x将不尝试重新连接。重新连接尝试和时间间隔仅适用于创建初始连接。","注意：若在","注意：请参阅官方","注解后，您可以使用以下命令来定义cli并注入值：","注销处理器","泵","泵（pump）的实例有以下几种方法：","流","流中无效。","流和管道","流和管道（泵）","流式","流式的socket","流重置","流量","消息中的最后一帧标记成","消息会被","消息写入","消息发送可能会因为其他原因失败，包括：","消息可以由多个帧组成，在这种情况下，第一帧是二进制或文本帧（text","消息在处理器（handler）中被接收。您可以在某个地址上注册一个处理器来接收消息。","消息大于使用setmaxwebsocketframes","消息对象","消息将被发布到一个地址中，发布意味着会将信息传递给","消息将被发送到一个地址中，vert.x将会把消息分发到某个注册在该地址上的处理器。若这个地址上有不止一个注册过的处理器，它将使用","消息的","消息类型","消息编解码器","消息编解码器的编码和解码不一定使用同一个类型。例如您可以编写一个编解码器来发送","消息顺序","消息，因此我们提供了","消费者可以通过调用","清理工作，您可以使用它。","源代码文件执行运行时编译，这对于快速原型制作和演示很有用。不需要设置","源代码，直接运行它：","源文件，vert.x会为你编译它。","激活该行为。","点对点模式/请求","点对点消息传递模式下，可在消息发送的时候指定一个应答处理器（可选）。","点对点消息模式。","然后创建","然后，将包含该命令的jar放入fat","然后，您可以按下边方式获取转换的值：","版本可通过","版本的扩展机制不好","版本，http","状态代码,如:200、404","状态代码时，使用","状态代码时，使用相同的","状态代码时，它遵循由","状态响应码为","状态消息,如:ok、not","环境","环境变量中，还要确保您的","环境变量和系统属性可以直接通过","环境变量，请确保路径下包含所有需要的jar（vertx","现在准备请求的一些东西","现在将接收组的数据包","现在开启了ha环境，在集群中需要多添加一个vert.x","现在您可以使用","现在我们来看看","现在所有的响应体都读取了","现在让我们专注于如何发送多播报文，发送多播报文与发送普通数据报报文没什么不同。","现在部署其他的一些verticl","甚至可以通过桥接的方式允许在浏览器中运行的客户端javascript在相同的ev","甚至是不同的","生成","用groovy的factori","用service的factori","用于","用于测试和开发目的的自签名证书","用于通用错误：1","用以在发生任何异常的时候接收异常信息。","用客户端发出请求的所有不同方式都支持这两种指定主机/端口的方法。","用户是无法直接利用路径访问的。更安全的做法是使用vert.x","由","由于","由于java不提供对类路径资源的异步方法，所以当类路径资源第一次被访问时，该文件将复制到工作线程中的文件系统。当第二次访问相同资源时，访问的文件直接从（工作线程的）文件系统提供。即使类路径资源发生变化（例如开发系统中），也会提供原始内容。","由于start命令产生一个新的进程，传递给jvm的java选项不会被传播，所以您必须使用java","由于vert.x或应用程序的代码块中没有阻塞，ev","由于没有阻塞，event","由于远程方应该确认接收者的配置更新，也有可能在回调中接收确认通知：","由此引入了下面一些vert.x中的重要概念。","的","的api：","的a记录，您需要像下面那样做：","的buffer。代码如下：","的jar库。依赖于tcnative的实现它需要openssl安装在您的操作系统中。","的listen(...)方法来绑定一个地址并且加入多播组，并加入多播组。","的main","的socket都将收到该报文。","的vert.x","的一个新功能，它可以为单个客户端并行发送多个响应。","的代码风格会很怪异，所以我们根据","的例子。","的例子：","的区别：文中所有","的压缩级别通常允许仅仅保存一些字节大小","的原生支持（first","的发行版，并且将安装的","的名称会用于查找实例化","的含义实际上是由应用程序来定义的。这完全取决于消费者如何执行，event","的基本","的处理。","的处理器。当连接成功或失败时处理器会被调用。","的处理器，那么这些处理器在","的子类来启动您的应用程序。这个类被设计成易于扩展的。","的实例。","的实例传入处理器并调用它，表示您现在拥有该锁。","的实例，它提供了添加、设置、删除条目的操作。http","的实现类必须实现","的实现类，因此可以和泵(pump)一起使用。","的实现类，如默认的","的对象的数量——方法writequeuefull返回true。注意，当写队列被认为已满时，若写（操作）被调用则数据依然会被接收和排队。实际数量取决于流的实现，对于buffer，尺寸代表实际写入的字节数，而并非缓冲区的数量。","的帧的最大值，则vert.x在将其发送到报文之前将其拆分为多个websocket","的常用命令行参数：","的引用：","的情况发生。","的控制中心，也是您做几乎一切事情的基础，包括创建客户端和服务器、获取事件总线的引用、设置定时器等等。","的数量，您亦可自行设置。","的整数值，其中","的文档获取更多信息。","的方式，从不同的","的方法。","的本地地址，通过","的核心","的特定","的状态一致性。","的状态被标记成失败），则返回的","的示例：","的神经系统。","的第二种方法是处理从客户端发送的http升级请求，调用服务器请求对象的","的简单示例。","的类型：","的索引进行标识。第一个参数的索引为","的线程来调用您的处理器。","的设置","的远程地址（即连接的另一端的地址）。","的连接。","的连接，则使用setidletimeout","的连接，若您想要在一段空闲时间之后让","的部署例子：","的部署和并发模型机制。您可以用此模型机制来保管您自己的代码组件。","的配置信息。查看","的配置和私钥是不加密的。","的配置需要在所有集群节点中保持一致性。","的问题，也可以避免传统的多线程应用经常会遇到的竞态条件和死锁的问题。","的顺序，可以将","的默认构造函数（或不定义构造函数），mapfrom","监听随机端口","目录添加到您的","直接从磁盘或","直接写入数据","直接通过tcp连接完成。","相互通信，无论它们使用哪一种语言实现，无论它们在同一个","相反，也可以在收到","相反，在收到新的远程设置时会通知","相反，它内部仅仅维护一个服务器实例。当传入新的连接时，它以轮询的方式将其分发给任意一个连接处理器处理。","相应示例来了解如何将应用打包成","相比选项，argument可以：","看这个例子会更清楚：","知道它是一个groovi","确保请求完成后结束","禁用时，vert.x","种类","秒。","稍后当vert.x有一个事件要传给您的处理器时，它会","空的。它不会创建一个填满了","突然挂掉，这个","章节。","章节了解更多事件总线集群细节），那么通常情况下您将需要使用另一种异步的方式来创建","章节了解更多配置信息。","章节了解类路径的限制或禁用它。","章节来了解详细信息。","端口。所以，当这个","第一次写入操作会触发响应头的写入，因此，若您不使用http","第一种方法是指定包含密钥和证书的java","第一种方法是指定包含证书和私钥的java密钥库位置。可以使用","第一种方法是指定包含证书颁发机构的java受信库的位置。","第一种方法需要在服务端实例上提供一个","等","等。","等其他信息。","等待一个互斥信号或监视器（例如同步的代码块）","等待一个锁","等待部署完成","等）。","等）将被重用。","算法。","算法压缩过的请求体信息。","管道意味着在返回一个响应之前，在同一个连接上发送另一个请求，管道不适合所有请求。","类。","类中使用，可以在","类中所有的字段都是","类似gnu选项（即du","类似java属性（即java","类似posix选项（即tar","类似。","类似地，对于文件上传vert.x","类作为主类时，它使用以下退出代码：","类则不翻译）","类名。我们为log4j（版本1）、log4j","类型的表单，它会被编码在请求体中，而且在整个请求体被完全读取之前它是不可用的。multipart","类型请求，那么它们将不会显示在此处的参数中。","类型，则（系统）会自动计算一组选项。","类提供了这个功能。这里有些例子：","类提供了追加各种不同类型数据的追加写入方法。","类来扩展命令集（仅限于java）：","类来描述选项和参数：","类用来描述","类用来描述json对象。","类的对象，但是当消息发送给处理器后解码成","类的文档。","类而不是java","类，只需要将","类，您可以使用语言前缀groovy:，因此vert.x","系统属性配置该位置。如，若当前工作目录不可写（例如在不可变容器上下文环境中），请使用以下命令启动应用程序：","索引为0","索引为1","级别和","线程。verticl","线程。取而代之是使用","线程。默认情况下，我们会根据机器上可用的核数量来设置","线程上。所以在该","线程上。稍后的章节我们会讨论更多。","线程上执行。这意味着如果您在多核的服务器上运行，并且只部署了一个实例，那么您的服务器上最多只能使用一个核。","线程中。对于运行内联的阻塞代码的","线程中被调用。","线程中，如单元测试或纯java的","线程中：客户端处理器将被不同的vert.x","线程和上下文调用，这样的上下文会根据需要创建。对于生产环境，不推荐这样使用。","线程安全","线程池的线程上。","线程池：","线程（或","线程）。一个","线程），但一个","线程，并在这个","组件介绍","绑定的处理器会被调用一次：","结合起来发送请求的头信息。","结尾的某些文件系统操作），vert.x中的所有api都不会阻塞调用线程。","结束一个请求时，若请求头尚未被写入，会导致它们被写入，并且请求被标记成完成的。","结束处理器","结束请求","结构。它具有字符串的键，值可以是任意一种json","结构的","结语","给","给客户端：","绝对uri","继承更简单。","维护集群范围中的主题订阅者列表（所以我们可知道哪些节点对哪个event","缓存","编写","编写支持","编码形式上传的的文件。","编码成字符串格式。","编码过的表单，表单属性会被编码在url中，如同普通查询参数一样。","编程方式部署verticl","编译java源代码并进行部署","网络活动可以被记录下来，用于调试：","翻译成了反应器模式）。","而不是","而不是jdk实现（来支持ssl）。","耦合，它们可以和任意类型的对象一起工作。","自动关闭","自动故障转移","自动生成了适应不同语言代码风格的","自签名证书也适用于其他基于tcp的协议，如https：","自身，所以它可以链式地调用:","至少一个失败","至少一个成功","节点不在授信的网络上，请勿使用。","节点中以使用","节点之间创建集群模式下的","节点发现和分组","若mi","若vert.x无法初始化：11","若websocket","若主verticle不能被部署：15","若使用setfactory嵌入了vert.x实例，也可以用编程方式指定度量工厂。","若使用了","若前缀后缀都没指定，vert.x将假定这个名字是一个java","若响应体通过","若客户端不想收到推送请求，它可重置流：","若客户端不支持http","若客户端将","若客户端没有设置trustall，则必须配置客户端受信存储，并且受信客户端应该包含服务器的证书。","若已经有一个","若您不想使用默认配置，可以在创建时通过传入一个","若您不想用默认值，可以在创建服务器时传递一个","若您不指定状态信息，将会使用默认的状态码响应。","若您不需要关心您调用","若您仅需要写单个字符串或","若您只是想将文件上传到服务器的某个磁盘，可以使用","若您只需要将单个字符串或","若您在","若您在启动应用程序时看到以下信息：","若您在命令行中使用vert.x并要使用集群，则应确保vert.x安装的lib目录包含您的集群管理器jar。","若您在调用listen(...)之前已经绑定了datagramsocket，您可以通过调用localaddress来查找套接字的本地地址（即udp","若您在调用其中一个","若您在集群模式下的","若您希望在完成注册后收到通知，您可以在","若您希望在服务器实际监听时收到通知，您可以向","若您总是希望某个类使用将特定的编解码器，那么您可以为这个类注册默认编解码器。这样您就不需要在每次发送的时候使用","若您想写入请求头，则您必须在写入任何请求体之前这样做来设置请求头。","若您想可设置默认端口","若您想将一个","若您想要从偏移量开始发送文件直到尾部，则不需要提供长度信息，这种情况下，您可以执行以下操作：","若您想要决定是否手动发送持续响应，那么此属性可设置成false（默认值），然后您可以通过检查头信息并且调用","若您想要加载的类和资源不存在于主类路径（main","若您想要在","若您想要在连接创建完时收到通知，则需要设置一个","若您想要将","若您想要接收数据包，则您需要调用","若您想要读取","若您想要配置客户端选项，可按以下方式创建：","若您拥有的锁没有其他调用者，集群上的任何地方都可以获得该锁。","若您正在编写一个web","若您用编程的方式创建","若您的一个选项是","若您的应用关心丢失的消息，您应该编写具有幂等性的处理器，并且您的发送者可以在恢复后重试。","若您的日志显示一堆：","若您知道响应体不是很大，并想在处理之前在内存中聚合所有响应体数据，那么您可以自己聚合：","若您需要在收到请求时收到通知，则需要设置一个","若您需要这样的保证，您可在tcp之上建立一些握手逻辑。","若想显示vert.x的版本，只需执行：","若我们现在关闭或杀死其中一个节点，那么这些模块将在其他节点上自动撤销，因为不再满足","若打开的文件已经存在，则可以使用","若没有设置任何处理器时，任何被推送的流将被客户端自动重置流（错误代码","若生成的进程无法启动、发现或停止：12，该错误代码一般由start和stop命令使用","若系统配置不符合系统要求（如找不到","若终端3中的实例被杀掉，因为这个组中没有其他vert.x实例，则它不会故障转移。","若要使用","若要向响应添加尾部，则直接添加到","若要启用","若要启用ha模式，在启动","若要启用管道，必须调用setpipelining方法，默认管道是禁止的。","若要启用解压缩功能则您要在创建服务器时调用","若要启用高可用方式运行一个","若要在集群模式下保证安全性，您","若要接收特定多播组的数据包，您需要通过调用","若要接收自定义帧(frame)，您可以在请求中使用","若要获取","若解析器在getquerytimeout毫秒内没有收到正确答案（默认为5秒），dns查询被视为失败。","若设置监听端口为0，服务器将随机寻找一个没有使用的端口来监听。","若请求在超时期限内未返回任何数据，则异常将会被传给异常处理器（若提供），并且请求将会被关闭。","若进程顺利结束，或抛出未捕获的错误：0","若选项值包含空白，请不要忘记在“”（双引号）之间包装值。","若需要调整","获取","获取event","获取map的过程是异步的，返回结果可以传给您指定的处理器中。以下是一个例子：","获取到了集群模式下的","获取失败，可能是集群管理器出现了问题","获取完整列表。","获得锁","虚拟机本身附带的api是不可能的，因此vert.x提供了它自己的完全异步解析dns的api。","表单","表单。","表单的属性，您应该告诉","表单还可以包含文件上传。","表单，并对请求设置","表示使用了tls的应用层协议协商(alpn)协议来协商的","表示可用的最大压缩比但比较慢的算法。","表示在tcp层上使用明文形式的","表示在响应完成后连接将被关闭。","表示更低的压缩比但是最快的算法，9","表示要监视的文件集，这个集合可使用","被创建时，它会被分派给一个","被实例化多次，如运行以下命令：","被我们称为","被撤销时这个计时器会被自动关闭。","被撤销的时候会自动被注销。","被设置到了仅占用一个字节的特定位置：","被设置时，使用该选项","被设计来调用阻塞式代码，它不会阻塞任何","裁剪buffer","裁剪得到的buffer是基于原始buffer的一个新的buffer。它不会拷贝实际的数据。使用","裸","要","要为","要使用asyncfile进行随机访问写，请使用","要使用asyncfile进行随机访问读，请使用","要使用udp，您首先要创建一个","要使用该模型，您需要将您的代码组织成一系列的","要做ipaddress","要发送多个帧组成的消息，请使用","要发送这样的帧，您可以使用","要发送这样的帧，您可以在响应中使用","要启用压缩，可以使用","要启用实时重新部署，请将","要告诉服务器当前客户端支持哪种压缩，则它（请求头）将包含一个","要告诉服务器监听传入的请求，您可以使用其中一个","要告诉服务端监听传入的请求，您可以使用其中一个","要在","要处理","要将您的verticle全部部署在这个fat","要屏蔽来自特定地址的多播，您可以在","要指定一个ha组，您可以在运行该verticle时使用","要接收文件，您可以告诉","要接收自定义帧，您可以在请求中使用","要接收请求体，您可在请求中调用","要查找","要查找vertx.io的所有aaaa记录，您通常会执行以下操作：","要查找vertx.io的所有a记录，您通常会执行以下操作：","要查找vertx.io的所有cname记录，您通常会执行以下操作：","要查找vertx.io的所有srv记录，您通常会执行以下操作：","要查找您常用执行的vertx.io的所有mx记录：","要解析ip地址10.0.0.1的ptr记录，您将使用1.0.0.10.in","要解析vertx.io的所有ns记录，您可以使用下边几行：","要解析vertx.io的所有txt记录，您可以使用下边几行：","要调试应用程序，请将运行配置创建为远程应用程序，并使用","规范中定义了可用的","规范，一个客户端可以设置请求头","解析不会失败，您可以做：","解析会一直在代理服务器上执行。为了实现","解析后，您可以从解析方法返回的commandline对象中读取选项和参数的值：","解析总是在代理服务器上完成解析，为了实现","解析用户命令行","解析阶段","触发一个计时器","警告：","警告：multi","警告：大多数浏览器不支持","警告：确保您检查了生产系统的文件名，以避免恶意客户将文件上传到文件系统中的任意位置。有关详细信息，参阅","警告：若您要直接使用","警告：谨慎使用此功能，类加载器可能会导致您的应用难于调试，变得一团乱麻（can","警告：随后的重定向会缓存请求体。","计算重定向uri","让我们举个例子，我们要从readstream中读取数据，然后将数据写入writestream。","让我们看看使用异步方法的几个例子：","让服务器监听配置项指定的主机和端口：","记录客户端网络活动","记录服务端网络活动","记录网络活动","记录解析器","记录解析器将生成下结果：","记录解析器（record","记录，您需要像下面那样做：","许多情况下，您只需要发送一个包含了单个最终帧的","设置","设置。","设置一个推送处理器来感知服务器推送的任何资源","设置为","设置了下限，则有效值可以更低。","设置响应头","设置将用作客户端默认配置。","设置消息头","设置状态码和消息","设置的w","设置的值，此时，模块将自动部署在所有实例上。","设置配置项启用压缩。","访问文件","访问文件系统","访问：","证书颁发机构可通过多种方式为服务端配置。","译者注：rpc通信通常情况下有三种语义：at","译者注：vert.x","译者注：如要得到更优美、格式化的字符串，可以使用","译者注：每个","译者注：这里给个示例：","译者注：通常情况下，这是正常的，无需担心，如果您打开浏览器，按快捷键不停滴刷新页面，就能看到该severe日志。","该命令集是可扩展的，请参考","该方法也可使用一个处理器来调用，这个处理器在","该方法的参数有：","该目录必须是可写的。","该配置可通过core","详情请参阅","详细说明请参阅","详细请参阅","语言——若有需要可以切换到语言特定部分（手册中）。","请求","请求/响应模型的具有各种帧的一个帧协议，该协议允许发送和接收其他类型的帧。","请求/响应模型的包含各种帧的一种帧协议，该协议允许发送和接收其他类型的帧。","请求uri","请求、http","请求。","请求。它还将接受以","请求。当请求的头信息被完全读取时会调用该请求处理器。","请求。若要执行","请求中传递的uri通常是相对的，若您想要读取请求中和相对uri对应的绝对uri，可调用","请求中传递的实际uri，它总是一个相对的uri。","请求中的主机名。","请求中的请求头部信息。","请求主机","请求体中读取数据","请求体中，如下所示：","请求体很大并填满了内存，任何时候它依旧会工作：","请求体被完全读取，所以直接读取表单属性","请求体，这个在请求体比较大需要流式发送到服务器，或预先不知道大小时很常用。","请求体，除非返回的请求使用了","请求例子：","请求则返回伪头中的:authority的值。","请求参数","请求参数在请求uri的","请求可以通过多种方式结束。无参简单结束请求的方式如：","请求和响应和","请求头部","请求头，除非您已经设置了一些头（包括","请求对象实现了","请求并尝试升级到","请求异常处理器","请求或者直接建立","请求方法","请求查询","请求添加一个","请求版本","请求的","请求的准备工作，您必须调用其中一个","请求的超时时间。","请求设置成分块模式。","请求超时","请求路径","请求返回请求头中的","请求需要提供","请求，tls必须禁用，客户端将执行","请求，tls必须被禁用，服务器将升级到","请求，你必须调用","请求，则必须调用","请求，并在单个方法调用中发送它，而且允许您提供一个处理器，当http","请求，很明显的是每一个请求处理时间不可以超过0.1毫秒，所以您不能阻塞任何过多（大于0.1毫秒）的时间。","请求，必须使用应用层协议协商(alpn)启用tls：","请求，这种情况通常如http","请注意上述代码直接使用了","请注意仅仅只有匹配的类会被隔离，其他任意类会被当前类加载器加载。","请注意这仅适用于某些操作系统和内核版本，所以请检查操作系统文档看是它是否支持。","请注意，netty会寻找slf4","请注意，列表将包含按照它们优先级排序的mxrecord，这意味着列表中优先级低的mx记录会第一个优先出现在列表中。","请注意，列表将包含按照它们优先级排序的srvrecord，这意味着优先级低的记录会第一个优先出现在列表中。","请注意，您可以传入","请注意，提供的log4j","请注意，这些请求参数是从请求的","请注意，这是在http","请注意：","请注意：jdk需要支持java代码的快速编译。","请注意：jdk需要支持java代码的运行时编译（on","请注意：vert.x","请注意：worker","请注意：即使一个","请注意：只有当第二个vert.x","请注意：大部分应用将只会需要一个vert.x实例，但如果您有需要也可创建多个vert.x实例，如：隔离的事件总线或不同组的客户端和服务器。","请注意：当加载io.vertx.core.impl.fileresolver类时，这些系统属性将被评估一次，因此，在加载此类之前应该设置这些属性，或者在启动它时作为jvm系统属性来设置。","请注意：您不需要在一个","请注意：有时可能需要使用jvm内置解析器。可以在启动的时候加上jvm系统属性","请注意：本文大部分内容专用于","请注意：此功能仅适用于","请注意：此功能仅适用于http/2协议。","请注意：这个配置信息在","请注意：通过","请记住","请记住pem的配置和私钥是不加密的。","请记住这个计时器将会定期触发。如果您的定时任务会花费大量的时间，则您的计时器事件可能会连续执行甚至发生更坏的情况：重叠。这种情况，您应考虑使用","请阅读","读取user","读取帧","读取帧，您可以使用framehandl","读取文件","读取请求体","读文件","调用","调用一些需要耗费显著执行时间返回结果的阻塞式api","调用了","调用这个处理器。","资源记录不应该存在","路径部分应该是：","转换到","运行","运行20个ruby语言的work","运行javascript的verticl","运行ruby的verticl","运行vert.x实例，您可以在命令行中指定","运行一个rubi","运行应用时，默认会执行","运行指定类路径的预编译好的10个java","运行阻塞式代码","近似于普通的","返回值是一个唯一的计时器id，该id可用于之后取消该计时器，这个计时器id会传入给处理器。","返回的","返回的请求必须是未发送的，这样原始请求处理器才会被发送而且客户端之后才能发送请求。大多数原始请求设置将会传播（拷贝）到新请求中：","还将提供堆栈跟踪，以精确定位发生阻塞的位置。","还应提供受信存储的密码：","还应提供密钥存储的密码：","还提供了其他命令：","这两个快捷方法。","这两种","这个","这个api是流式的，因此这个方法可以被链式地调用。","这个headers是一个","这个uri是在","这个例子不会耗尽内存，但如果写入队列已满，我们最终会丢失数据。我们真正想要做的是在写入队列已满时暂停读取","这个功能不能用于生产环境","这个功能对于跨多核扩展时很有用。例如，您有一个实现了web服务器的verticle需要部署在多核的机器上，您可以部署多个实例来利用所有的核。","这个处理器将会每隔一秒被调用一次","这个数学题并不难，将留给读者作为练习。","这个方法的参数有：","这个方法返回一个","这个服务正在监听","这个模型不能说是严格的","这个模型是可选的，如果您不想这样做，vert.x","这个消息将会传递给所有在地址","这个策略将会处理接收到的原始","这个配置会以","这些帧被立即发送，并且不受流程控制的影响——当这样的帧被发送到那里时，可以在其他的","这些阻塞做法包括：","这使得它们对于托管vert.x","这儿是一个非常简单的","这儿有一个例子，它回应了任何","这儿有一个例子：","这儿有一个部署不同类型","这儿有一些写入请求体的","这儿有一些创建","这儿有三种不同类型的","这允许http","这允许使用块方式写入http","这允许它同时处理支持http","这允许您部署用任何使用vert.x支持的语言编写的verticle实例。","这可以通过几种方式完成：","这和更加详细的例子完全一样。","这实际上是在发送响应体的最后一个（数据）块。","这将阻止从10.0.0.2发送的数据包","这意味着","这意味着在响应发送回客户端之前，您可以将响应体自动压缩。","这意味着客户端正在重置http连接，而不是关闭它。此消息还可能表示您没有读取完整的有效负荷（连接在读取完全之前被切断）。","这意味着您可以通过向这个地址发送","这意味着您的类路径中有slf4j","这意味着我们可以保证您的","这意味着每个数据包都可以发送到不同的远程对等体。","这是一个常见的情况，vert.x为您提供了一个","这是专家级别的技巧。","这是因为让不同的","这是因为请求体可能非常大（如文件上传），并且我们不会在内容发送给您之前将其全部缓冲存储在内存中，这可能会导致服务器耗尽可用内存。","这是服务器处理请求并回复","这是贯穿","这是随机访问写的示例：","这有个例子：","这样做可以得到和上边相同的结果","这样您就可以接收到被发送至","这样的链式调用会让您的代码更为简洁。当然，如果您不喜欢流式风格，我们不强制您用这种方式书写代码。如果您更倾向于用以下方式编码，您可以忽略它：","这样，您将能够接收到被发送到","这样，我们可以确保在vert.x应用程序不同线程之间","这次使用默认端口80和指定的主机名","这种处理器不处理需要在","这种情况下，您可以先监听他们，之后再取消监听。","这种方法主要缺点是alpn的实现版本依赖于jvm的版本。为了解决这个问题，可以使用","这表示","这里。","这里例子中，有三个操作被串起来了：","这里的想法是允许服务器在发送大量数据之前授权、接收/拒绝请求，若请求不能被接收，则发送大量数据信息会浪费带宽，并将服务器绑定在读取即将丢弃的无用数据中。","进程能够在您的服务器上扩展，与","进行交互。主要用于运行","进行编码，并将结果写入到报文中。","远程地址","连接","连接。","连接不会被客户端自动关闭，若要关闭它们，可以调用","连接也可以直接建立，如连接可以使用前文提到的方式创建，当","连接事件、生命周期、设置的api。","连接代理","连接关闭","连接关闭/goaway","连接关闭时","连接到服务端，并提供回调函数。","连接前缀，并期望从服务端接收相同的连接偏好。","连接发送和接收消息，因此可以通过","连接在关闭响应之前会发送","连接建立后可随时更改设置：","连接时，vert.x","连接时，它会向客户端发送其初始设置。定义客户端如何使用连接，服务器的默认初始设置为：","连接用于多个请求。当您向同一台服务器发送多个请求时，可以更加有效使用连接。","连接的复用限制是在客户端上设置限制单个连接的流数量，如果服务器使用","连接配置","连续","追加上","追加到buffer","退出","选择其中一个。","选择绑定并配置。","选项","选项传递给","选项可以标记为必填项，在用户命令行中未设置必填选项在解析阶段会引发异常：","选项来简单部署更多的服务器实例：","选项确定应用程序的主类启动器。它通常是一个","选项设置为","通常您希望使用","通常您需要像上边例子一样重写","通常情况下，您需要以异步方式来获取dns信息。","通常情况，alpn会对","通常表示java中的类","通常，您想发出没有请求体的http","通知何时关闭所有流，连接尚未关闭。","通过","通过代码的方式启用集群模式","通过命令行启用集群模式","通过开箱即用的方式提供了一个简单便捷的、可扩展的、类似","通过源文件运行10个java","通过覆盖","那么参数将包含以下内容：","那么如何获取它的实例呢？","部分。","部分之后，例如uri是：","部署","部署javascript的verticl","部署ruby的verticl","部署一个groovy的verticl","部署一个javascript的verticl","部署一个ruby的verticl","部署一个已经打包成jar的verticle，这个jar需要在类路径中","部署一个已经编译好的java的verticle，类的根路径是当前目录","部署和撤销","部署和运行的代码块。默认情况一个","部署完成，这样做会破坏","部署成一个","都会在","都会自动进行扩容，所以不可能在使用","都应该成功。","都必须遵守连接另一端的发送设置。","都成功完成，该方法将返回一个","都执行失败，则该","都是事件驱动的，当有事件时","都是非阻塞式的并且不会阻塞","都绑定到同一个端口，您将收到一个","配置","配置jul日志记录","配置jvm虚拟机选项。","配置tls协议版本","配置。","配置密码套件","配置对应行为。","配置日志记录时，您也应该关心配置netty日志记录。","配置服务端和客户端以使用ssl/tl","配置网络服务器以使用","配置连接重试","配置项来启用","配置：","里。","里。这对以优化网络协议和最小化带宽消耗为目的实现的编解码器是很有用的。","重定向处理器","重定向策略如下：","重定向：当客户端接收到","重新获取时，他们将重新部署。通过这样做您可以防止网络分区，也就是脑裂（split","重新部署功能还支持以下设置：","重新部署过程如下执行。首先，您的应用程序作为后台应用程序启动（使用start命令）。当发现文件更改时，该进程将停止并重新启动该应用、这样可避免泄露。","重用","重要提示：","重要提示：一系列的","重要提示：分布式数据结构的行为取决于您使用的集群管理器，网络分区面临的备份（复制）和行为由集群管理器和它的配置来定义。请参阅集群管理器文档以及底层框架手册。","重要提示：请注意，干净地关闭vert.x实例不会导致故障转移发生，例如：ctrl","锁获取失败","错误代码会发送，您也可以发送另外一个错误代码：","错误处理","错误时间戳","错误码","键","阻塞版本的方法名为","附带的","限定类全名，如","除了run和version以外，vertx命令行和","除了取消监听一个多播地址以外，也可以做到屏蔽指定发送者地址的多播。","除了很少的特例（如以","除此之外，udp不像tcp的使用那样安全，这也就意味着不能保证发送的数据包一定会被对应的接收端（endpoint）接收。","除此之外，您还可设置一个处理器，它在每次接收到","除此之外，您还要设置一个handler，每接收到一个","除非您拿到","随机访问写","随机访问写buffer","随机访问读","隔离组","集群","集群模式","集群模式的","集群管理器","集群管理器不处理event","集群管理器必须实现clustermanager接口，vert.x在运行时使用java的服务加载器（servic","集群范围异步map","集群范围异步map(clust","集群范围计时器","集群范围锁","集群范围锁具有异步api，它和大多数等待锁释放的阻塞调用线程的api锁不相同。","集群范围锁（lock）允许您在集群中获取独占锁","需要从类路径中读取文件（嵌入在","非常灵活，它支持在","非必填选项可以具有默认值，如果用户没有在命令行中设置该选项，即将使用该值：","非标准的","非标准的http","非法密钥","非法签名","页面上找到。","项目中以正常方式添加","项目使用vert.x，则只需将集群管理器jar作为项目依赖添加。","顺序合并","顺序执行（一个接一个）。","首先来看些基本概念和理论。","首先，默认情况下，vert.x","高可用/故障转移","高可用ha实现同样支持","高可用和故障转移","高可用性","黄金法则。","黄金法则：不要阻塞event","默认主机名是","默认主机名是0.0.0.0，它表示：监听所有可用地址；默认端口号是80。","默认允许任何基本/简单类型、string","默认情况下","默认情况下，dns服务器选择使用第一个，其余的服务器用于故障转移。","默认情况下，http","默认情况下，tls配置将使用以下协议版本：sslv2hello、tlsv1、tlsv1.1","默认情况下，tls配置将使用运行vert.x的jvm","默认情况下，vert.x","默认情况下，vert.x不会记录任何指标。相反，它为其他人提供了一个spi，可以将其添加到类路径中。spi是一项高级功能，允许实施者从vert.x捕获事件以收集指标。有关详细信息，请参阅","默认情况下，多个连接尝试是被禁用的。","默认情况下，如果","默认情况下，它会执行","默认情况下，它将使用环境中系统dns服务器地址的列表，若该列表无法检索，将使用google的公共dns服务器","默认情况下，客户端禁用主机验证。要启用主机验证，请在客户端上设置使用的算法（目前仅支持https和ldaps）：","默认情况下，解析器将使用环境中的系统dns搜索域，或者，可提供明确的显示搜索域列表：","默认情况压缩被禁用。","默认情况最大的重定向数为","默认情况，发送","默认情况，当vert.x部署verticle时它会调用当前类加载器来加载类，而不会创建一个新的。大多数情况下，这是最简单、最清晰和最干净。","默认是不分块的，当处于分块模式，每次调用任意一个","默认的","默认的阻塞式代码会在","（扩展包）（译者注：vert.x的扩展包是vert.x的子项目集合，类似web、web","）方法来标记启动完成或失败了。","，它可使您避免用传统方式编写代码：如果成功则完成","：","：提供了verticle的一些配置，config_file是包含描述verticle配置的json对象的文本文件的名称，该参数是可选的。","：搜索verticle和它使用的其他任何资源的路径，默认为.（当前目录）。若您的verticle引用了其他脚本、类或其他资源（例如jar文件），请确保这些脚本、其他资源存在此路径上。该路径可以包含由以下内容分隔的多个路径条目：:（冒号）或;（分号）——这取决于操作系统。每个路径条目可以是包含脚本的目录的绝对路径或相对路径，也可以是jar或zip文件的绝对或相对文件名。一个示例路径可能是","：要实例化的verticle实例的数目，每个verticle实例都是严格单线程（运行）的，以便在可用的核上扩展应用程序，您可能需要部署多个实例。若省略，则部署单个实例。"],"web/Web.html":["!!!","!=","\"","\"/catalogue/products/:producttype/:productid/\");","\"/some/path/\");","\"address\":","\"albums\"));","\"application/json\").end(tojson(ar.result()));","\"application/json\");","\"bar\");","\"body\":","\"client_id\",","\"client_secret\");","\"en\":","\"es\":","\"find\")","\"foo\"));","\"fr\":","\"http://localhost:8080\");","\"https://myserver.com/callback\");","\"https://myserver.com:8447/callback\");","\"jceks\")","\"keystore.jceks\")","\"myapi/orders\")","\"myapp3.sessionmap\");","\"myapp3.sessionmap\",","\"myclusteredapp3.sessionmap\");","\"paulo\"),","\"paulo\").put(\"somekey\",","\"pt\":","\"secret\"));","\"secret\".equals(ctx.request().getparam(\"password\")))","\"send\"|\"publish\"|\"receive\"|\"register\"|\"unregister\",","\"some","\"somevalue\"));","\"text/html\").end(\"helloprotect","\"text/plain\");","\"type\":","\"val\").put(\"header2\",","\"val2\");","&&","'","'bar'","'foo'","'io.vertx:vertx","'tim',","(\"paulo\".equals(ctx.request().getparam(\"username\"))","(4)","(ar.succeeded())","(be.getrawmessage().getstring(\"body\").equals(\"armadillos\"))","(be.type()","(ctx.statuscode()","(everi","(language.tag())","(languagehead","(not","(rc.getacceptablecontenttype().equals(\"text/xml\"))","*","*.vertx.io","+",",",".",".consumes(\"application/json\")",".end(\"not",".ftl",".hb",".html",".html、.css、.j",".jade",".peb",".produces(\"application/json\");",".put(\"collection\",",".put(\"password\",",".put(\"path\",",".put(\"type\",",".setauthorizationpath(\"/o/oauth2/auth\"));",".setclientid(\"client_id\")",".setclientsecret(\"client_secret\")",".setmatch(new",".setsite(\"https://accounts.google.com\")",".setstatuscode(404)",".settokenpath(\"https://www.googleapis.com/oauth2/v3/token\")",".templ",".vertx","/","//","//虽然通过一个","/bar/foo","/bar/wibbl","/catalogue/products/tools/drill123/，那么会匹配这个","/dynamic/graph.hb","/foo","/foo/bar/wibble/foo","/loginpage。","/preoductapi：","/privat","/products/product1234","/some/path","/some/path/","/some/path//","/some/path/b，该处理器最后结束了响应。","/some/path/foo","/some/path/foo.html","/some/path/oth","/some/path/otherdir/blah.css","/some/path，首先第一个处理器向上下文添加了值，然后路由到了下一个处理器。第二个处理器转发到了路径","/somepath/","/static","/static/css/mystyles.css","/templates/graph.hb","/tools/drill123/，那么会匹配这个","/，则意味着是一个子类型（sub","/，所以路径","0","0，第二个是","1);","1.0。","1.0。缺省值为","1.0）。","10","1000","10000);","128","128k。","1456m","1，以此类推。","2","2.x","25","3.0.0","3.1.0","3.4.1","30","300000});","304","401","403","404","404)","413","5","500","500，否则是","503","587});","64","8","8080",":","=","==",">","@{context.get('bar')}","@{context.request().path()}","@{context.session().get('foo')}","[snip]","`*.vertx.io`","`.hbs`","`/dynamic`","`/foo/bar`","`/myapi/orders`","`/private/settings`","`/private`","`/protected`","`/some/bath`","`/some/path//`","`/some/path/`","`/some/path/subdir/blah.html`","`/some/path/subdir`","`/some/path`","`/somepath/`","`accept`","`action`","`admin`","`albums`","`application/json`","`content","`demo.ordermgr`","`demo.orderservice`","`find`、`collecton`","`foo`","`http://localhost:8080`","`json`","`list_products`","`news.`","`place_orders`","`text/html`","`text/json`","`text/plain`","`text`","`ticker.mystock`","`wibble`","accept","accept(3)处理。","accept:","acceptablecontenttyp","acceptablecontenttype);","acceptablelocal","acceptable）的路由","activ","addcooki","addinboundpermitted(inboundpermitted));","addinboundpermitted(inboundpermitted1).","addinboundpermitted(inboundpermitted3).","addoutboundpermitted(outboundpermitted1).","addoutboundpermitted(outboundpermitted2);","address","address',","addressregex","address，这个选项会被忽略。","ag","age:","age=86400，也就是一天。可以通过","apach","api","api。","api。我们会将它挂载到另一个","api。通过这些","api，所以熟悉基于","application/*","application/json","application/json,","application/json;","application/json;q=0.7,","application：应用","auth","authcod","authconfig","authconfig);","authent","authhandl","author","authorizt","authprovid","authprovider.generatetoken(new","azur","azureadauth","b","balancer：负载均衡器","bar","base64","base64_access_token","basicauthhandl","basicauthhandler.create(authprovider);","be","be.complete(false);","be.complete(true);","be.getrawmessage();","be.setrawmessage(rawmessage);","be.type()","bearer","blockinghandl","blocking：阻塞式","bodi","bodyhandl","body：消息体","boolean","bower","box.com","boxauth","bridg","bridgeev","bridgeeventtype.publish","bridgeeventtype.receive)","bridgeeventtype.send)","bridgeeventtype.socket_idle)","bridgeopt","bridgeoptions().","bridgeoptions().addinboundpermitted(inboundpermitted).setpingtimeout(5000);","bridgeoptions().addinboundpermitted(inboundpermitted);","bridgeoptions();","bridge：桥接","bu","buffer","buffer、jsonobject、jsonarray","build.gradl","bus。只要服务器之间的链接存在，浏览器不需要每一次都与同一个服务器建立链接。","bus。这个","cach","callback","case","classpath","clearus","client","close","clusteredsessionstor","clusteredsessionstore.create(vertx);","clusteredsessionstore.create(vertx,","compil","console.log('close');","console.log('message',","console.log('open');","console.log('receiv","consum","container：容器","content","context","context.get('foo')","context.request().path()","context（vert.x","context，不同于","context，例如同一个","context：上下文。非特别说明指代路由的上下文","control","control、last","cooki","cookie(5)","cookiehandl","cookievalu","cookie。","cookie。可参考","cookie。客户端会在消息头里包含这个令牌。由于令牌基于","cookie，会自动回写到响应里","cookie，因此需要在","cookie，特指有效期为","cor","core","core，提供了一系列更丰富的功能以便更容易地开发实际的","corshandl","cors（跨域资源共享）","csrf","csrfhandler","ctx.fail(401);","ctx.next();","ctx.request().setexpectmultipart(true);","ctx.reroute(\"/mi","ctx.response()","ctx.response().end(authprovider.generatetoken(new","ctx.response().putheader(\"cont","data","delete。","deni","depend","destroy","directori","disabl","disabledtransport","don't","drill123。","dropbox","dropboxauth","e.data);","e.g.:","eb","eb.onopen","eb.registerhandler('som","eb.send('som","enabl","engin","entiti","errorhandler。您只需要在需要覆盖到的路径上将它设置为失败处理器(9)来使用它。","etc","event","eventbu","eventbus('http://localhost:8080/eventbus');","eventbus('http://localhost:8080/eventbus',","eventbus.j","express","facebook","facebookauth","fail","failureroutingcontext.response();","failureroutingcontext.statuscode();","fals","false。","fanci","fat","favicon.ico","faviconhandl","file","fileupload","findbooks(ar","formloginhandl","found","found)","foursquar","foursquareauth","freemark","freemarker:3.4.1。通过这个方法来创建","freemarker：io.vertx:vertx","function()","function(e)","function(error,","futur","future。这个特性可以用于定制您自己的消息过滤器、细粒度的授权或指标收集。","get/put/delet","getacceptablecontenttyp","getbodi","getbodyasjson；如果您知道它的类型是字符串，您可以使用","getbodyasstring；否则可以通过","getcooki","getrawmessag","get、post、put","github","github\");","githubauth","githubauth.create(vertx,","googl","google\");","googleauth","gradle（在","gradle（在您的","handlebar","handlebars:3.4.1。通过这个方法来创建","handlebarstemplateengine.create();","handlebars：io.vertx:vertx","handler","handler\").handler(ctx","handler\");","handler：处理器，某些特定的地方未翻译","happened!\");","head","header","headers);","header：消息头","heartbeatinterv","hello","here!!!\");","host","html","http","http://cdn.jsdelivr.net/sockjs/0.3.4/sockjs.min.js。","http://localhost:8080","https://myserver.com/callback。这是您的处理器的第二个参数。至此，您完成所有必须的配置，只需要通过","https://myserver.com:8447/callback。注意，端口号可以不使用默认值。","httpserver","httpserverrequest","httpserverrespons","httpserverresponse，还包含了各种用于简化","http基本认证","http基础认证是适用于简单应用的简单认证手段。","http，对于一部分应用来是足够的。","id","ifram","inboundpermit","inboundpermitted.setrequiredauthority(\"place_orders\");","inboundpermitted1","inboundpermitted2","inboundpermitted3","index.html。可以通过","insertjsessionid","instagram","instagramauth","int","integ","io.vertx","io.vertx.ext.auth.prng.algorithm","io.vertx.ext.auth.prng.seed.bit","io.vertx.ext.auth.prng.seed.interv","isauthent","jade","jade4j","jade:3.4.1。通过这个方法来创建","jar","jar）里进行分发。","java","javascript","javascript），当消息发送时，vert.x","js","jsessionid，这样负载均衡器可以保证","json","json.stringify(message));","jsonobject","jsonobject()","jsonobject().put(\"action\",","jsonobject().put(\"header1\",","jsonobject().put(\"keystore\",","jsonobject().put(\"sub\",","jsonobject().put(\"wibble\",","json，您可以使用","jul","jwt","jwtauth","jwtauth.create(vertx,","jwtoptions()));","jwtoptions());","jwt，oauth","keycloak","keycloakauth","lambda","languag","larg","last","level","libraryurl","linkedin","linkedinauth","listproductsauthhandl","listproductsauthhandler.addauthority(\"list_products\");","load","localhost）。","localsessionstor","localsessionstore.cr","localsessionstore.create(vertx);","localsessionstore.create(vertx,","loggerformat。","loggerhandler。","loop","mailchimp","mailchimpauth","mainrout","mainrouter.mountsubrouter(\"/productsapi\",","mainrouter.route(\".*\\\\.templ\").handler(mytemplatehandler);","mainrouter.route(\"/static/*\").handler(mystatichandler);","map","map来实现，并包含了一个用于清理过期会话的回收器。","match","maven","maven（在","max","maxbytesstream","messag","message)","message:","method","method。","method，您可以使用","method，您可以调用","micro","mime","minutes.","modifi","modified、date。","mount：挂载","msdn。","multipart","mvel","mvel:3.4.1。通过这个方法来创建","netsocket","new","news.europe,","news.usa,","next","next，则下一个匹配的","node.j","notfound","npm","null;","oauth","oauth2","oauth2.addauthority(\"profile\");","oauth2.setupcallback(router.get(\"/callback\"));","oauth2.setupcallback(router.route());","oauth2auth","oauth2auth.create(vertx,","oauth2authhandl","oauth2authhandler.create(authprovider,","oauth2authhandler.create(provider,","oauth2clientoptions()","oauth2flowtype.auth_code,","obj","onopen","option","options);","order","origin","outboundpermitted1","outboundpermitted2","param","param0","param1","path","pebbl","pebble:3.4.0","pebble：io.vertx:vertx","permittedopt","permittedoptions().setaddress(\"demo.ordermgr\");","permittedoptions().setaddress(\"demo.orderservice\");","permittedoptions().setaddress(\"demo.persistor\")","permittedoptions().setaddress(\"demo.someservice\");","permittedoptions().setaddress(\"ticker.mystock\");","permittedoptions().setaddressregex(\"news\\\\..+\");","permittedoptions().setmatch(new","ping","pom.xml","pool","post","preferredlocal","pretti","prng","produc","productid","producttyp","protect","provid","provider。例如一些支持角色/权限的模型，另一些可能是其他的模型。","provider。完整的","proxi","publish","pug。","put","q","q=0.7,","q=0.9,","qualiti","rang","rawmessag","rawmessage.put(\"headers\",","rc","rc.acceptablelanguages())","rc.fail(ar.cause());","rc.preferredlocale());","rc.response().end(\"bonjour!\");","rc.response().end(\"hello!\");","rc.response().end(\"hola!\");","rc.response().end(\"olá!\");","rc.response().end(\"sorri","rc.response().end(\"welcom","rc.response().end();","rc.response().end(tojson(ar.result()));","rc.response().end(toxml(ar.result()));","rc.response().putheader(\"cont","rc.response().write(productjson);","rc.user().principal().getstring(\"somekey\");","rc.user().principal().getstring(\"sub\");","re","readstream","receiv","redirect","redirectauthhandl","redirectauthhandler.create(authprovider);","regist","remov","removecooki","render","request","request.response();","rerout","res.result();","resourc","resource!\");","respons","response.end(\"hello","response.putheader(\"cont","response.setchunked(true);","response.setstatuscode(statuscode).end(\"sorry!","response.write(\"route1\\n\");","response.write(\"route2\\n\");","response.write(\"route3\");","response.write(somejson).end();","response.write(whatever).end();","responsecontenttypehandl","rest","restapi","restapi);","restapi.delete(\"/products/:productid\").handler(rc","restapi.get(\"/products/:productid\").handler(rc","restapi.put(\"/products/:productid\").handler(rc","return;","rfc6750","rout","route.failurehandler(frc","route.failurehandler。","route.handler(routingcontext","route.pathregex(\"\\\\/([^\\\\/]+)\\\\/([^\\\\/]+)\").handler(routingcontext","route1","route1.handler(routingcontext","route2","route2.handler(routingcontext","route2.order(","route3","route3.failurehandler(failureroutingcontext","route:","router","router.get(\"/\").handler(ctx","router.get(\"/api/books\").produces(\"application/json\").handler(rc","router.get(\"/api/books\").produces(\"text/xml\").produces(\"application/json\").handler(rc","router.get(\"/dynamic\").handler(routingcontext","router.get(\"/dynamic/\").handler(handler);","router.get(\"/dynamic/*\").handler(handler);","router.get(\"/localized\").handler(","router.get(\"/mi","router.get(\"/some/path\").handler(routingcontext","router.get(\"/some/path/\").handler(routingcontext","router.get(\"/some/path/*\").handler(routingcontext","router.get(\"/some/path/b\").handler(routingcontext","router.get(\"/some/path/other\").handler(routingcontext","router.get(\"/somepath/*\");","router.get(\"/somepath/path1/\");","router.get(\"/somepath/path2\");","router.get().failurehandler(ctx","router.get().handler(routingcontext","router.getwithregex(\".*foo\").handler(routingcontext","router.getwithregex(\".+\\\\.hbs\").handler(handler);","router.post(\"/login\").handler(formloginhandler.create(authprovider));","router.post(\"/some/endpoint\").handler(ctx","router.post(\"/some/path/uploads\").handler(routingcontext","router.route(\"/api/*\").handler(responsecontenttypehandler.create());","router.route(\"/eventbus\").handler(sockjshandler);","router.route(\"/eventbus/*\").handler(basicauthhandler);","router.route(\"/eventbus/*\").handler(sockjshandler);","router.route(\"/foo/\").handler(timeouthandler.create(5000));","router.route(\"/listproducts/*\").handler(listproductsauthhandler);","router.route(\"/login\").handler(ctx","router.route(\"/myapp/*\").handler(sockjshandler);","router.route(\"/private/*\").handler(basicauthhandler);","router.route(\"/private/*\").handler(redirectauthhandler);","router.route(\"/private/settings/*\").handler(settingsauthhandler);","router.route(\"/private/somepath\").handler(routingcontext","router.route(\"/protected/*\").handler(jwtauthhandler.create(authprovider));","router.route(\"/protected/*\").handler(oauth2);","router.route(\"/protected/somepage\").handler(ctx","router.route(\"/protected/somepage\").handler(rc","router.route(\"/some/path/\").handler(routingcontext","router.route(\"/some/path/*\");","router.route(\"/someotherpath\").handler(routingcontext","router.route(\"/somepath/blah\").handler(routingcontext","router.route(\"/somepath/blah/\").handler(routingcontext","router.route(\"/static/*\").handler(statichandler.create());","router.route(\"some/path/\").handler(routingcontext","router.route()","router.route().blockinghandler(routingcontext","router.route().consumes(\"*/json\").handler(routingcontext","router.route().consumes(\"text/*\").handler(routingcontext","router.route().consumes(\"text/html\").consumes(\"text/plain\").handler(routingcontext","router.route().consumes(\"text/html\").handler(routingcontext","router.route().handler(bodyhandler.create());","router.route().handler(cookiehandler.create());","router.route().handler(corshandler.create(\"vertx\\\\.io\").allowedmethod(httpmethod.get));","router.route().handler(csrfhandler.create(\"abracadabra\"));","router.route().handler(rc","router.route().handler(routingcontext","router.route().handler(sessionhandler);","router.route().handler(sessionhandler.create(localsessionstore.create(vertx)));","router.route().handler(statichandler.create());","router.route().handler(usersessionhandler.create(authprovider));","router.route().handler(virtualhosthandler.create(\"*.vertx.io\",","router.route().method(httpmethod.post).method(httpmethod.put);","router.route().method(httpmethod.post);","router.route().path(\"/some/path/\");","router.route().path(\"/some/path/*\");","router.route().pathregex(\".*foo\");","router.route().produces(\"application/json\").handler(routingcontext","router.route().produces(\"application/json\").produces(\"text/html\").handler(routingcontext","router.route(httpmethod.post,","router.route(httpmethod.put,","router.router(vertx);","router.routewithregex(\".*foo\");","router。","router。因此，您可以包含若干级别的","router。在这之后，我们创建了一个没有匹配条件的","router。这也有利于您在多个不用的应用中通过设置不同的根路径来复用处理器。","router）。sub","router，那么例如","router：","router：路由器","route。","route。停用的","route。您可以使用正则表达式来实现，但更简单的方式是在声明","route的流程。","route，并且","route，并且会接收到参数","route，然后将请求传递给这个","route，这个","route：路由","routingcontext","routingcontext.addcookie(cookie.cookie(\"othercookie\",","routingcontext.fail(403);","routingcontext.fileuploads();","routingcontext.get(\"foo\");","routingcontext.getacceptablecontenttype();","routingcontext.getcookie(\"mycookie\");","routingcontext.next());","routingcontext.next();","routingcontext.put(\"foo\",","routingcontext.put(\"request_path\",","routingcontext.put(\"session_data\",","routingcontext.request().getparam(\"param0\");","routingcontext.request().getparam(\"param1\");","routingcontext.request().getparam(\"productid\");","routingcontext.request().getparam(\"producttype\");","routingcontext.request().path());","routingcontext.reroute(\"/some/path/b\");","routingcontext.response().end();","routingcontext.response();","routingcontext.session().data());","routingcontext.session();","routingcontext.user()","routingcontext.vertx().settimer(5000,","routingcontext，这个实例会被传递到所有处理这个请求的处理器上。","rubi","runtimeexcept","runtimeexception(\"someth","salesforc","salesforceauth","second)","send","sent/published/registered/unregist","server","server.listen(8080);","server.requesthandler(request","server.requesthandler(router::accept).listen(8080);","service.dosomethingthatblocks();","service：微服务","session","session.get(\"age\");","session.put(\"foo\",","session.remove(\"myobj\");","sessionhandl","sessionhandler.create(store);","sessionstor","sessiontimeout","set","setaccess","setaddress","setaddressregex","setbodylimit","setcacheentrytimeout","setcachingen","setdirectorylist","setdirectorytempl","setexpectmultipart(true)。","setfilesreadonli","setincludehidden","setindexpag","setmatch","setmaxagesecond","setmaxcaches","setmergeformattribut","setrequiredauthor","settingsauthhandl","settingsauthhandler.addauthority(\"role:admin\");","setupcallback","setwebroot","sha1prng","sharing）是一个安全机制。该机制允许了浏览器在一个域名下访问另一个域名的资源。","shopifi","shopifyauth","sinatra","slf4j。详见","snapshot。通过这个方法来创建","sock","sock.close();","sock.onclos","sock.onmessag","sock.onopen","sock.send('test');","socket","socket_clos","socket_cr","socket_iddl","socket_idl","socket_p","socket：套接字","sockj","sockjs('http://mydomain.com/myapp');","sockjshandl","sockjshandler.bridge(new","sockjshandler.bridge(options);","sockjshandler.bridge(options,","sockjshandler.cr","sockjshandler.create(vertx);","sockjshandler.create(vertx,","sockjshandler.sockethandler(sockjssocket","sockjshandleropt","sockjshandleroptions().setheartbeatinterval(2000);","sockjssocket","sockjssocket.handler(sockjssocket::write);","sockjs。","somecooki","somecookie.getvalue();","somekey","soundcloud","soundcloudauth","speak:","statichandl","statuscod","store","store1","store2","store3","string","stripe","stripeauth","sub","switch","templ","templat","templateengin","templatehandl","templatehandler.create(engine);","templatehandler。这个处理器会根据","text/html","text/html;q=0.8,","text/html。","text/html。这也是可以配置的。","text/html，但会更倾向于","text/html，因为其具有更高的","text/html，它需要提供","text/plain","text/plain,","text/plain;","thesubject","throw","thymeleaf","thymeleaf:3.4.1。通过这个方法来创建","thymeleaf：io.vertx:vertx","tid","time","time:","timeouthandl","title=","today\");","todo","token","tools，参数","transport","transport，例如","true","true。","twitter","twitterauth","type","type\",","type`","types）的路由","types：互联网媒体类型","type。因此，您可以很容易地使用同一个处理器来提供不同类型的数据：","type）。","type）：","type：","unregist","upload","uploads。","uri","uri。在这种情况下它只会匹配路径和该路径一致的请求。","uri。由于我们创建的桥接器是以","url","url。用法很简单，只需要为这个处理器提供一个路由(route)，其他的配置都会自动完成。一个典型的情况是您的","url，则您的输入类似于","user","uuid，因此它是无法推测的(6)。","valu","value\"),","var","variabl","vert.x","verticl","vertx","vertx.clusteredvertx(new","vertx.createhttpserver();","vertx.disablefilecach","vertx.executeblock","vertxoptions().setclustered(true),","web","web!\");","web:3.4.1'","web:3.4.1:client'","webroot","webroot/css/mystyle.css。","webroot/css/mystyle.css。这意味着您可以将所有的静态资源打包到一个","webroot。","websocket","websocket、event_source、html_file、json_p、xhr。","websocket。","web。","web：","worker","world","world!","world!\");","writestream","www","www.vertx.io。","x","xhr。服务器端返回一个响应之后，客户端一旦接受了响应，会立刻再发一个","xsrf","xsrf。它是一种可以再未授权的网站获取用户隐私数据的技术。vet.x","yoke","{","{\"vertxbus_ping_interval\":","{name:","||","}","}));","}).blockinghandler(ctx","});","};","“armadillos”","”漂亮“","一个","一个路径为","一些","一些处理过程","一旦您获取到了","一般来说，consum","一词同时具有名词和动词的含义。为了避免混淆，原文中所有使用名词的地方都统一按照专有名词","一词没有找到合适的方式来描述，译为了","一词的消息：","上。","上。您需要确保会话处理器在您的应用处理器之前被执行。","上。这个处理器用于处理","上下文数据","上也可以挂载其他的","上创建","上启用","上寻找","上执行的所有阻塞式处理器的执行是顺序的，也就意味着只有一个处理器执行完了才会继续执行下一个。","上注册了一个服务，用于访问和删除数据。但我们并不希望恶意的客户端能够通过这个服务来操作数据库中的数据。并且，我们也不希望客户端能够监听所有","上注册会话处理器","上添加","上的例子：","上的地址。","上，它会使用一个","上，这个例子使用了","下面例子中的失败处理器只会在路由路径为","下面定义了如何允许服务端向客户端发送消息","下面是一个使用","下面是一个例子：","下面的例子中的","下面的例子展示了如何配置并处理","下面的例子展示了这个过程：","下面的例子设置了一个超时处理器。对于所有以","不仅可以在多个","不允许在模板中随意地调用对象的方法，因此我们不能像对待其他模板引擎一样将路由上下文传递到引擎里并让模板来识别它。","不是一个容器，您可以只使用您需要的部分。","不能够很容易的处理","个步骤：","中包含","中找到，简单来说您会像这样使用：","中插入一个","中查找文件","中标准的","中注入一个","中的线程而不是","中第一次找到一个资源时，会将它提取到一个磁盘的缓存目录中以避免每一次都重新提取。","中英对照表","中设置实际的会话数据，这个","中，该","为","为了解决这个问题，sockj","为桥接器配置哪些消息允许通过是很容易的。","为若干流行的模板引擎提供了开箱即用的支持，通过这种方式来提供生成动态页面的能力。您也可以很容易地添加您自己的实现。","主要针对轮询方式的","之前执行","之前执行，可以将其指定为负值。","之前执行：","之前，需要为您的构建工具在描述文件中添加依赖项：","之后，我们为这个","之后，我们告诉服务器监听","之间的差异等）。本着翻译准确的原则，本译文没有进一步展开描述。","也即","也可以匹配多个精确的值（mime","也可以在创建","也可以在失败处理器中转发。由于转发的性质，在这种情况下，当前的状态码和失败原因也会被重置。因此在转发后的处理器应该根据需要生成正确的状态码，例如：","也需要加载","事件。","事件。(10)","事件。延时时间由这个配置决定。默认的服务端会在","事件。注意，setpingtimeout(5000)","事件可能是以下的某一种类型：","事件对象同时是一个","仅当用户已登录并且拥有权限","仅当用户已经登录并且包含","仅当需要通过多个处理器输出响应时才需要","从一个处理器捕捉到异常时会标记一个状态码为","从代码中可以看到，如果一个到达的请求包含路径","从会话中删除值","从会话中获取值","从路径中提取参数","代码可以发送任何消息到任何的服务端处理器或其他所有浏览器上。","令牌来作为访问令牌。这对于需要混合基于客户端的授权和基于","以","以上就是如何在您的服务器上绑定处理器","以下","以下是一个使用","以下是一个例子，一个处理器设置了一些数据，另一个处理器获取它：","以下是一个例子：","以下是一个查询和添加","以下是一个简单的路由示例：","以下是一些创建","以下是例子：","以下是操作会话数据的例子：","以下的例子定义了一个应用，该应用的不同部分需要不同的权限。注意，权限的含义取决于您使用的的","以下路径的请求都会调用这个处理器:","以执行后续的处理。","任何发生的事件都会被传递到这个处理器。事件由对象","会一步一步检查每一个","会使用","会使用当前工作目录的子目录","会匹配任何","会匹配所有","会匹配所有到达这个服务器的请求。","会发送一个基本的","会变得很麻烦。可以通过在","会在","会在响应里设置这些消息头：cach","会声明一个","会将状态消息替换为状态码的默认消息。","会将资源的最后修改日期缓存在内存里，以此来避免频繁地访问取磁盘来检查修改时间。","会查找模板","会检查每一条输入许可。如果存在匹配，则消息可以通过。","会检查每一条输出许可。如果存在匹配，则消息可以通过。","会每隔","会给于警告。","会自动设置响应的","会被传递到失败处理器里，失败处理器可以通过获取到的错误或错误编码来构造失败的响应内容。","会被赋值为其被添加到","会话","会话中的键的类型必须是字符串。本地会话存储的值可以是任何类型；集群会话存储的值类型可以是基本类型，或者","会话处理器会创建会话","会话处理器会自动从会话存储中查找会话（如果没有则创建），并在您的应用处理器执行之前设置在上下文中。","会话存储","会话存储持有一个伪随机数生成器（prng）用于安全地生成会话标示。prng","会话永远转发到正确的服务器上。默认值为","会话维持了","会话超时","会返回列表的第一个元素。","会返回客户端能够理解的排序好的语言列表。","会配置一个正确的","但不包括:","但不包括：","位的熵作为种子。这个策略可以通过系统属性来设置：","作为","作为前缀的，因此我们需要将","作为根目录。可以通过","作为结尾。","使用","使用了","使用会话","使用会话，vert.x","使用的","使用的东西。","使用这个处理器涉及","使用阻塞式处理器","例如","例如对于","例如您可以提供一个失败处理器只处理在某个路径上发生的失败，或某个","例如，下面的","例如，对于一个路径为","例如，您可能在event","例子忽略了","保护","值。","值为","值来表示权重。q","值（默认值为","值，或者使用","允许","允许向客户端发送地址为","允许向客户端发送地址以","允许客户端向地址","允许您向令牌中添加任何您需要的信息，只需要在创建令牌时向","允许该处理器为您处理回调地址","关于","关于如何编写","具有不同的会话处理机制。sessiontimeout","内容协商","内容协商(2)","内置的一个","写入响应并结束处理","决定路由一个请求到匹配的","出来继续等下一个消息。如果超过了默认的","函数处理。","分钟。","分钟使用一个新的","分钟发送一个","分隔的","列举目录","则您可以配置一个","创建。如果您需要完整的控制处理器的执行顺序（例如您期望它在处理链中首先被执行），您也可以先创建这个","创建了一个默认的集群会话存储","创建会话处理器","创建认证处理器","初始化","删除产品","到","到目前为止，通过上述的路由机制您可以顺序地处理您的请求，但某些情况下您可能需要回退。由于处理器的顺序是动态的，路由上下文并没有暴露出任何关于前一个或后一个处理器的信息。唯一的方式是在当前的","包里。","匹配对应","协议。","协议的","协议的安全路由。这个处理器简化了获取","协议的语义，而不至于崩溃并断开","占位符由","即","参数中添加数据即可。这样做服务器上不存在任何的会话状态，您可以在不依赖集群会话数据的情况下对应用进行扩展。","参考这里。","发起了重载操作，则会因为验证错误而请求失败。","发送到服务器），当消息到达时，vert.x","发送消息","变量来访问路由上下文","另一种您可以访问上下文数据的方式是使用","只匹配指定的","只是在服务器上查找实际的会话数据时使用的标示。这个标示是一个通过安全的随机过程生成的","只有","只要提供商被配置为支持","可以发送或发布消息，或注册处理器来接收消息。","可以在","可以在创建会话处理器时配置超时时间。默认的超时时间是","可以将","可以把它想象成一把构建现代的、可伸缩的","可以持有一个与之关联的处理器用于接收请求。您可以通过这个处理器对请求做一些事情，然后结束响应或者把请求传递给下一个匹配的处理器。","可以提供哪些","可以根据请求中的","可以访问","可以通过","可以通过占位符声明路径参数并在处理请求时通过","可以通过参数","可以通过提供值为","合并表单属性","名称创建了一个本地会话存储","名称创建了一个集群会话存储","后续的的","向会话中设置值","向响应里写入了数据并结束了响应。","向响应里写入了数据，5秒之后","向响应里写入了数据，再5秒之后","启用和停用","和","和上文一样，我们创建了一个","和参数名构成。参数名由字母、数字和下划线构成。","和设置处理器处理请求一样，您可以设置处理器处理路由过程中的失败。","响应。","响应。浏览器会显示一个登录窗口并提示用户输入他们的用户名和密码。","响应时间处理器","回收的周期可以通过","回调，因此您不需要处理授权服务器的响应。一个很重要的事情是，来自授权服务器的响应只有一次有效。也就是说如果客户端对回调","回顾","因为其具有更高的","图标可以指定为文件系统上的某个路径，否则","在","在上述例子中，如果您发送一个包含如下","在上述的例子中，route1","在上述的例子中，如果一个","在上面的例子中，如果一个请求的路径为","在上面的例子里，响应中会包含：","在下面的例子中处理器会匹配所有","在下面的例子里，我们拒绝掉了所有经过桥接器并且包含","在下面这个例子中会被路径为","在以下的例子中，所有路径以","在使用","在匹配时会被忽略。","在响应完成后会话会自动回写到存储中。","在域名","在处理这个错误时，routingcontext","在客户端","在客户端通过使用","在您的处理器中，您可以通过","在您的应用中处理认证","在服务器上创建","在消费时用同样的方式：","在设置认证处理器时可以指定一系列访问资源时需要的权限。","在请求的生命周期中，您可以通过路由上下文","在这个例子中，rout","在这个例子中，第一件事是创建了一个","在这之后，浏览器会重新发送这个请求，并将用户名和密码以","在这种情况下这个","在这种情况下，如果服务器可以同时提供","在这种情况下，如果请求中包含了消息头","在这种认证方式下，","在连接打开之前，我们什么也做不了。当它打开后，会回调","在顺序","基于","基于客户端可接受媒体类型（mime","基于正则表达式的路径匹配","基于正则表达式的路由","基于精确路径的路由","基于请求媒体类型（mime","基于路径前缀的路由","基于通配符的子类型匹配也是支持的：","基于重定向的认证","基础认证","声明了消息体的","处理","处理。原文中的动词统一译为","处理会话","处理器","处理器。","处理器。这个","处理器会自动处理这个问题。","处理器器能够匹配到所有您需要这个功能的请求。","处理器直接使用了它读取到的数据进行回写：","处理器通过请求的消息头","处理器需要在会话处理器之前被执行。","处理文件上传","处理消息体","处理登录请求","处理请求并调用下一个处理器","处理请求消息体","处理跨域资源共享","处理静态资源","处理静态资源，例如您的登录页","大多数流式传输方式会在客户端保存响应的内容并且不会释放派发消息所使用的内存。这些传输方式需要定期执行垃圾回收。max_bytes_stream","大多数用户并不需要配置这些值，除非您发现应用的性能被","失败处理器和普通的处理器具有完全一样的路由匹配规则。","套接字","套接字创建时会发生该事件。","套接字处理器。该处理器用于将服务器端的","套接字处理器会被安装到","如何通过","如果一个请求在响应之前超时，则会给客户端返回一个","如果不需要缓存的消息头，可以通过","如果两个匹配的","如果会话在指定的周期内没有被访问，则会超时。","如果启用了缓存处理，则","如果在","如果在处理路径以","如果处理器随后调用了","如果尝试发送一个大于最大值的消息体，则会得到一个","如果您不关心执行的顺序，并且不介意阻塞式处理器以并行的方式执行，您可以在调用","如果您不在处理器里结束这个响应，您需要调用","如果您不希望事件继续处理，您可以用参数","如果您不能够保证这一点，那么就不要使用这个存储。这会导致请求被派发到无法识别这个会话的服务器上。","如果您不需要为隐藏文件提供服务，可以通过","如果您不需要这个行为，可以通过","如果您像上面的例子一样启动一个桥接器，并试图发送消息，您会发现您的消息神秘地失踪了。发生了什么？","如果您只关心用户偏好的语言，那么使用","如果您希望在回话中存储用户对象，以避免对所有的请求都执行认证过程，您需要使用会话处理器。确保它匹配了对应的路径，并且会在认证处理器之前执行。","如果您希望用户登出，您可以调用上下文的","如果您想要让一个路由匹配不止一个","如果您想覆盖路由默认的顺序，您可以通过","如果您想让","如果您没有在","如果您的文件在服务器运行过程中可能发生变化，您可以通过","如果您知道消息体的类型是","如果您要访问某些上下文数据里不存在的信息，比如请求的路径、请求参数或者会话等，您需要在模板处理器执行之前将他们添加到上下文数据里，例如：","如果您需要","如果您需要使用一个上述未列出的提供商，您也可以使用基本的","如果您需要在在桥接器发生事件的时候得到通知，您需要在调用","如果我们已经有了一个网站包含以下的","如果指定了","如果没有为请求匹配到任何路由，vert.x","如果没有指定","如果没有提供错误处理器，vert.x","如果用户没有提供，则返回空。","如果要使用集群会话存储，您需要确保您的","如果要限制请求消息体的大小，可以在创建消息体处理器时使用","如果认证处理器完成了授权和认证，它会向","如果请求访问虚机主机","如果这个","子路由","字段来提供资源的不同版本。","字段，并且消息中包含了","字段，并且消息的目标地址与","字段，并且消息的目标地址匹配了这个正则表达式，则匹配成功。","它也会在","它做了和上文使用","它提供了若干不同的传输方式，并在运行时根据浏览器和网络的兼容性来选择使用哪种传输方式处理。","它继承了","安全的桥接","完整的细节可以在","官方网站","定义一个失败处理器，上述的处理器发生错误时会调用这个处理器","定义了使用模板引擎的接口，当渲染模板时会调用","实例。当您完成了对消息的处理，您可以用参数","实例上。","实例中使用，还可以通过运行在浏览器里的","实例中有多个应用，并且希望不同的应用使用不同的","实例是集群模式的。","实例来创建认证处理器。auth","实例的情况，或者您正在使用粘性会话。也就是说您可以配置您的负载均衡器来确保所有请求（来自同一用户的）永远被派发到同一个","实例）","实例：","实现的","实际上不同的","实际的匹配过程如下：","客户端","客户端的地址","对于","对于一个正在接收响应的客户端连接，如果一段时间内没有动作，则服务端会发出一个","对于一个输入的消息（例如通过客户端","对于一个输出的消息（例如通过服务器端发送给客户端","对于任意以","对于大多数的应用，您应该不希望客户端的","对于没有提供原生的跨域通信支持的浏览器，会使用","对应的处理器（如果有）会被调用，以此类推。","对象。它不仅包含了","对象。您可以通过","对象。这也意味着您可以基于上下文里的任何信息来渲染模板，包括请求、响应、会话或者上下文数据。","对象。这是一个类似套接字的接口，您可以向使用","对象中的所有键值对，则匹配成功。","对象来使用重定向处理器。","对象来指定配置选项。","对象来描述，通过这个对象可以获得名称、文件名、大小等属性。","对象来表述的。您可以通过它来获取名称、值、域名、路径或","对象来进行配置。","对象来配置这个处理器的若干选项。","对象通过","对象，您可以通过编程的方式来使用它的相关方法为用户授权。","对象，然后将引用传进这个方法里。","对象：","导致协议运行的不完整。","将所有以","将数据回写","将规则添加到","就","已更名为","帮助您快速地配置基于","并且","并写入","并写入了","并查找会话信息，您不需要自己来实现。","库","库。它提供了类似","库来和","库，这个配置就是用于指定这个","应用、rest","应用、实时的（服务端推送）web","应用。","应用。应用类型的选择取决于您，而不是","应用中使用","应用的构建模块。","应用的瑞士军刀。","应用，我们需要在所有处理器里设置","应用，或任何类型的您所能想到的","建立连接，并发送/接收消息：","开头的文件）。","开头的消息（例如","开头的请求。","开头的请求会被保护","开头的请求路由到模板处理器上","开头的请求过程中发生错误，会调用这个处理器","开头的请求都会对应到","开头的请求都会调用这个处理器处理，例如：","开头的请求，route会被依次调用。","开头，`content","当","当一个处理器抛出异常，或者一个处理器通过了","当一个请求到达时，router","当向响应中写入响应消息头时，cooki","当基础认证处理器收到了这些信息，它会使用用户名和密码调用配置的","当客户端试图注册一个处理器时会发生该事件。","当客户端试图注销一个处理器时会发生该事件。","当开发非单页面应用，并依赖客户端来发送","当您创建会话存储之后，您可以创建一个会话处理器，并添加到","当您有很多处理器的情况下，合理的方式是将它们分隔为多个","当我们创建了处理器之后，我们设置了","当新的","当浏览器发送了携带消息头","当消息体处理器匹配到请求时，所有上传的文件会被自动地写入到上传目录中，默认的该目录为","当用户提交登录表单，服务器会处理用户认证。如果成功，则将用户重定向到原始的资源上。","当用户请求一个需要授权的资源，基础认证处理器会返回一个包含","当试图将一个客户端消息发布到服务端时会发生该事件。","当试图将一个客户端消息发送到服务端时会发生该事件。","当试图将一个服务器端消息发布到客户端时会发生该事件。","当该功能启用时，会根据客户端请求的消息头","当请求到达时，我们设置了响应的","当请求到达，访问了会话，并且在响应完成向会话存储回写会话时，会话会被标记为被访问的。","循环有点奇怪，我们必须按顺序选择正确的本地化方式","微服务，但我们不强制您必须把应用实现成这样。","您不能在普通的处理器里执行这些操作，所以我们提供了向","您不需要在处理器执行完毕时调用","您也可以在处理事件时修改原始的消息内容，例如修改消息体。对于从客户端发送来的消息，您也可以修改消息的消息头，下面是一个例子：","您也可以捕捉通过正则表达式声明的路径参数，下面是一个例子：","您也可以标记您的","您也可以用通配符匹配顶级的类型（top","您也可以通过","您可以使用","您可以使用消息体处理器","您可以使用特定的顺序值覆盖默认的顺序。如果您需要确保一个","您可以使用路径或者同时使用路径和方法来转发。注意，基于方法的重定向可能会带来安全问题，例如将一个通常安全的","您可以使用静态资源处理器","您可以在服务器端设置一个处理器，这个处理器会在每次客户端创建连接时被调用：","您可以对认证处理器配置访问资源所需的权限。","您可以执行这段代码，并打开浏览器访问","您可以用","您可以用不同的方式来组合上述的路由规则，例如：","您可以用模板处理器来渲染错误信息，或者使用","您可以通过","您可以通过依赖管理器来获取客户端库：","您可以通过将一个","您可以通过设置系统属性","您可以通过调用桥接器时传入的","您的应用处理","您的应用处理器","您的登录页需要","您经常需要为所有以某些路径开始的请求设置","您自己的应用处理器","您还需要配置用于处理登录页面的处理器，以及实际处理登录的处理器。我们提供了一个内置的处理器","您需要一个","您需要保证","您需要保证消息体处理器能够匹配到所有您需要这个功能的请求。","您需要在创建模板处理器时提供您需要使用的模板引擎的实例。","您需要在匹配的","您需要在您的项目中添加这些依赖来使用","您需要将表单的属性设置为正确的值。填充这个值唯一的办法是通过上下文来获取键","您需要手工提供所有关于您所使用的提供商的细节，但结果是一样的。","您需要提供一个会话存储对象来创建会话处理器。会话存储用于维持会话数据。","您需要通过","我们不会在会话","我们不知道用户的语言，因此返回这个信息：","我们会在本手册里讨论所有上述的特性。","我们会每隔一段时间发送一个心跳包，用来避免由于请求时间过长导致连接被代理和负载均衡器关闭。默认的每隔","我们创建了一个","我们可以将这个","我们来假设您希望所有路径为","我们首先需要一个","或","或其他类型的静态资源。","或可序列化对象。因为这些值需要在集群中进行序列化。","或可称之为不可枚举的。可防止碰撞攻击。","或完整的域名","或者","或者可以在创建这个","或者在创建","或者执行密集计算。","所有","所有以下路径的请求都会调用这个处理器:","所有的","所有的请求都会调用这个处理器处理","所有访问根路径","所有路径为","所有路径以","所有这些对您是透明的，您只需要简单地使用类似","所表示的类型来返回相应的结果。","执行","执行上传处理","执行某些同步的耗时操作","执行某些处理","执行某些操作","执行某些操作...","执行某些阻塞操作","扩展到客户端的","拒绝该消息","挂载到另一个","指","指允许同一个","指向这里。","指定了一个处理器，所有的请求都会调用这个处理器处理。","指定的","指通过","捕捉路径参数","换句话说，桥接器的行为像是配置了","授权","授权处理器","授权通过权限来保护资源不被未为授权的用户访问。","排序的语言偏好列表的方法。","接口数量的增长，设置","接口，因此您可以将它套用（pump）到其他的读写流上。","接收","接收和解析","描述了处理器能够处理的","提供不止一种","提供了一个内置的叫做","提供了一个处理器","提供了一个开箱即用的处理器","提供了一个开箱即用的处理器来提供静态的","提供了一个用于记录","提供了一个超时处理器，可以在处理时间过长时将请求超时。","提供了一系列底层的功能用于操作","提供了两种开箱即用的会话存储实现，您也可以编写您自己的实现。","提供了开箱即用的会话(session)支持。","提供了每一种模板引擎的配置。","提供了若干开箱即用的处理器来处理认证和授权。","提供了若干开箱即用的实现：","提供商会需要您来提供您的应用的","提供商需要作出少许的修改。为此，vertx","提供的一个简单的客户端","提供网页图标","操作","支持","支持服务端模板渲染，包括以下开箱即用的模板引擎：","支持本地会话和集群会话","支持请求超时","文件。这意味着您可以将图标打包到您的应用的","文件上传","文件中）：","文件里）","文件（或","文档","文档。","文档，同时您又希望他可以作为","方法","方法。","方法。您可以在之后您需要的时间点调用它：","方法。示例代码使用了","方法为每一个","方法为每一个路由指定一个","方法从上下文中获取任何对象。","方法向上下文设置任何对象，使用","方法在您的处理器中获取到该对象。","方法声明的值进行比较。","方法多次：","方法将其禁用。","方法引用","方法指定","方法指定了","方法时将","方法时提供一个处理器。","方法来停用一个","方法来删除数据。","方法来向会话中设置数据，通过","方法来启动它即可。","方法来启用。","方法来定期刷新生成器的种子，在","方法来找出真正被接受的","方法来指定","方法来指定对于一个登录用户，需要具有哪些权限才允许访问这个消息。","方法来获取数据，通过","方法来获得事件的类型，通过","方法来获得消息原始内容。","方法来设置。","方法来设置内存缓存的最大数量。通过","方法来设置缓存的过期时间。","方法来设置阻塞式处理器。下面是一个例子：","方法来访问会话对象。","方法来选择适当的","方法来配置。","方法来重新启用它。","方法来销毁一个会话。这会将这个会话同时从上下文和存储中删除。注意，在删除会话之后，下一次通过浏览器访问并经过会话处理器处理时，会自动创建新的会话。","方法获取：","方法让其他匹配的","方法设置文件的只读属性为","方法设置的模板来渲染文件列表。","日志、log4j","日志来记录，或者也可以配置为","时和路径一起指定：","时指定。","时指定正则表达式：","时的序号，例如第一个","时间戳被更新时会发生该事件。","是","是一个客户端的","是一个顶级的","是一系列用于基于","是临时的，当浏览器关闭时会被删除。","是使用","是否匹配，如果匹配则对应的处理器会被调用。","是您可以避免跨站点的伪造请求。","是独立于存储的，这意味着对于给定的存储","暴露的","更改","替代方案是，可以使用","最后执行。","最简单的使用模板的方式不是直接调用模板引擎，而是使用模板处理器","有很多关于这方面的细节。","有相同的顺序值，则会按照添加它们的顺序来调用。","服务器。","服务器会提供一个简单的页面（在目标域名上）并放置在一个不可见的","服务器基本相同的事情，只是这一次换成了","服务器的请求处理器，使所有的请求都通过","服务器运行在同一个域名下，因此不用担心跨域的问题。这个","服务器，暂不涉及","服务器，然后创建了一个","服务的静态资源。这对于在生产环境中通过","服务端","服务端建立连接。您不必关注浏览器或网络是否真的是","服务端的基本概念是很有价值的。","服务端，并设置了一个请求处理器。所有的请求都会调用这个处理器处理。","本地会话存储","本地会话存储基于本地的共享","本地化","权限","权限来列举产品","来为您处理","来人工指定会话被访问。","来使用会话功能是明智的。如果您尝试直接通过","来创建到","来创建认证处理器的例子：","来删除","来启用会话功能，并确保它能够在应用逻辑之前执行。","来在磁盘上缓存通过","来处理。","来处理登录的问题。","来处理请求（如果有）。","来完成这个","来定义","来实现您的应用是非常必要的。","来实现的。它提供了一系列和服务器端的","来实现，例如：","来指定消息体的最大字节数。这对于规避由于过大的消息体导致的内存溢出的问题很有用。","来授权：","来描述。","来提供网页图标。","来提供诸如","来提取文件是低效的。","来支持","来构建经典的服务端","来查找会话，因此您还需要包含一个","来标示一个会话。会话","来添加","来禁用。","来禁用文件缓存。","来结束这个","来维护任何您希望在处理器之间共享的数据。","来获取","来获取。","来获取请求的消息体，限制消息体大小，或者处理文件上传。","来获得。","来认证用户。如果认证成功则该处理器会尝试用户授权，如果也成功了则允许这个请求路由到后续的处理器里处理。否则，会返回一个","来让您在","来访问上下文数据。","来访问受保护的资源。","来进行匹配，并支持基于通配符的模式匹配。例如","来进行授权，可以","来进行通信。sockj","来通过名称获取","来避免这个问题：","来部署的服务是很重要的。因为每一次都通过","来配置。","来配置匹配规则，指定哪些输入和输出的流量是允许通过的。","来验证它是否如预期的一样工作。","构建","构造函数中的参数是连接到","构造函数的第二个参数是告诉","某些情况下失败处理器会由于使用了不支持的字符集作为状态消息而导致错误。在这种情况下，vert.x","某些时候也被称为","某些时候您可能需要在处理器里执行一些需要阻塞","查找产品信息","标示的请求，会使用通过","格式的消息。","桥接","桥接器事件","桥接器可以使用","模板中可以通过","模板引擎","模板引擎时，如果不指定模板文件的扩展名，则默认会查找扩展名为","模板引擎的实例：io.vertx.ext.web.templ.freemarkertemplateengine#create()。","模板引擎的实例：io.vertx.ext.web.templ.handlebarstemplateengine#create()。","模板引擎的实例：io.vertx.ext.web.templ.jadetemplateengine#create()。","模板引擎的实例：io.vertx.ext.web.templ.mveltemplateengine#create()。","模板引擎的实例：io.vertx.ext.web.templ.pebbletemplateengine#create()。","模板引擎的实例：io.vertx.ext.web.templ.thymeleaftemplateengine#create()。","模板引擎的实现没有内嵌在","模板引擎：io.vertx:vertx","模板文档。","模板，请参考","欢迎页","正则表达式同样也可用于在路由时匹配","此处是公开的，不需要登录","此处需要登录","此时响应内容会是：","每一个上传的文件会被自动生成一个文件名，并可以通过","每一个上传的文件通过一个","每一个匹配规则对应一个","每一个被路由的请求对应一个唯一的","每一个被静态资源处理器处理的请求都会返回文件系统的某个目录或","注意，","注意，如果您需要在一个阻塞处理器中处理一个","注意，对于持有令牌的客户端，唯一需要做的是在","注意，所有发生的这些没有线程阻塞。","注意，这两个处理器应该只能通过","注释","流式请求所需要发送的最小字节数。超过这个值则客户端需要打开一个新的请求。将这个值设置得过小会失去流式的处理能力，使这个流式的传输方式表现得像一个轮训的传输方式一样。默认值是","流程的细节、sockj","消息。","消息。由于服务器端配置了期望每隔","消息体处理器也可以用于处理","消息体处理器默认地会合并表单属性到请求的参数里。","消息体的长度限制","消息在","消息头。假设我们要构建一个","消息头中匹配了不止一个","消息头为","消息头匹配","消息头可以包含多个用","消息头并提供了一些识别客户端偏好的语言，以及提供通过","消息头用于表示哪些","消息头的","消息头的值为","消息头的子类型为","消息头的请求：","消息头的部分响应。","消息头的顶级类型为","消息头表示客户端只接受","消息头设置为","消息头里。","消息授权","消息的原始内容是一个如下结构的","消息，因此会在服务器端触发","混合","添加一个","添加新的产品","添加消息头","然后结束了处理。","版本之间发生了变化，请检查变更日志。老版本的客户端仍然兼容，但新版本提供了更多的特性，并且更接近服务端的","状态码","状态码会是","状态码时，会执行路由的失败处理。","状态码通知浏览器使用本地的缓存资源。","环境里您使用","环境里您需要通过","现在可以通过这种路径访问：/productsapi/products/product1234。","用于为用户提供认证和授权。vert.x","用户/角色/权限授权","用户需要登录，并被授权才能够访问消息。因此，您需要配置一个","用默认值创建一个集群会话存储","由于会话处理器需要使用","由于它需要在所有异步执行之前处理请求的消息体，因此这个处理器要尽可能早地设置到","由于我们会在不同的处理器里写入响应，因此需要启用分块传输","由此，我们可以围绕浏览器和服务器构建一个庞大的分布式","登录表单数据","的","的、开箱即用的错误处理器来渲染错误页面。","的。默认情况下会使用最新发布的压缩版本","的一部分关键特性有：","的不同","的会话标示是不能够派发出存储","的会话标示的，因为他们具有不同的种子和状态。","的作用是当","的例子：","的值。这个键的名称也可以在初始化","的值为","的值会是","的值使其能在","的其他属性。","的具体实现：","的内容写作风格明显和前文不同，而且有些地方描述的很简略（例如","的匹配过程是精确的：","的取值范围由","的响应。","的响应拒绝访问。","的回调","的基本概念","的大多数特性被实现为了处理器（handler），因此您随时可以实现您自己的处理器。我们预计随着时间的推移会有更多的处理器被实现。","的套接字关闭时会发生该事件。","的套接字的","的套接字的空闲事件超过出事设置会发生该事件。","的客户端","的客户端库来建立连接。","的对象。","的库每隔","的应用创建这个处理器。您也可以在创建处理器时通过","的情况","的挂载点上来实现。挂载的","的授权","的授权功能来配置消息的访问授权。同时支持输入和输出。","的授权很有用。例如您的应用提供了一些受保护的","的接口。","的接口为您和","的提供商参考了","的操作，比如调用某个传统的阻塞式","的数据并把它桥接到服务器端的","的文件。","的文件上传。","的文档。","的时候指定任意的路径：","的核心概念之一。它是一个维护了零或多个","的框架","的流程。下面的例子用这个处理器实现了保护资源并通过","的消息","的消息.","的消息头","的特点，灵感来自于","的算法所影响。","的网站","的设计是强大的，非侵入式的，并且是完全可插拔的。vert.x","的详细信息。","的请求","的请求。例如：","的请求也是匹配的：","的请求会同时匹配两个","的请求会被定位到索引页。默认的该文件为","的请求会调用这个处理器","的请求调用。我们会忽略结尾的","的请求都需要认证控制。为了实现这个，您需要确保您的认证处理器匹配这个路径，并在您的应用处理器之前执行：","的请求，静态处理器会在该路径中查找文件","的路径时使用一个","的路由","的运行配置来启动您的应用时，如果您修改了文件，缓存的文件时不会被更新的。","的连接并发送和接收消息：","的配置和用法请参考","的错误。","的集合会自动被回写到响应里，这样浏览器就可以存储下来。","的顺序一致。","的顺序使其可以在","的默认值为","目录中查找模板文件。这是可以配置的。","目录：","确保所有请求都会经过","禁止访问","禁用磁盘文件缓存","秒","秒之后发出这个","秒内没有从客户端返回时触发","秒发送一个心跳包，可以通过这个设置来控制频率。","秒后自动超时。","秒后调用下一个处理器","秒收到一条","秒该会话没有收到新的请求，则会认为客户端断开了连接，会话过期。","端口（默认的主机名是","第二个参数是您提供给您的提供商的回调","等方法。下面是一个例子：","等概念，只是进程内的逻辑跳转。","等等。","等）","策略的防火墙。","类似的","类型。","类型。例如以下处理器可以提供","类型。则它会与通过","类型。在这种情况下，您可以使用","类型为","类型的响应。","类型的响应是客户端可接受的。","类型的表单数据，您需要首先使用一个非阻塞的处理器来调用","类型的请求。","类型追加一个","类型）：","类型，则可以为每一个","精确匹配，则匹配成功。","线程中同步执行生成随机数的过程。","线程来处理请求。","组件介绍","组合路由规则","经验法则是：当有效的回调执行时，通知客户端跳转到受保护的资源上。","结尾的","结尾的请求路由到模板处理器上","结束响应","结语","维护了一系列处理器，对应了一个虚构的","缓存有过期时间，在这个时间之后，会重新访问磁盘检查文件并更新缓存。","编写","编写的","编码的形式包含在请求的","网页图标处理器","而是指定了","而非","获取","获取整个集合。","获取最终匹配到的","获取请求的消息体","获取，`bar`","虚拟主机","虚机主机处理器","虚机主机处理器会验证请求的主机名。如果匹配成功，则转发这个请求到注册的处理器上。否则，继续在原先的处理器链中执行。","表单","表单里指定。为了解决这个问题，这个令牌的值也会通过表单属性来检查。这只会发生在请求中不存在这个消息头，并且表单中包含同名属性时。例如：","表示客户端会接受","表示客户端会无偏好地接受","被创建时","被消费。在这种情况下，一个","被称为子路由（sub","规范的生态来看，使用其他的","规范，使用","解析","认证/授权","认证处理器","认证处理器来处理登录和授权。例如：","让我们改变","让我们看一个","设置一个接收消息的回调函数","设置为","设置为只匹配指定的","设置了一个接收数据的处理器","设置了会话的过期时间为","设置了每一个","设置基础认证处理器","设置阻塞式处理器的能力。","访问。","访问。否则可能会引起由流量嗅探引起的会话劫持。","证书会以非加密的形式在","译者注：jade","该处理器","该处理器会将从接收到请求到写入响应的消息头之间的毫秒数写入到响应的","该处理器会返回渲染的结果，并默认设置","该存储将会话保存在内存中，并只在当前实例中有效。","该存储将会话保存在分布式","语法。","请求","请求中传输。因此，使用","请求中包含消息头","请求可能会成为","请求和响应之间传递。因此通过","请求和浏览器会话之间的关系，并提供了可以设置会话范围的信息的能力，例如一个购物篮。","请求失败时被调用：","请求日志","请求时，如果对应的资源在该日期之后没有修改过，则会返回一个","请求时，这个消息头没办法在","请求的响应里加一个独一无二的令牌作为","请求的处理器","请求的路径为","请求的路径来调用模板引擎。","请求都会调用这个","请求都会调用这个处理器","请求，并查找首个匹配该请求的","请访问","调用下一个匹配的","调用下一个处理器","调用处理器的参数是一个","调用对应处理器。","调用这个处理器的参数是一个","资源。您可以非常容易地编写静态的","超时处理器","跨域请求伪造","跨域资源共享（cors，cross","跨站点请求伪造","路径。","路径下挂载某些处理器","路径下的资源","路径开头的请求，都会在执行","路由。原文的最后几部分关于","路由顺序","路由（基于方法(1)、路径等）","转发","转发。此处有别于","运行环境里。","这个","这个例子做的第一件事是创建了一个","这个值会返回","这个参数用于禁用某些传输方式。可能的值包括","这个处理器会向所有的","这个处理器会在您的应用上绑定回调的","这个处理器会通过","这个处理器是","这个处理器能够处理范围请求。当客户端请求静态资源时，该处理器会添加一个范围单位的说明到响应的消息头","这个存储适用于您只有一个","这个存储适用于您没有使用粘性会话的情况。比如您的负载均衡器会将来自同一个浏览器的不同请求转发到不同的服务器上。","这个库也可以通过","这个正则表达式可以匹配路径类似于","这个路由器的调用规则和上面的例子一样","这个配置精确地定义了消息可以被发送到哪些地址。如果您需要通过精确的地址来控制消息的话，使用这个选项。","这个配置通过正则表达式来定义消息可以被发送到哪些地址。如果您需要通过正则表达式来控制消息的话，使用这个选项。如果指定了","这个配置通过消息的接口来控制消息是否可以发送。这个配置中定义的每一个字段必须在消息中存在，并且值一致。这个配置只能用于","这些是最基本的，下面我们来看一下更多的细节：","这些是通过","这会匹配所有路径以","这会将所有以","这允许您在应用的不同部分设置不同的失败处理器。","这可以被您自己实现的处理器处理，或者被我们提供的专用错误处理器（failurehandler）处理。","这可以通过向上文所述的匹配规则中加入额外的字段来指定该匹配需要哪些权限。","这在开发时会导致一个问题，例如当您通过","这将创建一个分布式的","这意味着您的","这意味着这个","这是一个例子，认证会由另一个","这是一个例子：","这是为了保证","这种","这适用于您在同一个","这适用于您在集群中有多个应用，并且希望不同的应用使用不同的","这里抛出一个","这里故意将请求处理为失败状态","这里是一个派发令牌的例子：","这里是一个简单的例子，使用了一个重定向认证处理器并使用默认的重定向","通过","通过一个挂载点挂载到主","通过内置的处理器","通过指定的","通过正则表达式捕捉路径参数","通过这个存储，您的会话可以被集群中的任何节点访问。","那么会匹配上面的","那样通过它来读写数据。它实现了","都会匹配","都会匹配。","配置","配置一个处理器用于颁发令牌（或依靠第三方）","配置回调处理器来接收","配置所需的权限","配置授权处理器来过滤请求","配置索引页","配置缓存","配置跟目录","配置需要的权限","里","里。在","里包含了正确的单位以及起始、终止位置，则客户端将收到包含了的","里来通知客户端它支持范围请求。如果后续请求的消息头","里的","里的文件。文件的根目录是可以配置的，默认为","里运行的代码和","里重启","里，例如：","里，您需要配置您的项目来访问它们。vert.x","重定向认证处理器","重定向认证处理器用于当未登录的用户尝试访问受保护的资源时将他们重定向到登录页上。","错误。","错误处理","错误页面处理器","阻塞式处理器和普通处理器的区别是","限制消息体大小","随着","隐藏文件","集群中共享访问。","集群会话存储","需要","需要的重定向握手，但可以提供令牌(11)。","静态文件服务，包括缓存逻辑以及目录监听","静态资源处理器可以用于列举目录的文件。默认情况下该功能是关闭的。可以通过","静态资源服务","非常适合编写","项目中提供了若干开箱即用的","默认会在","默认使用混合模式，阻塞式地刷新种子，非阻塞式地生成随机数(7)。prng","默认情况下在一个","默认情况下，vert.x","默认的","默认的会拒绝所有的消息。您需要告诉桥接器哪些消息是可以通过的。（例外情况是，所有的回复消息都是可以通过的）。","默认的没有消息体大小限制。","默认的路由的匹配顺序与添加到","默认的，rout","默认的，为了让浏览器有效地缓存文件，静态处理器会设置缓存消息头。","默认的，处理器会为隐藏文件提供服务（文件名以","默认的，如果不配置权限，那么只要登录了就可以访问资源。否则，用户不仅需要登录，而且需要具有所需的权限。","默认的，如果您的文件永远不会发生变化，则缓存内容会永远有效。","默认的，所有资源都以","默认的，模板处理器会在","默认的，请求会通过","（在您的","，例如：","，您也可以使用对应的","，执行某些处理"],"webclient/WebClient.html":["\"","\"/some","\"1024\";","\"another_param2_value\");","\"application/json\");","\"cooper\"),","\"cooper\");","\"dale\")","\"dale\");","\"foo\");","\"header","\"multipart/form","\"myserver.mycompany.com\",","\"param","\"param1_value\");","\"param3_value\");","\"param_value\")","\"with","'io.vertx:vertx","(ar.succeeded())","(fileres.succeeded())","+",".addqueryparam(\"param\",",".addqueryparam(\"som",".as(bodycodec.json(user.class))",".as(bodycodec.jsonobject())",".as(bodycodec.none())",".as(bodycodec.pipe(writestream))",".flatmap(u",".get(443,",".get(8080,",".getabs(\"https://myserver.mycompany.com:4043/som",".head(8080,",".map(httpresponse::bodyasstring);",".post(8080,",".put(\"firstname\",",".put(\"lastname\",",".putheader(\"an",".putheader(\"cont",".putheader(\"som",".rxsend()",".rxsend();",".rxsendstream(body);",".send(ar",".sendbuffer(buffer,",".sendform(form,",".sendjson(new",".sendjsonobject(new",".sendstream(filestream,",".sendstream(stream,",".setuseragent(\"mi",".ssl(true)",".subscribe(respons",".timeout(5000)","//","//发送head请求","03","15","15:54:14","1st","2nd","3.4.1","=",">","api","api自然组合成链式处理","api，此时您应当使用","app/1.2.3\");","application/x","ar","ar.cause().getmessage());","ar.result();","asyncfil","bodi","body);","bodyasxxx()","bodycodec","bodycodec.jsonobject","bodycodec.non","bodycodec.pip","client","client.get(8080,","client.getabs(u).rxsend())","client:3.4.1'","client会为您设置好传输泵以平滑传输流。如果流长度未知则使用分块传输（chunk","client使得发送","client使用vert.x","client可用","client可用与","client并未提供","client的回顾","client的目的并非为了替换vert.x","client请求发送之后，返回的结果将会被包装在异步结果","client配置选项继承自","client（web客户端）是一个异步的","client，请先加入以下依赖：","code\"","codec：响应体编解码器","codec：响应编解码器（编码及解码工具）","compil","content","copi","core","core中的","core的api，如您对此还不熟悉，请先熟悉","data\")","data：","depend","error","error.getmessage());","filelen","filelen)","filer","fileres.result();","filestream","files，即文件上传），该功能可能在将来版本中予以支持。","form","form.set(\"firstname\",","form.set(\"lastname\",","fs.open(\"content.txt\",","get.copy()","get.send(ar","getpayload();","get，options以及head请求没有请求体，可用以下方式发送无请求体的http","gradle（在build.gradle文件中）：","header","header\",","headers.set(\"cont","headers.set(\"oth","http","http/2","httpclient","httpclient。","httpclient，可用以下方式复用：","httpclient，而是基于该客户端，扩展并保留其便利的设置和特性，例如请求连接池（pooling），http/2的支持，流水线／管线的支持等。当您需要对","httprequest","httprespons","io.vertx","java","json.encod","jsonobject","jsonobject()","jsonobject：","json。","json体","json体的编码和解码","json对象","json：","length","length\",","mapper将","maven（在","multimap","multimap.caseinsensitivemultimap();","multipart/form","new","object），该方法会自动调用","observ","ok","old","openoptions(),","option","options);","options.setkeepalive(false);","param\",","pojo","pom.xml文件中）：","pump：泵（平滑流式数据读入内存的机制，防止一次性将大量数据读入内存导致内存溢出）","puthead","readstream","readstream（例如","readstream）：","request","request.addqueryparam(\"param1\",","request.addqueryparam(\"param3\",","request.headers();","request.putheader(\"cont","request.putheader(\"oth","request.setqueryparam(\"param2\",","request.uri(\"/som","requests（http请求）：","resp","respons","response.body();","response.bodyasjsonobject();","response.statuscode()","response.statuscode());","rxjava","rxjava的","send","sendbuff","sendform","sendjson","sendjsonobject","sendstream","sendstream：","sendxxx","singl","single.subscribe(resp","single.subscribe(respons","single>","single>，故单个","statu","string","system.out.println(\"receiv","system.out.println(\"someth","system.out.println(resp.body());","system.out.println(resp.statuscode());","timeout","transfer）。","type","type\",","uri\")","uri\");","uri?param1=param1_value¶m2=param2_value\");","url","urlencoded，您亦可将其设置为","user","user(\"dale\",","user.getfirstname()","user.getlastname());","value\")","vert.x","vertx","web","webclient","webclient.create(vertx);","webclient.create(vertx,","webclient.wrap(httpclient);","webclientopt","webclientoptions()","webclientoptions().setfollowredirects(false));","webclientoptions().setmaxredirects(5));","webclient：","websocket","went","writestream","wrong","www","{","{});","}","});","},","一般情况下，http","中。","中英对照表","之前的例子可写成","予以配置：","使用","使用http","使用web","例如用","便是一个","再次发送同样的请求","再次发送请求","创建web","制作web","原文上次编辑于2017","原文档","发送get请求","发送一次请求，并处理其响应，rx通常通过订阅触发各种响应","发送请求","另外web","可与其它rxjava","可用","可被多次订阅。","和","响应体编解码器对二进制数据流解码，以节省您在响应处理中的代码。","响应变得更加便捷，同时提供了额外的高级功能，例如：","响应编解码器","在java，groovy以及kotlin语言中，json对象可被解码映射成pojo：","在java，groovy以及kotlin语言中，您亦可使用","在请求uri中的参数将会被预填充","填充请求体","填充请求头","处理30x重定向","处理http响应","如已在程序中创建","如已知流的大小，可在http协议头中设置","如需使用vert.x","如需要发送请求体，可使用相同的api并在最后加上","客户端。","客户端将会执行最多达16次重定向，该参数亦可在","对vert.x","对象变得更加便捷：","对象，提供了增加、设置以及删除头属性操作的入口。http头的某些特定属性允许设置多个值。","将json映射成pojo","将会被订阅，其内容将会被用于请求中。","将响应定制成以下类型：","将结果解码为json对象","将结果解码为json对象：","属性","属性值为","并在最后发出成功或失败的信号。","废弃响应体。","当发送请求体为","当响应结果较大时，请使用","当响应被成功接收到之后，相应的回调函数将会被触发。","当您需要更改请求时，可用","当订阅时，bodi","您亦可使用配置选项来创建客户端：","您亦可通过","您可使用","您可使用以下方式填充请求头：","您可使用缺省设置创建一个","您可对每个请求单独设置：","您可用以下链式方式向请求uri添加查询参数","您可通过","或使用绝对路径：","提交表单","提供了原版api的响应式版本，rxsend","方法。响应体编解码器将响应结果压入","方法使用jackson的","方法写入头属性：","方法发送","方法发送http表单。","方法发送pojo（plain","方法发送一个缓冲体：","方法发送流式数据","方法发送相应的请求体。","方法可被重复多次调用，这使得配置以及重用","方法复制一份请求的拷贝：","方法将","方法将其转换成特定的类型","方法将响应写入流。","方法设置超时时间。","方法返回一个可被订阅的","无请求体的简单请求","时，应使用","映射为","映射成","是一个","普通字符串","最后，如您对响应结果不感兴趣，可用","有时候我们并不希望将所有数据一次性全部读入内存，因为文件太大或希望同时处理多个请求，希望每个请求仅使用最小的内存。出于此目的，web","有时您需要在请求体中使用json格式，可使用","服务器接收","欧洲中部时间","此处","此处可填入超时处理部分代码","此时post方法不会使用分块传输。","添加param1（参数1）","添加param3（参数3）","用flatmap将返回值内的链接作为参数传入lambda，在lambda中将其设置成发送请求，并返回single，在下一步订阅中予以触发","用post方法发送文件","用url编码方式提交表单","用分块方式编码提交表单","的一些基本概念。","相同方式配置https协议。","组件介绍","组件源码","组件示例","统一的错误处理","缺省情况下，提交表单的请求头中的","缺省状况下，响应以缓冲形式提供，并不提供任何形式的解码。","缺省状况下，客户端将会依照30x状态码自动重定向，您可使用","若无法预知响应内容类型，您依旧可以在获取结果之后，用","若请求在设定时间内没返回任何数据，则一个超时异常将会传递给响应处理代码。","获取到的","获取同样的请求","获取响应","表单提交","覆盖param1（参数1）同时新增param2（参数2）","覆盖param2（参数2）","警告：缺省状况下，响应会被完全缓冲读入内存，请用","警告：这种方式仅对响应结果为缓冲体有效。","设置请求uri将会自动清除已有的查询参数","请求以及从","请求参数的处理","请求和响应做细微粒度控制时，您应当使用","请求和响应泵","请注意：","请注意：当前版本并不支持分块文件编码（multipart","超时","配置选项，使用时可根据实际情况选择。","配置：","重用请求"],"data/Data.html":["access","data","vert.x"],"data/MongoDBClient.html":["!\");","\"","\"123244\");","\"127.0.0.1\",","\"1937","\"a2fpbhvhiglzihrozsajmsbizwfjacbpbib0agugd29ybgq=\";","\"alan","\"authmechanism\"","\"authsource\"","\"cluster1\",","\"cluster2\",","\"collection_name\")","\"connecttimeoutms\"","\"foo\",","\"gssapi\",","\"gssapiservicename\"","\"heartbeat.socket\"","\"heartbeatfrequencyms\"","\"host\"","\"hosts\"","\"j.","\"john\",","\"keepalive\"","\"maintenancefrequencyms\"","\"maintenanceinitialdelayms\"","\"maxidletimems\"","\"maxlifetimems\"","\"maxpoolsize\"","\"minheartbeatfrequencyms\"","\"minpoolsize\"","\"mypoolname\");","\"myservicename\",","\"passw0rd\",","\"password\"","\"port\"","\"receivebuffersize\"","\"replicaset\"","\"sendbuffersize\"","\"serverselectiontimeoutms\"","\"sockettimeoutms\"","\"some.db\"","\"stephen","\"the","\"title\",","\"username\"","\"waitqueuemultiple\"","\"waitqueuetimeoutms\"","'io.vertx:vertx","(jsonobject","(res.result()","(res.succeeded())","(res2.succeeded())","(在","+","...",".put(\"aggregate\",",".put(\"binarystuff\",",".put(\"individualid\",",".put(\"name\",",".put(\"pipeline\",",".put(\"publicationdate\",","/","//","//...","//iso","//thi","//译者注：mongodb","0","03","09","0。","0，表示一直存在","0，表示永远存活。","0，这将使用操作系统默认大小。","10,","100","1000","10000,","100000,","120000（2分钟）","127.0.0.1。","15","15:54:14","16","16进制的字符串中导出创建时间。若您选择其他类型作为","16进制的字符串作为","1，意味着返回所有数据。","2000,","2017","21t00:00:00+00:00\"));","25,","27000","27017,","27017。如果设置了","28000","3.4.1","30000,","300000,","3600000,","50,","500","500,","5000","64","8192,","8601",":","=","==",">","[","],","_id","aggregate（译者注：聚合）命令。请注意，命令的名称要做为","alreadi","api","async","auth","authent","authmechan","author","authsourc","back","base","base64encodedstr","base64encodedstring));","binari","binaryobject","binaryobject));","book","boolean","bson","build.gradl","byte","byte[40];","byte[]","cet","client","client:3.4.1'","client（以下简称客户端）来与","cluster","collect","command","command,","commands。","compil","config","config);","config,","connect","connection_str","connecttimeoutm","convert","count","creat","createcollect","credenti","date","date，oid","db_name","de","default_db","distinct","doc:","document","document,","driver。","drop","dropcollect","etc","exists.","extend","fail","fals","false。","field","find","findon","findopt","findwithopt","getcollect","gradl","gssapi","gssapiservicenam","hawking\")","heartbeat","heartbeat.socket","heartbeatfrequencym","hobbit\")","hobbit\").put(\"_id\",","hobbit\");","host","id","id),","id);","id，但是此","id，回调方法中可以获得保存后生成的","if(res2.succeeded())","individualid","individualid));","insert","int","io.vertx","iso","java","json","jsonarray","jsonarray());","jsonobject","jsonobject()","jsonobject().put(\"$binary\",","jsonobject().put(\"$date\",","jsonobject().put(\"$oid\",","jsonobject().put(\"$set\",","jsonobject().put(\"_id\",","jsonobject().put(\"author\",","jsonobject().put(\"title\",","jsonobject();","json（bson）格式的文档数据库。","keepal","kerbero","life","like","limit","list","long","lord","maintenancefrequencym","maintenanceinitialdelaym","mapreduce。更多详情，请参考说明文档","maven","maxidletimem","maxlifetimem","maxpools","mechan","minheartbeatfrequencym","minpools","mongo","mongocli","mongoclient.count(\"books\",","mongoclient.createcollection(\"mynewcollectionr\",","mongoclient.createnonshar","mongoclient.createnonshared(vertx,","mongoclient.createshar","mongoclient.createshared(vertx,","mongoclient.distinct(\"books\",","mongoclient.distinctbatch(\"books\",","mongoclient.dropcollection(\"mynewcollectionr\",","mongoclient.find(\"books\",","mongoclient.findbatch(\"book\",","mongoclient.getcollections(r","mongoclient.insert(\"books\",","mongoclient.remove(\"books\",","mongoclient.replace(\"books\",","mongoclient.runcommand(\"aggregate\",","mongoclient.save(\"books\",","mongoclient.update(\"books\",","mongoclient.updatewithoptions(\"books\",","mongodb","mongoservice.findone(\"publishedbooks\",","mongoservice.findone(\"smartpeople\",","mongoservice.save(\"publishedbooks\",","mongoservice.save(\"smartpeople\",","much","multi","multipl","new","now","null","null)","null,","null。","null（意味着不需要授权）","num","object","objectid","objectid().tohexstring();","objectid::getdate()","ok!","oper","option","options,","password","pom.xml","pool","port","queri","query,","r.","re","real","receivebuffers","reconstitutedbase64encodedstr","reconstitutedbinaryobject","reconstitutedindividualid","removedocu","replac","replace,","replicaset","res.cause().printstacktrace();","res.result())","res.result().encodeprettily());","res.result().getjsonarray(\"result\");","res.result();","res2","res2.cause().printstacktrace();","res2.result().getjsonarray(0));","res2.result().getjsonobject(\"binarystuff\").getbinary(\"$binary\");","res2.result().getjsonobject(\"binarystuff\").getstring(\"$binary\");","res2.result().getjsonobject(\"individualid\").getstring(\"$oid\");","res2.result().getjsonobject(\"publicationdate\").getstring(\"$date\"));","res2.result().getstring(\"title\"));","resarr","research\");","retriev","rings\").put(\"author\",","runcommand","save","sendbuffers","serial","server","serverselectiontimeoutm","set","singl","skip","socket","sockettimeoutm","sockettimeoutms，","socket（so_keepalive）连接。默认为","sort","sql","string","string.class.getname(),","stuff!\");","system.out.println(\"book","system.out.println(\"end","system.out.println(\"found","system.out.println(\"insert","system.out.println(\"nev","system.out.println(\"sav","system.out.println(\"titl","system.out.println(\"to","system.out.println(json.encodeprettily());","tolkien","tolkien\"));","tolkien\");","true","true，则可以在没有查询到要更新的文档时，新增该文档","true，则可以更新多个文档","turing\")","updat","update,","updatecollect","updatecollectionwithopt","updateopt","updateoptions().setmulti(true);","updateoptions.","updatewithopt","upsert","upserted。upsert","upsert（upsert","useobjectid","usernam","vert.x","verticl","vertx","waitqueuemultipl","waitqueuetimeoutm","writeconcern","writeopt","writeoption.acknowledg","{","}","});","},","。","。如果您保存的文档中，没有设置","。有关连接字符串格式的更多信息，请参考驱动程序文档。","。此参数默认为","上接收或者发送超时的时间。默认为","下面的例子，文档已有","不是有序的，但","与授权用户关联的数据库名称。默认值为","中可以设置以下参数：","中指定这些查询要求。","中的","中的哪个键值对是命令名称，我们也就必须把命令名称单独设置为一个参数：","中的数据库表）中的一个或多个文档。其中","中的集合概念对应","之后再调用此方法，只会返回一个新的客户端对象，但使用的是相同的数据源。这时","代表的文档已经存在，插入就会失败：","使用","使用客户端","使用此客户端，需要添加下列依赖：","使用的","使用这种方式，可以发挥出","例如保存一个","例如删除作者为","例如匹配所有文档：","例如执行","例如插入一个","例如插入含有","例如更新","例如替换","例如获取","例如获取批量模式下","例如计算作者为","例如：","例如：我们在部署","保存文档","其中","其他命令","写操作的可靠性（译者注：源码中是用","创建不共享数据源的客户端对象","创建客户端","删除单个文档","删除文档","却是，而且","原文档更新于","原文档：vert.x","参数","参数。因为","参数中。这么做是因为","参数也就不再有作用。","参数决定了要删除集合中的哪些文档。","参数决定更新集合中的哪个文档。","参数创建一个数据源。","参数找到的整个文档。","参数用来匹配集合中的文档。","参数的","参数的第一个键值对是命令的名称。所以，为了明确","参数，就会忽略","参数，就会忽略host","又例如匹配","发送缓冲区大小（so_sndbuf）。默认为","只支持","只有在第一次调用","同样的（与默认使用共享的数据源），只有在第一次调用mongoclient.createshared方法的时候，才会真正的根据","后的值：","后，可以让文档基于创建时间排序（译者注：前4个字节用来存储创建的时的时间戳，精确到秒）。您也可以通过使用","命令。","和","在","在大部分情况下，我们会希望在不同的客户端对象之间共享数据源。但有时候，却恰恰相反。","大部分情况下，您希望不同的客户端之间共享一个连接池。","天生就是处理","如果不同的客户端对象使用了相同的","如果您需要指定返回哪些域，又或者需要指定返回的数据条数，可以使用","如果文档中没有","如果文档没有","如果被插入的文档包含","如果被插入的文档没有包含","如果要指定","如果设置了","字段插入。并且读取这个字段：","字段的值，将会默认的生成","字段，回调方法中可以获得保存后生成的","字段，文档会被保存。若有，将执行","完全非阻塞","实例作为副本集的名称","实例的数据库名称。默认是","实例监听的端口。默认是","实例能够共享同一个数据源，而不是单独为每个","实例设置不同的数据源。","实例运行的地址。默认是","客户端参数配置","对象中。","对象和相同的数据源名称，那么它们将共享数据源。","对象的","对象，必须包含","将无法得知服务器是否已写入）。","并且读取它：","应用可以使用","应用进行数据持久化时的最佳选择，因为","当使用","当我们希望不同含义的客户端对象拥有不同的数据源时，可以采用这种方式来创建它的对象。比如它们要与不同的数据源进行交互。","快速序列化和反序列化","您也可以使用","您可以使用","您有以下几种方式来创建客户端：","您的","您还可以像下面这样，在创建一个客户端的时候指定数据源的名称：","意思是，如果此文档不存在，就保存此文档，此文档存在就更新。","意思是，如果此文档不存在，就保存此文档；此文档存在就更新）或者仅仅只更新，请使用","所使用的授权认证机制。请参考","所有返回的结果，都可以在回调方法中得到。","打开连接超时的时间，单位毫秒。默认为10000（10","执行","扩展的","拥有多个实例化的对象，但是我们希望每个","指定排序字段。默认为","指定数据源名称","指定返回哪些域。默认值为","指定返回的数据条数。默认值为","授权的密码","授权的用户名。默认为","接口定义了操作客户端的api","接收缓冲区大小（so_rcvbuf）。默认为","插入文档","操作到底是","支持","支持自定义编解码器，从而实现","文件中):","文档计数","方法。","方法。您可以使用","方法只返回匹配到的第一个文档。","方法和","方法并传递参数","方法或者","方法时加上了具有唯一名称的数据源参数。","方法替换的是","方法来保存文档。","方法来创建一个新的集合：","方法来删除单个文档。","方法来删除文档","方法来删除文档。","方法来执行任何","方法来插入文档。","方法来更新文档（译者注：建议使用","方法来替换文档","方法来获得所有的集合：","方法来计算文档数量。","方法查找文档。","方法查询到的第一条数据。","方法的一个参数，并且同时也必须包含在包装命令的","方法的时候，才会真正的根据","方法类似，但是并不需要","方法）。","方法，从这个","方法，但是","方法，但是仅仅返回","方法，在参数","方法：","时，设置了","是在","更多优点，比如使用","更新文档","替换文档","最小心跳频率。默认为","有以下选项：","服务名。","期望","本客户端基于","来使用调用","来获取更多信息。","枚举类型来代表的）","某个","查找文档","查询单个文档","查询的结果包装成了","此参数用来支持","此客户端尝试着支持驱动所支持的大多数参数配置。有两种配置方式，一种是连接字符串，另一种是驱动配置选项。","此客户端把配置参数放在","此客户端支持以下这些参数：","此方法可以更新集合（译者注：mongodb","每次调用此方法，就相当于在调用","特点","的","的书的数量，结果包装在回调方法中。","的值：","的所有文档数据都存储在集合中。","的所有文档：","的持久化和检索。如果设置为","的授权机制时，所使用的","目前，mongodb","秒）","管理","类型字段的文档以及读取这个字段","类型字段的文档：","类型的字段。而且在设置为","类型（请参考：http://docs.mongodb.org/manual/reference/mongodb","线程等待作为连接的最长等待时间。默认为","组件介绍","维护任务进行循环检查连接的时间间隔（译者注：维护任务会定时检查连接的状态，直到连接池剩下最小连接数）。默认为","编码的字符串，将这个字符串作为","若设置为","表示支持","表示返回的结果，跳过的数据行数。默认值为","要查询单个文档，您可以使用","要解决上面的问题，我们可以这么做：","设置","设置是否复用","请注意：上面提到的各类参数的默认值，都是","请注意：删除一个集合将会删除集合中所有的文档！","请注意：如果使用了字符串连接的方式，此客户端将会忽略所有配置选项。","达到了","这时，可以调用","这有点类似","进制的字符串来保存","进行交互，包括保存，获取，搜索和删除文档。","连接字符串，指的是创建客户端的字符串，例如：mongodb://localhost:27017","连接情况的参数","连接池中最大等待连接数。默认为","连接池启动后，维护任务第一次启动的时间。默认为","连接池最大连接数。默认为","连接池最小连接数。默认为","连接池的连接最大存活时间。默认为","连接池的连接最大空闲时间。默认为","配置集群监视器监控","集合","集合。","集合中某一个作者的所有文档：","集合中的一个文档：","集群中某个运行实例的地址","集群中某个运行实例监听的端口","集群的","集群监视器访问每个集群服务器的频率。默认为","集群（分片／复制）的一组地址和端口","驱动参数说明","驱动大部分配置项","驱动的默认值。请参考驱动文档来获取最新信息。","驱动选择服务器的最大时间，单位毫秒","驱动配置的具体选项","默认使用共享的连接池","默认写操作级别是","（1s）","（5s）","）","，则设置此参数为","，因为由它决定更新的方式。","，将会在集合的文档中，以","，意味着永远不超时（译者注：这是客户端的超时时间。如果一个","，意味着返回所有域。","："],"data/JDBCClient.html":["\"castuuid\":","\"jdbc:hsqldb:mem:test?shutdown=true\")","\"mydatasource\");","\"org.hsqldb.jdbcdriver\")","${vertx_home}/lib","'io.vertx:vertx","(password","(res.succeeded())","(res2.succeeded())","(time,","(代表一直保留)","(在","*",".put(\"driver_class\",",".put(\"max_pool_size\",",".put(\"url\",","//","0","03","128。","15","15:54:14","3.4.1","30);","=",">","bonecp","bonecp，并在命令行上加上","boolean","build.gradl","c3p0","c3p0（datasourceprovider），可以使用下面的配置参数：","c3p0，上面的连接池也可以通过传递一个","cet","classpath","client","client.getconnection(r","client:3.4.1'","client，可以让我们的","client，需要添加下面的依赖：","common","compil","config","config);","config,","connect","connection.query(\"select","cp标示。","datasource);","date,","document","driver_class","driverclassnam","fat","getconnect","gradl","hikari","initial_pool_s","interfac","io.vertx","jar","jar，要确保","jdbc","jdbcclient","jdbcclient.create(vertx,","jdbcclient.createnonshar","jdbcclient.createnonshared(vertx,","jdbcclient.createshar","jdbcclient.createshared(vertx,","jdbcclient。","jdbcurl","json","jsonobject","jsonobject()","lib","maven","max_idle_tim","max_pool_s","max_stat","max_statements_per_connect","maximumpools","min_pool_s","mysql","new","null","number","osgi","password","pom.xml","provider_class","res.result();","res2","res2.result();","resultset","row_stream_fetch_s","rs","some_table\",","sql","sqlconnect","string","timestamp)","true","url","user","usernam","uuid","uuid，可并不是所有都支持，比如说","varchar(36)","vert.x","verticl","vertx","{","}","});","。","。如果我们想使用其他的类，可以自己设置这个参数，但参数对应的类，必须实现接口datasourceprovider。","下添加文件c3p0.properties。","中创建的","中有用到。","中自动关闭","为了提升性能，sqlrowstream","之后再调用此方法，只会返回一个新的","也可以作为","作为","作为标准的消息格式，这使得客户端在接受数据类型时受到很多限制。我们只能从","使用","使用不同的连接池时，可能会稍有不一样。","使用的配置参数不一样：","例如：","关闭客户端","其它连接池实现：","创建","创建不共享数据源的","创建或者部署的时候，我们应该把对应的配置参数传给它。","加载","卸载（undeploy）的时候自动关闭。","原文档更新于2017","原文档：vert.x","参数也就不再有作用。","参数创建一个数据源。","只有在第一次调用","可以自动转换。需要注意的是，我们可以选择性的使用","可以阅读","同样的（与默认使用共享的数据源），只有在第一次调用jdbcclient.createshared方法的时候，才会真正的根据","命令行启动，要确保","和","在","在创建","在多个","在大部分情况下，我们会希望在不同的","处理失败的情况","大部分情况下，我们希望在不同的","如果不同的","如果使用默认的datasourceprovider实现类（c3p0实现），我们要把jdbc","如果想要配置","如果我们已经存在一个数据源，也可以在创建","如果我们的","实例能够共享同一个数据源，而不是单独为每个","实例设置不同的数据源。","对象","对象之间共享数据源。但有时候，却恰恰相反。","对象之间，共享一个数据源。","对象使用了相同的vert.x","对象共享数据源的情况下，这个数据源对象维护着一个引用计数器。一旦此数据源最后一个引用关闭后，这个数据源也就关闭了。","对象后，我们可以通过","对象和相同的数据源名称，那么它们将共享数据源。","对象拥有不同的数据源时，可以采用这种方式来创建它的对象。比如它们要与不同的数据源进行交互。","对象来配置参数。考虑这样一种情况，应用程序要运行在一个","对象的几种方式。","对象的时候就直接指定它：","对象的时候指定数据源的名称：","对象（比如在","对象，会在这些","对象，但使用的是相同的数据源。这时","将会被作为原生类型（译者注：java.util.uuid）来处理。","就不支持。这种情况下，建议使用","常用的配置参数有下面这些：","应用程序","应用程序。","应用程序。但是，必须首先部署它所有的依赖。但有些连接池要求必须从","应用程序打包成","应用程序通过","应用程序通过异步的方式，与任何支持","当我们希望不同含义的","我们可以较长时间的持有","我们在","我们还可以像下面这样，在创建一个","拥有多个实例化的对象，但是我们希望每个","指定数据源","指定数据源名称","接下来，我们一起来看下创建","数据库","数据库密码","数据库密码)","数据库用户名","数据类型","文件中):","方法时加上了具有唯一名称的数据源参数。","方法来获取一个数据库连接。","方法的时候，才会真正的根据","方法：","时间类型","时，设置了","是一个通用接口，不只是在","更多的参数，我们可以在","更多详细内容，可以参考文档","来了解更多关于两个数据源的知识。","此参数确定管理数据库连接池的实现类，默认是io.vertx.ext.jdbc.spi.impl.c3p0datasourceprovid","此方法从连接池中获取一个数据库连接，并返回给回调方法：","每个数据库连接的最大预处理sql缓存数，默认0","每次调用此方法，就相当于在调用","环境中，但我们却不想通过","用结果集results进行其他操作","由于","的一个实现。但是","的接口定义为","的数据库来说，使用下面的参数后，可以对","的数据库进行交互。","的整个生命周期里），可一旦不再使用它后，就应该关闭它。","的方式来部署，且在没有权限把","的转换。虽然大部分数据库都支持","目录下的时候，建议使用","空闲连接保留时间，默认0","类似于","类型的字段。对于其他支持","考虑这样一种情况：我们在部署","若我们使用的是","获取数据库连接","获取的这个连接，是接口","获取连接失败","获得下面的数据类型：","要使用vert.x","要解决上面的问题，我们可以这么做：","设置有内部缓存。默认缓存大小为","路径里面。","这时，可以调用","这样，uuid","进行自动类型转换。","连接地址","连接池初始连接数，默认3","连接池最大连接数","连接池最大连接数，默认15","连接池最小连接数","配置参数","需要注意，hikari","预处理sql语句最小缓存数，默认","驱动","驱动jar包放在编译路径下。","驱动包加到","驱动包含在里面。如果我们的","驱动包在","驱动类名","驱动，这样的就不能作为","默认使用共享的数据源","默认的"],"data/SQLCommon.html":["!\");","!=","\"","\"creat","\"fname","\"select","\"updat","\"{","'io.vertx:vertx","'john',","'smith',","'varchar']","('jane')\");","('joe')\");","(?)\",","(execute.succeeded())","(id","(jsonarray","(jsonobject","(name)","(null,","(r","(res.succeeded())","(start","(stream.succeeded())","(在","*","+",".endhandler(v",".handler(row",".resultsetclosedhandler(v","//","03","1","1)","10","15","15:54:14","3.4.1","9)\",",":","=",">","?","?\";","?)","api","arraylist<>();","auto","batch","batch,","batch.add(\"insert","batch.add(new","batchcallablewithparam","batchwithparam","build.gradl","call","callwithparam","cet","client","close","columnnam","commit","commit/rollback","commit）默认设置为","common","common:3.4.1'","compil","connection.batch(batch,","connection.batchwithparams(\"insert","connection.call(func,","connection.callwithparams(func,","connection.commit(r","connection.execute(sql,","connection.query(\"select","connection.querystream(\"select","connection.querywithparams(query,","connection.setautocommit(false,","connection.update(\"insert","connection.updatewithparams(update,","creat","customer_lastname(?,","data）的方式。因为它能够避免把所有的返回值加载到内存中，而且得到的","default","emp","end","event","execut","failed!","false。","fname","fname,","func","func_proc_name()","func_proc_name(?,","gener","getcolumnnam","getkeys方法获得对应的主键。","getresult","getrow","getupd","gradl","id","id,","ident","in,","increment","insert/update/delet","int","int);\";","interfac","interface组件定义了","io.vertx","jdbc","jdbc/mysql/postgresql）的接口来获取数据库连接。","jdbcstatementhelper.fillstatement(statement,","json","jsonarray","jsonarray().add(\"fox\").add(9);","jsonarray().add(\"fox\");","jsonarray().add(\"jane\"));","jsonarray().add(\"joe\"));","jsonarray().add(\"john\"),","jsonarray().add(\"john\").add(\"doe\"),","jsonarray().addnull().add(\"varchar\"),","jsonobject","json，并且为了保持稳定性，下一个","keys:","large_table\",","large_table;","list","lname","lname,","lname=?","lname=?\";","maven","new","new_customer(?,","next","no.","null","null)","null,","null,\"","null。","null，且","one_hour_ago()","other_table\",","out","out)）：","output","param","params,","peopl","people\",","pom.xml文件中):","queri","queries）。此方法接受含参数占位符的sql查询语句以及","querywithparam","re","res.result();","result","result.getkeys());","result.getupdated());","results)","resultset","resultset.getcolumnnames();","resultset.getresults();","resultset.getrows();","resultset，此时，返回的结果集会被转成纯","return","rollback","row","row...","row.getinteger(\"shoe_size\");","row.getinteger(3);","row.getstring(\"fname\");","row.getstring(\"id\");","row.getstring(\"lname\");","row.getstring(0);","row.getstring(1);","row.getstring(2);","rows)","rows:","rs","rs.getnext();","select","set","set...","setautocommit","shoe_siz","shoesiz","someth","sql","sqlconnect","sqlrowstream","sqlrowstream.moreresults();","sql语句传给数据库时，不会经过任何处理。操作结束时将调用回调方法。","statement","statements），例如","step","stream","stream.result().handler(row","stream.result();","string","system.out.println(\"gener","system.out.println(\"no.","system.out.println(\"t","system.out.println(\"upd","tabl","true。这意味着您的每个操作都将在单独的事务中有效执行。","updat","updated:","updateresult","updateresult.getupdated());","updates）。此方法接受含参数占位符的sql更新语句以及","updatewithparam","valu","varchar(255),","vert.x","vertx","{","}","}\";","})","});","}，也可以选择使用占位符传参数的形式，例如：{","一旦","下面是将结果集作为","与各种","中。","为","为避免歧义，实现类需要遵循以下规则（译者注：可参考","事物提交失败!","事物提交成功!","但是如果存储过程有返回值的话，需要像下面这样调用：","但是当您使用存储过程时，还是需要使用它的参数来返回结果集。如果一个存储过程没有返回值的话，可以像下面这样调用：","何时停止，何时恢复，何时结束。对于查询返回多个结果集的情况，您应该使用","使用事务","值传入存储过程","公共接口定义了3种批量操作的方法：","关键字返回输出结果集，这时可以这样调用：","关闭连接","函数只使用","函数或者存储过程。此方法接受以下参数：","列表，其中的每个元素代表一行结果。","包含输出类型的输出结果集（output），jsonarray","原文档更新于2017","原文档：vert.x","参数的元素值不是","参数的元素值也是","参数的元素值将被注册为输出参数","参数的元素值，再做判断","参数的元素将被当作","参数的元素是","可调用语句","可调用语句。可以使用标准","同样重要。如果第二个参数代表输出结果集，那么应该设置结果集的","在处理大数据结果集时，不建议使用上面提到的api，而是使用数据流（stream","处理","处理row","失败!","如果您希望在同一个事务中执行多个操作，就应该使用","如果有新的结果集，将会重启","对应的回调函数（resulthandler）","对象中。","对象列表（list）的结果集，这样能让","对象（用于传递参数）或参数值。","将会得到新的结果集，若没有，将会调用结束方法。","属性。","属性链接着。一种简单的遍历所有结果集的方式如下：","当","当您获取的数据库连接，其自动提交选项（auto","当操作完成时，回调方法将会被执行：","当更新结束时，将执行回调方法处理结果。更新结果包装在","当查询结束时，将执行回调方法处理结果。查询结果包装在","您可以使用","您可以通过","您在用完连接后，必须使用","您必须通过使用特定的","您还可以使用","您还可以控制","成功!","成功！","我们用","执行","执行其他操作","执行查询","批量操作","批量操作能执行一组","批量调用语句","批量预编译操作","接口来表示数据库连接（译者注：此接口中包含各种基本的操作方法）。","文件中):","方法。","方法执行查询操作。","方法执行结束，将会调用回调方法。然后下一个事务也将自动开始。","方法执行预编译查询（prepar","方法把连接返回给连接池。","方法来执行","方法来执行可调用语句（callabl","方法来执行更新数据库的操作（包括增、删、改）。","方法来执行预编译更新（prepar","方法来获得被包装成了","方法获得。结果集被包装成了一组","方法获得更新的数据条数，并且如果更新操作有生成主键，可以通过","方法获得查询结果的列名","方法设置","方法设置自动提交为false。","方法；在需要回滚时，调用","时，","时，out","时，将进一步去检查","时，此元素将被注册为输入参数","更新语句（原生sql）传给数据库时，不会经过任何处理。","有些","服务交互的方法。","服务（例如","来获得下一个结果集。如果有，stream","某些情况下，您的查询语句可能返回多个结果集","查询语句（原生sql）传给数据库时，不会经过任何修改。","格式","格式的数据也能够一行行的处理，例如：","没有新的结果集需要处理","注册为","然后您就可以执行在同一个事务中的操作，在需要提交事务时，调用","的","的下标和输入参数的","的下标，并且输出结果集元素的值必须是结果集类型的字符串表示。","的参数，设置成了","的实现源码","的操作更简单些。但要注意的是，查询出的结果集中可能会出现重复的列名。若遇到这样的情况，您应该选择使用","的第一个元素为","类代表查询结果。","类型","类型），例如：","类型，例如：[null,","自动提交","若当","若需要执行其他数据库操作，例如您可以使用","获得","被作为当前","要使用事务，首先要用","要使用此组件，需要添加下列依赖：","语句","语句。","语句（list","语句，例如：","请注意，输出结果集的","请注意：输入输出参数的下标必须匹配","输入参数集（params），jsonarray","返回多个结果集","进行迭代的例子：","连接","集合，实际的结果集可以通过","预编译或者调用语句将会根据参数列表，来重复使用","预编译更新","预编译查询"],"data/RedisClient.html":["\"0\",","\"2.5.13\",","\"2812b945\",","\"32\",","\"4.4.1\",","\"8107\",","\"epoll\",","\"hello","\"linux","\"member\",","\"other","\"value\",","'io.vertx:vertx","(res.succeeded())","(在","...",".sethost(\"127.0.0.1\");","//","0","03","10","10。","15","15:54:14","2.6.32.16","3.4.1","6379","8","=",">",">=3.0.0","api，总结如下：","api，省去了手写命令的麻烦。例如，如果想通过","arch_bits:","auth","bu","build.gradl","cet","channel","channel，pattern","client","client:","client:3.4.1'","cluster","compil","config","config);","connect","db","db、建立连接、断开连接、授权相关的命令","db，您需要提供授权的密码，或者","encoding:","eval","evalsha","event","gcc_version:","gradl","hash","hgetal","hmset","host:","hyperloglog","i686\",","id，配置参数如下：","io.vertx","java","json","jsonarray","jsonobject","key","keyname:","key）。需要注意","linode28","list","localhost","lua","map","maven","member\"","member。","memory:","messag","mset","msetnx","multiplexing_api:","new","object","os:","otherkeyname:","otherscore:","pattern","pom.xml","port:","process_id:","pub/sub","re","receiv","received.body().getjsonobject(\"value\");","redi","redis.get(\"mykey\",","redis.publish(\"channel1\",","redis.subscribe(\"channel1\",","redis_git_dirty:","redis_git_sha1:","redis_version:","rediscli","redisclient.create(vertx,","redisopt","redisoptions()","redisoptions());","return","score","score:","script","select","server","server:","set","sets)，所以通常被用做结构化数据存储服务器。要使用本组件，您必须有一个运行中的","socket","something...","sort","string","tcpkeepalive:","tcpnodelay:","transact","true","utf","valu","value\"","value数据库。它可以存储字符串、哈希(hashes)、列表、无序集合(sets)和有序集合(sort","value的话，可以这样：","vert.x","vertx","vertx.eventbus().consumer(\"io.vertx.redis.channel1\",","world!\",","zadd","zaddmani","{","{...},","}","});","},","不存在，将创建新的","不是默认","与集群相关的命令。要使用这些命令，redi","中的","中的数据进行保存、获取、搜索和删除。redi","中设置多个值。需要注意","中设置多个值（译者注：hmset","中设置多个值（译者注：msetnx","中，zadd","为让返回的服务器信息易于操作，vert.x","也是多语言的，而不同语言之间的类型转换实现起来十分的复杂和困难。所以，我们会用","代表的是匹配符","使用","例如：","值时，有其他一些更简洁的方式。","切换","原文档更新于2017","原文档：vert.x","发布消息的","发布消息：","发布的消息载体","发布／订阅模式","发布／订阅模式的消息队列相关命令","可以这样注册一个订阅者：","命令","命令。vert.x","命令。不同之处在于，zaddmani","命令传入一个","命令使用单个字符串或者字符串数组来作为参数，并且返回的也是单个字符串或者字符串数组。不过在处理","命令十分特殊，因为它们可以返回任意类型。vert.x","命令提供了一套十分简洁的","命令的返回值，即便是像下面这样简单的脚本：","命令返回的结果将被转换成","命令，如果给定","命令，必须当且仅当所有给定","命令，请参考","和","基于","处理事务的相关命令","大部分","如果您不这样做，而是手动调用","官方文档。","实例。","客户端为执行","客户端在连接","客户端实现。","客户端将不知道如何修复错误。","客户端将会把服务器信息转换成利于理解的","客户端执行","客户端连接到","客户端，需要添加下列依赖：","对象","对象。这样，您就可以使用","对象中，有以下这些参数：","对象以在","对象的每个部分都包装着属于着这部分的属性。不在这个部分的属性，将会以其他的顶级对象部分展现：","对象，且下标为","当使用","您可以向","您可以通过","或者","执行上面的脚本，将返回一个","执行命令","操作","操作字符串的相关命令","操作接收到的消息","操作无序集合的相关命令","操作有序集合的相关命令","支持发布／订阅模式的消息队列。需要注意，一旦一个","文件中):","方法中，传入的是","方法可以同时向有序集合中添加多个member。需要注意","方法可以添加多个","方法和","方法都对应","方法，那么当出现","是","是一个包含下面数据的","是一个基于bsd协议开源的高性能key","是强类型语言，并且我们又要避免使用","更简洁的","有着丰富的","服务器","服务器信息","服务器后，就可以使用","服务器失败时，会尝试重连。所以，如果您连接的","服务器的","服务器的版本必须","服务器的相关命令","服务器需要授权，或者您连接的","服务器，需要配置一些参数。配置参数包装在","来包装","来对","格式。格式为：json","的","的值为","的相关命令","的语法来进行交互，这在与","相关的命令","算法来快速计算元素基数的相关命令","管理","类型的原因是因为","类型的参数。","类型，这使得返回任意类型变得比较困难。避免使用","脚本的相关命令","若您使用匹配符来匹配消息","获得","要使用","要想了解更多","要连接到","解释运行","译者注：在","译者注：实际在","语言，而","调用","连接","连接被注册为订阅者时，此连接将不能再执行其他命令，直到这个连接使用取消订阅者的命令。","通信时十分方便。","都不存在）。需要注意","都将被转换成字符串。","配套的","错误的时候，vert.x","默认是"],"data/MySQL&PostgreSQLClient.html":["\"charset\"","\"database\"","\"host\"","\"included\":","\"maxpoolsize\"","\"mymysqldb.mycompany\");","\"mypostgresqldb.mycompany\");","\"mysqlpool1\");","\"password\"","\"port\"","\"postgresqlpool1\");","\"querytimeout\"","\"username\"","$vertx_hom","$vertx_home/lib","'io.vertx:vertx","(=","(res.succeeded())","(在","(此客户端)",",","./vertx",".000。","/","//","03","10000","10。","10秒)。","15","15:54:14","2.11","2.11.4","2.11，来自","3.4.1","3306","5432，mysql","8601（yyyi","8。",":","=",">","api","async","asyncsqlcli","async。此组件让","build.gradl","call","callwithparam","cet","charset","classpath:","clause。您可以选择使用其中的一个","client","client.getconnection(r","client:","client:3.4.1'","client（以下简称客户端）底层实现基于","close()","close(handler)","common","compil","config","connect","creat","databas","ddthh:mm:ss.sss）格式的字符串。mysql","dir=lib","fat","getconnect","gradl","host","https://github.com/mauricio/postgresql","id。在","id，而在","interfac","io.vertx","iso","jar","jdbc","joda","jsonobject","jsonobject().put(\"host\",","librari","linhar","localhost。","mauricio","maven","maxpools","mm","mysql","mysql/postgresql","mysqlclient","mysqlclient.createnonshared(vertx,","mysqlclient.createshar","mysqlclient.createshared(vertx,","mysqlclientconfig","mysqlclientconfig);","mysqlclientconfig,","new","password","pom.xml","port","postgr","postgresql","postgresqlcli","postgresqlclient.createnonshared(vertx,","postgresqlclient.createshar","postgresqlclient.createshared(vertx,","postgresqlclientconfig","postgresqlclientconfig);","postgresqlclientconfig,","postgress","queri","querytimeout","res.result();","resolv","return","root","scala","sql","sqlconnect","stack.json","stack.json，就会下载此客户端及它的依赖。","stack=","testdb。","time","true。完成后，执行命令：vertx","usernam","utf","vert.x","verticl","vertx","{","}","});","。","一旦您用完一个数据库连接后，请确保关闭它。","中了解如何去使用它。","中心库下载。","中，可以按照","中，您可以使用","之后再调用此方法，只会返回一个新的客户端实例，但使用的是相同的数据源。这时","之后再调用此方法，只会返回一个新的客户端对象，但使用的是相同的数据源。这时","会舍弃毫秒项，所以您会看到","使用","使用默认共享连接池","关闭客户端","写的异步驱动","创建","创建一个","创建不共享数据源的客户端对象","创建客户端对象","包加入","包加入到","原文档更新于2017","原文档：vert.x","参数也就不再有作用。","参数创建一个数据源。","只有在第一次调用","只要您从数据库从获取时间格式的数据，此客户端都将会隐式将它们转换成","和","在使用","在大部分情况下，我们会希望在不同的客户端实例之间共享数据源。但有时候，却恰恰相反。","在常规应用中","在打包成","在表中插入新数据时，您也许希望获得数据库的自增长id。jdbc","处理异常","大部分情况下，您都将希望不同的客户端实例（asyncsqlclient）共享一个连接池。","如果不同的客户端对象使用了相同的","如果您使用","存储过程","实例能够共享同一个数据源，而不是单独为每个","实例设置不同的数据源。","客户端","客户端。","客户端的配置参数一样：","客户端给需要与","客户端，您需要把下面的","对象和相同的数据源名称，那么它们将共享数据源。","应用提供了相应的接口。","应用能够以异步、非阻塞的方式访问","应用，只需要加入下面的依赖：","当我们希望不同含义的客户端对象拥有不同的数据源时，可以采用这种方式来创建它的对象，比如它们要与不同的数据库进行交互。","您可以使用","您可以在","您可以较长时间的持有客户端对象（比如在","您还可以像下面这样，在创建一个客户端实例的时候指定数据源的名称：","或","或者","或者postgresqlclient.createnonshar","或者，您可以编辑位于","所有这些都可以从","拥有多个实例化的对象，但是您希望每个","指定数据源名称","描述的方式获得最后插入的","数据库。","数据库主机地址，默认为","数据库交互的","数据库名称，默认为","数据库密码，默认不设置。","数据库用户名，postgresql","数据库端口，postgresql","文件中):","文件，并且设置","文档","方法时加上了具有唯一名称的数据源参数。","方法来关闭它。","方法来获取返回的列。","方法来获得数据库连接。","方法的时候，才会真正地根据","方法的时候，才会真正的根据","方法目前暂未实现。","方法：","日期和时间戳","时，设置了","是一个通用接口，不只是在此客户端中有用到。","最后插入的数据id","最大连接数。默认为","有几种方式来创建客户端，我们一起来看下。","构建","查询超时时间（毫秒），默认为","此异步","此方法从连接池中获取一个数据库连接，并返回给回调方法：","每次调用此方法，就相当于在调用","环境的应用中","环境，需要把上面列出的","的一个实现。但是","的依赖为","的应用中","的整个生命周期里），可一旦不再使用，就应该使用","编码格式，默认为","考虑这样一种情况：您在部署","获取数据库连接","获取的连接，是接口","获取连接失败","获得一个连接","要使用","要解决上面的问题，您可以这么做：","路径下。","路径下的vertx","这时，可以调用mysqlclient.createnonshar","这部分内容阐述了如何在您的应用中配置","通常都会让您从数据库连接中得到最后一个插入的","配置参数","默认为","，mysql"],"integration/Integration.html":["integr","vert.x"],"integration/MailClient.html":["client","mail","vert.x"],"integration/STOMPClient&Server.html":["&","client","server","stomp","vert.x"],"integration/JCAAdaptor.html":["adaptor","jca","vert.x"],"integration/KafkaClient.html":["\"","\",","\",offset=\"","\",partition=\"","\",value=\"","\"1\");","\"earliest\");","\"false\");","\"io.vertx.kafka.client.serialization.bufferdeserializer\");","\"io.vertx.kafka.client.serialization.bufferserializer\");","\"io.vertx.kafka.client.serialization.jsonarraydeserializer\");","\"io.vertx.kafka.client.serialization.jsonarrayserializer\");","\"io.vertx.kafka.client.serialization.jsonobjectdeserializer\");","\"io.vertx.kafka.client.serialization.jsonobjectserializer\");","\"localhost:9092\");","\"message_\"","\"my_group\");","\"org.apache.kafka.common.serialization.stringdeserializer\");","\"org.apache.kafka.common.serialization.stringserializer\");","\"the","&&","'io.vertx:vertx","((record.partition()","(ar.succeeded())","(assign","(destin","(done.succeeded())","(done1.succeeded())","(int","(partitioninfo","(record.offset()","(res.succeeded())","(system.currenttimemillis()","(topicpartit",").subscribe(v","+",".buffer(256)",".map(",".map(record",".setpartition(0));",".setpartition(0);",".settopic(\"test\")","//","//注册一个handler处理进来的消息","//获取到一个平均值","//这里lambda表达式用于接收消息处理结果","0)","0);","0.10.1.1","03","0;","10,","15","15:54:14","2017","3.4.1","5))","5秒后再恢复,继续读取","60000);",":","=","==",">","apach","api","api。","api通过这些接口将这些方法展现给用户，其他语言版本也应该类似。","ar","ar.cause().getmessage());","ar.result())","ar.result();","assign","assigned\");","balanc","beginningoffset","beginningoffset)","beginningoffset=\"+beginningoffset));","beginningoffset=\"+beginningoffset);","buffer.class);","buffer.class,","bufferconsum","bufferproduc","buffer、jsonobject","buffer：","cet","client","client:3.4.1'","close","closed\");","commit","committed\");","compil","config","config);","config,","config.put(\"acks\",","config.put(\"auto.offset.reset\",","config.put(\"bootstrap.servers\",","config.put(\"enable.auto.commit\",","config.put(\"group.id\",","config.put(\"key.deserializer\",","config.put(\"key.serializer\",","config.put(\"value.deserializer\",","config.put(\"value.serializer\",","config.put(consumerconfig.auto_offset_reset_config,","config.put(consumerconfig.bootstrap_servers_config,","config.put(consumerconfig.enable_auto_commit_config,","config.put(consumerconfig.group_id_config,","config.put(consumerconfig.key_deserializer_class_config,","config.put(consumerconfig.value_deserializer_class_config,","config.put(producerconfig.acks_config,","config.put(producerconfig.bootstrap_servers_config,","consum","consumer.assign(topicpartitions,","consumer.assignment(done1","consumer.beginningoffsets(topicpartition,","consumer.beginningoffsets(topicpartitions,","consumer.close(r","consumer.commit(ar","consumer.endoffsets(topicpartition,","consumer.endoffsets(topicpartitions,","consumer.exceptionhandler(","consumer.handler(record","consumer.listtopics(ar","consumer.offsetsfortimes(topicpartition,","consumer.offsetsfortimes(topicpartitionswithtimestamps,","consumer.partitionsassignedhandler(topicpartit","consumer.partitionsfor(\"test\",","consumer.partitionsrevokedhandler(topicpartit","consumer.pause(topicpartition,","consumer.resume(topicpartition);","consumer.seek(topicpartition,","consumer.seektobeginning(collections.singleton(topicpartition),","consumer.seektoend(collections.singleton(topicpartition),","consumer.subscribe(\"a","consumer.subscribe(\"test\",","consumer.subscribe(topics);","consumer.subscribe(topics,","consumer.toobservable();","consumer.unsubscribe();","consumer.unsubscribe(ar","consumerrecord","consumer：消费者","context","creat","createshar","done","done\");","done.result();","done1.result())","e.getmessage());","enable.auto.commit","endoffset","endoffset)","endoffset=\"+endoffset));","endoffset=\"+endoffset);","failed\");","gradle（在build.gradle文件中）：","group","group)，同一个组只有一个消费者可以消费特定的","group）中（在创建消费者实例时通过配置指定）。当然你需要通过","group：消费组（kafka中的设计）","handler","handler：","hash","hashmap<>();","hashset<>();","i);","i,","if(done.succeeded())","io.vertx","jsonarray","jsonarray.class);","jsonarray.class,","jsonarrayconsum","jsonarrayproduc","jsonobject.class);","jsonobject.class,","jsonobjectconsum","jsonobjectproduc","kafka","kafkaconsum","kafkaconsumer#exceptionhandl","kafkaconsumer.create(vertx,","kafkaproduc","kafkaproducer#exceptionhandl","kafkaproducer.cr","kafkaproducer.create(vertx,","kafkaproducer.createshar","kafkaproducer.createshared(vertx,","kafkaproducerrecord.create(\"test\",","kafkaproducer：","kafkareadstream用于读取","kafkawritestream用于向某些","key","key=\"","key：","list","list.stream().maptodouble(n","long","map","map.foreach((topic,","map.get(topic));","map>","map：","maven（在","messag","n).average()","new","now","null,","observ","observable>","offset","offset)","offset)。","offset=\"","offset=\"+offset.getoffset()+","offset=\"+offsetandtimestamp.getoffset()+","offsetandtimestamp","offsetsfortimes，调用此api可以返回大于等于给定时间戳的","offsettimestamp=\"+offset.gettimestamp()));","offsettimestamp=\"+offsetandtimestamp.gettimestamp());","offset。因为","offset：偏移量","onc","oper","partit","partition)","partition=\"","partition=\"+","partition=\"+topic.getpartition()+\"\\n\"+","partition=\"+topicpartition.getpartition()+\"\\n\"+","partitioninfo","partitions)","partitionsassignedhandl","partitionsfor","partitionsrevokedhandl","partition。","partition。如果某个消费者并不属于任何消费组，那么整个程序就不能依赖","partition。它是","partition。您可以通过","partition，同时此消费组也可以接纳其他的消费者，这样可以实现","partition，所以我们可以保证所有的消息被发送到同样的","partition：分区（kafka中的设计）","paus","pom.xml文件中）：","produc","producer\",","producer.close(r","producer.partitionsfor(\"test\",","producer.write(record);","producer.write(record,","producer1","producer1.close();","producer:","producerrecord","producer。您可以通过","producer，那么当对应","producer：","properti","properties();","re","read","record","record.key()","record.offset());","record.partition()","record.value()","record.value())","recordmetadata","recordmetadata.getoffset());","recordmetadata.getpartition()","recordmetadata.gettopic()","record，您可以使用原生的","result","results.foreach((topic,","resum","resumi","revoked\");","robin)的方式发送到对应","rxjava","seek","seektobegin","seektoend","set","sever","singl","stream","string.class);","string.class,","string.valueof(key),","stringdeserializer.class);","subscrib","subscribed\");","system.out.println(\"begin","system.out.println(\"clos","system.out.println(\"consum","system.out.println(\"could","system.out.println(\"end","system.out.println(\"error","system.out.println(\"key=\"","system.out.println(\"last","system.out.println(\"messag","system.out.println(\"offset","system.out.println(\"partit","system.out.println(\"paused\");","system.out.println(\"process","system.out.println(\"produc","system.out.println(\"seek","system.out.println(\"subscribed\");","system.out.println(\"top","system.out.println(partitioninfo);","system.out.println(topicpartition.gettopic()","timeid","timestamp","timestamp);","timestamp,","timestamp=\"+timestamp+\",","topic","topic\");","topic\",","topic);","topic.getpartition()+\",","topic=\"","topic=\"+topic.gettopic()+","topic=\"+topic.gettopic()+\",","topic=\"+topicpartition.gettopic()+","topic=\"+topicpartition.gettopic()+\",","topicpartit","topicpartition()","topicpartition().settopic(\"test\").setpartition(0);","topicpartition.getpartition());","topicpartition.getpartition()+\",","topicpartitions)","topicpartitions.add(new","topicpartitions.add(topicpartition);","topicpartitionswithtimestamp","topicpartitionswithtimestamps.put(topicpartition,","topics.add(\"topic1\");","topics.add(\"topic2\");","topics.add(\"topic3\");","topic、目的分区","true","unsubscrib","unsubscribed\");","valu","value。","vert.x","verticl","vertx","vertx.settimer(5000,","write","written","{","}","});","上面的","下共用一个","与","与关闭","与此对应的api还有","中也可以：","中写入数据。","中写入数据。它是","中的消息是按顺序持久化在磁盘上的，所以消费者可以在某个","中英文对照表","中读取一批消息的时候自动执行提交偏移量的操作。需要在创建","中，并且是有序的。","中，消费者负责处理最新读取消息的偏移量（offset）。consum","之间安全共享的","从","以及","以及使用它们的方法其实与原生的","以及分区。在这种情况下，消息会以轮询(round","以及分区信息","以及分配的偏移量","以及对应的","以及相关的分区(partition)的方法，类似于向","以及相关的分区(partition)，或者将消息以","以及相应的值而省略消息的","会在每次从某个","会自动关闭。","位置开始消费消息。我们可以通过","位置设置到","低位就是时间戳，所以","作为","你可以利用","使用","侦听分配结果","信息：","值来确定","偏移量查询","共享","关闭","内部创建的","内部进行偏移量定位(seek)操作，并从任意指定的","分区偏移量定位","分配给组内其它消费者继续去消费。","则暂停读取","创建","创建一个kafka","创建一个可以反序列化成buffer的consum","创建一个可以反序列化成jsonarray的consum","创建一个可以反序列化成jsonarray的consumer.","创建一个可以反序列化成jsonobject的consum","创建一个可以反序列化成jsonobject的consumer.","创建一个可以序列化成buffer的producer.","创建一个可以序列化成jsonarray的producer.","创建一个可以序列化成jsonobject的producer.","加入某个","原文档","原文档最后更新于","原生对象","发送消息(records)。","发送消息到某个","另外也可以使用","另外如果想知道消息是否成功被消费掉，可以在调用","另外，listtop","只是做了一层异步封装。","只需要调用","可以使用消息的","可以对消息流进行流量控制。如果我们读到一批消息，需要花点时间进行处理则可以暂时暂停（pause）消息的流入（这里实际上是把消息全部缓存到内存里了）；等我们处理了差不多了，可以再继续消费缓存起来的消息（resume）。","同样在","后，直接调用","和","因为","在","在上面的例子中，我们在创建","在这里，我们在创建","如果希望将消息发送到指定的分区，你可以指定分区的标识(identifier)或者设定消息的","如果您希望直接操作原生的","如果您是在","如果我们读到partition0的第5个offset","如果组内的一个消费者挂了，kafka","实例之间共享，所以相关的配置必须在创建","实例将复用相关的资源（如线程、连接等）。使用完","实例时传入了一个","实例的时候传入了一个","实例，用于指定要连接的","实例：","客户端（生产者和消费者）和","对于消费者(consumer)，api以异步的方式订阅消费指定的","对于生产者(producer)，api提供发送信息到指定","对象。","对象的可写流对象。","对象的可读流对象，读到的是","将offset挪到分区末端","将offset挪到分区起始端","将会被调用。","库非常相似，vert.x","引入的新的api","当消费者需要从","当然你也可以在","很容易定位此类offset。","您也可以在","您可以利用","您可以通过","您可以通过绑定","我们只想要60秒之前的消息的offset","我们可以利用","我们可以用类似的方法来创建","我们可以通过","我们可以通过一个","我们需要对","或","或者","手动提交偏移量","指定offset位置10","指定的","接口中的","接口或","方法不会更改","方法中。","方法中传入一个","方法关闭即可，相关的资源会自动释放。","方法创建。它可以在多个","方法可以列出当前分配的","方法可以列出消费者下的所有","方法和","方法在","方法将","方法就可以了，它会自动的关闭与","方法时绑定一个","方法是异步的，你并不知道关闭操作什么时候完成或失败，这时你需要注册一个处理器(handler)来监听关闭完成的消息。当关闭操作彻底完成以后，注册的","方法有一个地方不同：beginningoffset","方法来创建可以在","方法来向某个","方法来处理","方法来更改读取位置对应的偏移量：","方法来订阅一个或多个","方法来进行流量控制：","方法注册一个","方法的参数直接传进去，而不是在相关配置中指定：","方法相比，endoffset","方法获取指定","方法请求分配指定的分区：","方法进行手动提交。手动提交偏移量通常用于确保消息分发的","方法退出该消费组，从而不再接受到相关消息：","方法里指明序列化与反序列化相关的类。","方法，用于获取给定分区末端的偏移量值。与","时将","时：","是否被删除或者分配。","最后我们也可以通过","最简单的发送消息的方式是仅仅指定目的","有时候您希望在多个","机制去消费消息。","来代替","来包装这些配置，然后将其传入到","来处理接收的消息：","来开启自动提交。","来接受发送的结果。这个结果其实就是一些元数据(metadata)，包含消息的","来获取给定分区的起始偏移量。这个跟上面的","查询辅助方法","此组件提供了","比如创建","注册一个用于侦听撤销partition的handl","注册一个用于侦听新分配partition的handl","注意这里的第三和第四个参数","注意：可共享的","流实现与","流式对象，它可以处理原生","流量控制","消息的","消费感兴趣","消费组内的消费者可以消费某个","生产者","用于监听对应的","用于监听执行结果状态：","由于","由于kafka的消费者会组成一个消费组(consum","的","的api方法","的值，仅仅是读取（只读模式）。","的分区信息。","的官方文档：","的序列化格式也可以作为","的所有分区上。","的方式从","的方式读取（甚至可以支持暂停(pause)和恢复(resume)操作）。","的时候定义。","的末端：","的消息并加入消费组","的消费者，可以通过","的特定分区里接收消息","的的","的相关信息","的解析方式作为参数传入","的起始位置读取消息时，可以使用","的起始端：","的连接，同时释放所有相关资源。","的连接，同时释放相关资源。","的集成，可以以","相关的","等类型。","类似，关闭","组件也提供rx风格的api。","组件介绍","组件源码","组件示例","组件，需要添加以下依赖：","自动关闭","自带现成的序列化与反序列化机制，可以处理","自带的序列化与反序列化机制","节点列表（只有一个）以及如何对接收到的消息进行解析以得到","节点列表（只有一个）和消息确认模式。消息","获取","被卸载(undeploy)的时候，相关的","要使用","要求分配到特定的topic以及partit","警告：此组件处于技术预览阶段，因此在之后版本中api可能还会发生一些变更。","订阅单个主题","订阅多个topic","译者注：此处也可以参考","语义，以确保消息没有被消费前不会执行提交。","返回的","还提供了一个根据时间戳(timestamp)来定位","进行一些相关的配置，具体可以参考","进行消费，同时加入到某个消费组（consum","通过","配置项设为","里您可以使用","里注册一个","重新分配给组内其他消费者，或者新加入一个消费者去消费对应的","错误处理","随","集群上消费或者发送消息。","集群之间的错误（如超时）。比如：","集群会自动把","静态方法里来创建"],"eventbusbridge/CamelBridge.html":["bridg","camel","vert.x"],"eventbusbridge/TCPEventbusBridge.html":["bridg","eventbu","tcp","vert.x"],"auth/Auth.html":["2：http://vertx.io/docs/vertx","auth","authent","authoris","auth：http://vertx.io/docs/vertx","common/java/jdbc","common：http://vertx.io/docs/vertx","http://vertx.io/docs/auth","jdbc/java/jwt","jwt/java/shiro","mongo/java/oauth","oauth2/java/","shiro/java/mongodb","vert.x","vert.x为您的应用程序提供了简单的认证api。我们还提供了一些开箱即用的实现","译者：虞浪，易世伟校对：钟子期，易世伟"],"auth/AuthCommon.html":["\"","\"mypassword\"","\"mypassword\");","\"password\":","\"tim\").put(\"password\",","\"tim\",","(hasauthority)","(res.succeeded())","+","3.2.1","=",">","auth","authenticated\");","authentication：认证","authinfo","authorisation：授权","authority\");","authority：权限","authprovider.authenticate(authinfo,","auth项目提供了处理认证和授权的功能，它可以被vertx","bearer","boolean","common","common/java/","common:3.2.1","compil","gradle（在build.gradle文件中）","handler：处理器","hasauthor","io.vertx","io.vertx:vertx","jsonobject","jsonobject().put(\"username\",","maven（在pom.xml文件中）","new","now","permission：许可","principal：凭证","provider则需要创建一个类实现authprovider接口。","provider，则可以按照文档中的内容实施。","re","res.cause().printstacktrace();","res.result();","role：角色","system.out.println(\"us","token或oauth","token的实现还会在认证信息中包含令牌token信息。vert.x中的认证是异步执行，在调用过程中，认证结果被传给结果处理器中的用户user对象里，异步调用结果包含了一个用户user的实例，这个实例表述了已经认证过的用户信息，并且包含了这些用户允许执行的合法操作。","token：令牌","user","user.isauthorised(\"printers:printer1234\",","user.principal()","user：用户","vert.x","vert.x提供了用户对象的抽象实现abstractuser，你可以创建这个类的子类对自己的用户user对象提供自定义实现。这个抽象实现中包含了缓存逻辑，所以你在实现的时候不需要考虑自己处理缓存问题。","vertx","web项目使用，若要在自己的项目中运用它，则需要在构建描述信息的dependencies节点中添加如下信息：","{","}","});","“username\":","一旦你拥有了一个用户user的实例过后，你就可以调用它的方法对这个用户进行授权。","上边所有操作的结果都是通过处理器handler异步调用提供的。","为了清空内部缓存，则你可以使用clearcache方法。","创建自己的认证实现","另外一个例子对基于角色模型的用户进行授权就是使用role:前缀，请注意，就像上边讨论的一样，权限字符串如何被解释完全取决于底层实现，这里vert.x不对解释细节提供假设。","基本术语","基本概念","如果你希望创建自己的认证提供者auth","如果你希望在集群环境中使用你的user对象，则需要保证这个用户对象实现了clusterserializable接口。","如果要了解期望的特定认证提供者auth","如果要对用户进行认证可使用provider中的authenticate方法。","对于一些基于jwt","对于已经认证过的用户，你可以调用principal方法获取用户的凭证信息，获取凭证信息的内容同样取决于底层实现。","引用：http://vertx.io/docs/vertx","授权","授权authorisation：用于验证用户是否拥有访问系统的许可。","权限authority：它取决于一些特定的系统实现但对特定的模型不做任何要求；比如：许可/角色permissions/roles模型，可以使事情变得灵活。在一些实现中一个权限可以用来表述一个许可，如：有权限访问所有打印机、或特定打印机。在另外一些实现中则必须支持角色信息，通常使用一些角色信息对权限进行前缀role:命名/标识，如：role:admin。还有一些实现也许会包含更加复杂以及不同的模型来表述权限信息。","权限缓存","检查一个用户是否拥有特定权限需要使用它的isauhorised方法。","用户凭证","用户对象可以缓存任何权限，之后的调用会检查是否拥有同样的权限执行其操作，这个结果实际上调用了底层提供者provider的方法。","认证","认证authentication：用于验证用户的标识和身份。","这个方法的第一个参数是一个json对象，它包含了认证用的信息，实际上这些信息取决于特定的实现；对于简单基于用户名/密码username/password的认证包含了如下信息：","这里是一个对用户授权的例子：","这里是一个简单的基于用户名/密码username/password认证用户的代码实现："],"auth/JDBCAuth.html":["\"sausages\");","\"tim\").put(\"password\",","(res.succeeded())","//","3.2.1","512算法加密后进行存储，之后会连接对应的salt值，这个salt值和密码存储在同一个表里。","=",">","auth","authentication：认证","authinfo","authorisation：授权","authority：权限","authprovid","authprovider.authenticate(authinfo,","auth自身并不要求使用特定的许可模型（它本身只是使用了不透明的字符串），但默认的实现使用了比较熟悉的：用户/角色/许可模型，这样在应用里你可以使用一个或者多个角色，而一个角色也可以拥有一个或者多个许可。","boolean","box）中包含了某些针对认证和授权的信息查询，如果你想要使用不同的数据库模式（schema），这些查询内容可以通过下边几个方法进行更改：","compil","fail","failed!","gradle（在build.gradle文件中）","handler：处理器","haspermiss","hasrol","io.vertx","io.vertx:vertx","jdbc","jdbc/java/","jdbc:3.2.1","jdbcauth","jdbcauth.create(jdbcclient);","jdbcclient","jdbcclient.createshared(vertx,","jdbcclientconfig);","jsonobject","jsonobject().put(\"username\",","maven（在pom.xml文件中）","new","permission/role模型","permission：许可","principal：凭证","re","res.result();","role：角色","setauthenticationqueri","setpermissionqueri","setrolesqueri","token：令牌","user","user.isauthorised(\"commit_code\",","user.isauthorised(\"role:manager\",","user：用户","vert.x","vert.x中提供了一个使用jdbcclient的authprovider实现，它针对任何兼容jdbc的关系数据库执行认证和授权。若要在自己的项目中使用它，则需要在构建描述信息的dependencies节点中添加如下信息：","vert.x中的默认角色前缀使用了role:，这个值可通过setroleprefix进行更改。","vert.x的默认标准配置（out","vert.x默认实现中的密码在数据库中使用了sha","vertx","{","}","});","一旦你创建了一个jdbcclient实例后，就可以按下边代码创建jdbcauth实例：","创建好上边的实例过后你就可以如使用任何authprovider执行认证和授权功能了。","基本术语","如果你想要重写这些行为，则可以重写sethashstrategy方法去修改hash策略的设置。","如果要使用默认的认证实现，认证信息中用了username和password字段进行表述：","如果要创建一个客户端实例，你首先需要一个jdbcclient的实例，要知道如何创建这个实例可按照文档中的内容实施。","如果要验证一个用户是否属于特定角色，则可以使用前缀法给角色带上前缀表示：","如果要验证一个用户是否拥有特定的许可，则需要将许可信息传递到isauthorised中：","尽管vert.x","引用：http://vertx.io/docs/vertx","强烈建议在存储密码时使用哈希算法加密过后保存在数据库中，这个哈希值是在创建这一行记录时基于salt值计算的，应用中应该使用强壮的密码算法，在存储密码时绝对不要使用明文。","授权","认证","！warn"],"auth/JWTAuth.html":["\"cn=,ou=,o=,l=,st=,c=\"","\"jceks\")","\"keystore.jceks\")","\"paulo\"),","\"secret\"));","\"super_secret\".equals(password))","&&","'io.vertx:vertx","(\"paulo\".equal(username)",".put(\"password\",",".put(\"path\",",".put(\"type\",","//","2048","256","3.2.1","360","384","512","521","=","`es256`::","`es384`::","`es512`::","`hs256`::","`hs384`::","`hs512`::","`rs256`::","`rs384`::","`rs512`::","algorithm","alia","api，非常适用于简单的页面应用","auth","authent","authenticity：真实性","authorisation：授权","authprovid","auth提供者的示例代码：","auth提供者需要在类路径或文件系统上加载一个keystore文件，keystore文件要么有一个mac要么有一个signature用于签名和验证生成的令牌，。","compil","config","config);","curv","dname","ec","ecdsa","es256","es384","es512","file","foxpaulo","genkey","genkeypair","genseckey","gradle(在你的build.gradle文件里)","hash","hmac","hmacsha256","hmacsha384","hmacsha512","hs256","hs384","hs512","io.vertx","jcek","json","jsonobject","jsonobject()","jsonobject().put(\"keystore\",","jsonobject().put(\"sub\",","jsonobjetc","julien","jwt","jwt/java/","jwt:3.2.1'","jwtauth","jwtauth.create(vertx,","jwtoptions());","jwt主要的优点有：","jwt用法的典型流程是，在您的应用程序有一个终点颁发令牌，这个终点应在ssl模式下运行，终点这通过用户名和密码验证完请求用户之后，表示你将这样做生成令牌：","keyalg","keypass","keysiz","keystor","keystore.jcek","keystore.jceks)","keytool","lope","maven（在你的pom.xml文件里）","new","p","permission：","provid","provider.generatetoken(new","provider：提供者","rs256","rs384","rs512","rsa","rsassa","secret","sha","sha256withecdsa","sha256withrsa","sha384withecdsa","sha384withrsa","sha512withecdsa","sha512withrsa","sigalg","storepass","storetyp","string","todo展示了使用jwt的验证和授权的例子并解释了如何通过传入到授权的许可字符映射到jw令牌中的声明。","token","tokens实现auth。","token：","translat","us","valid","vertx","viettim","web","weiyiysw","{","}","令牌","令牌是一种简单的方法来发送明文信息（通常是url），其内容可以被验证为是可信的。像下面的这些场景jwt是非常适用的：","你可以使用jwtauth来创建一个提供者的实例，并指定一个json对象的配置。这是创建一个jwt","使用json","在一个单一的报名场景中，你想要有一个隔离的认证服务用可被信任的方式发送用户信息","在决定使用jwt之前，需要重点注意的是jwt并不加密payload，它仅对payload签名。你不应该使用jwt发送任何私密信息，相反你应该发送是不是私密的但要被验证的信息。举个例子，使用jwt发送一个签名过的用户id来表明这个用户已经登录了的做法非常对的。相反发送一个用户的密码的做法是非常非常错误的。","在验证的终点上，一旦你通过它的用户名/密码验证了用户的id","基本术语","它可以让你验证令牌的真实性","它完全是无状态的","它有一个json结构，可以包含任何你想要的变量和大量的数据","引用：http://vertx.io/docs/vertx","当keystore没有被提供，执行将会回滚到一个不安全的模式同时签名并不会被验证，如果payload被外部的方法签名或加密后的情况下这是非常有用的。","授权：bearer","无状态的server","生成keystore文件唯一需要的工具是keytool，运行的时候，你可以指定你需要使用的算法：","生成一个新的keystore文件","等等","要使用这个项目，将下面的依赖添加到构建描述符里的dependencies部分。","许可","这个组件包含了一个开箱即用的jwt实现。","这时任何请求受保护的资源你应该传入这个字符串到http头授权部分，像这样：","默认的情况下，实践将会查找这些别名，然而并不是所有的算法都需要存在。作为一个好的实践hs256应该存在：","：认证"],"auth/ShiroAuth.html":["\"classpath:test","\"sausages\");","\"tim\").put(\"password\",","'io.vertx:vertx","(res.succeeded())","*","//","3.2.1","=",">","anotherpassword,manag","apach","auth","auth.properties\");","authent","authentication：验证","authinfo","authprovid","authprovider.authenticate(authinfo,","auth尽可能的尝试轻便。然而，可以通过使用前缀role:或者通过setroleprefix指定你想要的前缀在一个角色上执行断言。","auth提供者实现","auth提供者的示例：","auth提供者的类型，并且也可以指定一个json对象的配置。","auth本身并没有授权任何特定的许可（它们仅是不透明的字符串）模型，这个的实现和","boolean","class","compil","config","config);","context","dn","do_actual_work","enabled：todo","factori","fail","failed!","fox","gradle(在build.gradle文件里)","haspermiss","hasrol","hispassword,develop","io.vertx","jsonobject","jsonobject().put(\"properties_path\",","jsonobject().put(\"username\",","julien","ldap","ldap_url：这个url是设置ldap服务器。这个url必须以ldap://开头，端口也必须要指定。这是一个示例ldap://myldapserver.mycompany.com:10389","maven（在pom.xml文件里）","mechanism：todo","mypassword,administrator,develop","name：todo","new","password：todo","permissions：权限","play_golf,say_buzzword","pool","properti","provid","provider：提供者","re","realm","realm);","realm从一个ldap服务器上获取","realm对象创建一个auth提供者的示例是可以的。","realm里。","realm：","referral：todo","res.result();","role.administr","role.develop","role.manag","role.{rolename}={permissionname1},{permissionname2},...,{permissionnamen}","shiro","shiro:3.2.1'","shiroauth.create(vertx,","shiroauthrealmtype.properties,","shiro从一个配置文件里获取","shiro的auth提供者的实现。","system","template：这是用来决定实际的查找使用当通过一个特定的id来查找一个用户的时候。一个例子是uid={0},ou=users,dc=foo,dc=com","translat","user","user.bob","user.isauthorised(\"newsletter:edit:13\",","user.isauthorised(\"role:manager\",","user.jo","user.tim","user.{username}={password},{rolename1},{rolename2},...,{rolenamen}","username：todo","users.properties。","users.properties的文件。如果你想要改变这个，你可以使用properties_path配置元素来定义属性文件的路径，默认的值是classpath:vertx","vert.x","vertx","viettim","weiyiysw","{","}","});","一个用户的行应该是这样的结构：","一个角色行应该是这样的结构：","使用shiroauth创建提供者的实例。使用shiroauthrealmtype指定shiro","使用一个预先创建的apach","使用另一个shiro","信息。","像下面这样做的：","基本术语","如果这个值得前缀是classpath:，将会在类路径查找那个名字的属性文件。如果这个值的前缀是file:，将在文件系统上指定一个具体的文件。如果这个值得前缀是url:，将会指定一个具体的url来加载这个属性文件。","尽管vert.x","当使用这种实现作为认证时，它需要在认证信息里获取username和password：","当描述一个角色使用通配符*时，说明这个角色拥有所有的权限。","我们使用shiro提供基于身份认证属性和ldap开箱即用的支持，你也可以使用插件，在任何其他的期望用户名和密码作为凭据的shiro","授权","接下来的这些配置属性是用来配置一个ldap","权限","模型类似，一个用户可以有0到多个角色，一个角色可以有0到多个权限。","每一行应该要么包含一个用户的用户名、密码和角色，要么包含角色的权限。","注意，角色在api里并不是直接可用的，因为这个事实，vertx","用户/角色/权限","要使用这个项目，将下面的依赖添加到构建描述符里的dependencies部分。","要验证一个用户是否有一个特定的权限，只需要简单的将权限传入到isauthorised像接下来这样做：","要验证一个用户是否有一个特定的角色，你需要在参数前面加上角色前缀。","角色模型","这个auth提供者的实现是使用apach","这个元素{0}是创建实际的查找时替换成用户的id。这个设置是强制的。","这个实现当前假定了在基本的验证中使用了用户名和密码。","这个属性文件应该遵从下面的结构：","这是一个使用apach","这是示例：","这是通过指定类型创建shiro","验证","默认的情况下，这个实现将会在类路径里查找一个名为vertx","默认的角色前缀是role:。你可以设置setroleprefix改变默认的。"],"auth/MongoDBAuth.html":["\"manager\",","\"sausages\");","\"tim\")","(res.succeeded())",")","+",".put(\"password\",",".put(\"username\",","//","1","3.2.1","512算法加密后进行存储，之后会连接对应的salt值，这个salt值和密码存储在同一个表里。你可以调用setsaltfield方法来改变存储salt值的字段名称，它的默认值是\"salt\"，你同样可以使用setsaltstyle来改变一些行为。通过调用gethashstrategy方法还可以读取hash策略设置。","=",">","auth","authentication：认证","authinfo","authorisation：授权","authority：权限","authproperti","authproperties);","authprovid","authprovider.authenticate(authinfo,","boolean","box）中包含了\"user\"集合（collection），用户名字段使用\"username\"进行存储和读取。","client","collection：集合，mongodb专用（概念稍同database的table）","column：vert.x会为每个用户创建一个\"salt“值，并且存储在用户表定义的列中；","compil","db.user.createindex(","document：文档，mongodb专用（概念稍同database中row）","external：vert.x仅仅将密码最终加密结果存储在数据库中，\"salt“值可以在外部使用，并且可以调用setexternalsalt方法进行设置。","fail","failed!","gradle（在build.gradle文件中）","handler：处理器","haspermiss","hasrol","index），你可以在mongodb服务器中运行下边的片段来完成此操作：","io.vertx","io.vertx:vertx","jsonobject","jsonobject()","jsonobject();","maven（在pom.xml文件中）","mongo","mongo/java/","mongo:3.2.1","mongoauth","mongoauth.create(client,","mongocli","mongoclient.createshared(vertx,","mongoclientconfig);","mongodb","mongodb中可以设置下边几种salt的值（参考下边warning）：","mongodb的特性是先查询username字段中的值是否已经存在，然后会插入一个document，并不能作为一个原子性操作，基于这个原因你需要添加上边的唯一索引，使用了这个索引过后你的代码会尝试先插入一行数据，如果出现了重复记录则会失败。","new","no_salt：密码就不会执行加密以明文的方式存储。","permission/role模型","permission：许可","principal：凭证","re","res.result();","role：角色","setcollectionnam","setpasswordcredentialfield","setpasswordfield","setpermissionfield","setrolefield","setusernamecredentialfield","setusernamefield","token：令牌","true","unique:","user","user.isauthorised(\"commit_code\",","user.isauthorised(mongoauth.role_prefix","username:","user：用户","vert.x","vert.x中提供了一个authprovider的实现，它可以让你使用mongoclient针对mongodb数据库执行认证和授权。若要在自己的项目中使用它，则需要在构建描述信息的dependencies节点中添加如下信息：","vert.x的默认标准配置（out","vert.x默认实现中的密码在数据库中使用了sha","vertx","{","}","});","},","一旦你创建了一个mongoclient实例后，就可以按照下边的代码创建mongoauth实例：","为了避免在\"user\"集合中出现重复的用户名，应该在\"user\"集合中给\"username\"添加唯一索引（uniqu","创建好上边的实例过后，你就可以使用任何authprovider针对mongodb执行认证和授权功能了。","基本术语","如果你想要重写上述行为，则你可以调用sethashstrategy方法设置新的hash策略，并且提供变更过的hash策略及配置信息。","如果想要替换上边的username和password两个默认字段名，你可以使用下边两个方法：","如果要创建一个客户端实例，你首先需要一个mongoclient的实例，要知道如何创建这个实例可按照文档中的内容实施。","如果要验证一个用户是否属于特定角色，则可以使用mongodb认证前缀（mongoauth.role_prefix）法给角色带上前缀表示：","如果要验证一个用户是否拥有特定的许可，则要将许可信息传递到isauthorised中：","如果认证使用了默认的mongodb实现，认证信息中用了username和password字段：","尽管vert.x自身并不要求使用特定的许可模型（它本身只是使用了不透明的字符串），但mongodb认证中的实现使用了比较熟悉的：用户/角色/许可模型，这样在应用里你可以使用一个或者多个角色，而一个角色也可以拥有一个或者多个许可。","引用：http://vertx.io/docs/vertx","强烈建议在设置“salt\"值时候使用external选项。no_salt选项仅仅推荐在开发阶段中使用，不仅仅如此，column方式也不推荐，因为它会导致salt和密码都存储在了同一个地方！","授权","根据你自己的需要，你同样可以使用下边的方法改变mongodb中使用的默认集合（collection）和列（column）名称等信息：","认证","！warn"],"auth/Oauth2.html":["\"","\"\")","\"\"));","\"/dialog/oauth\")","\"/o/oauth2/auth\");","\"/oauth/access_token\")","\"/oauth/access_token\");","\"/oauth/authorize\")","\"/oauth/authorize\");","\"/protocol/openid","\"/realms/\"","\"/uas/oauth2/accesstoken\");","\"/uas/oauth2/authorization\")","\"/users\",","\"3(#0/!~\"));","\"client_id\")","\"client_secret\")","\"http://localhost:3000/callback\");","\"http://localhost:8080/callback\")","\"http://localhost:8080/callback\"),","\"https://accounts.google.com\")","\"https://api.oauth.com\");","\"https://api.twitter.com\")","\"https://github.com/login\")","\"https://graph.facebook.com/oauth/access_token\");","\"https://www.facebook.com\")","\"https://www.googleapis.com/oauth2/v3/token\")","\"https://www.linkedin.com\")","\"https://www.your","\"notifications\")","\"password\");","\"username\")","\"xxxxxxxxxxxxxxxxxxxxxxxx\";","\"your_client_id\")","\"your_client_secret\")","(res.failed())","(res.succeeded())","(the","(token.expired())",");","+",".end();",".put(\"authorizationpath\",",".put(\"clientid\",",".put(\"clientsecret\",",".put(\"code\",",".put(\"password\",",".put(\"redirect_uri\",",".put(\"scope\",",".put(\"site\",",".put(\"state\",",".put(\"tokenpath\",",".put(\"username\",",".setstatuscode(302)","//","2","3.2.1","4.1","4.3","4.4","=",">","abov","access","accesstoken","applic","as:","auth","authentication：认证","author","authorisation：授权","authority：权限","authorization_uri","authorization_uri)","authz","back","call","callback","case","challeng","client","client）是很不错的（optimized）一种方式。作为一个基于重定向的流程，客户端必须能和资源拥有者的用户代理交互（通常是浏览器），同时要能接受从授权服务器（author","code","code).put(\"redirect_uri\",","code：授权码流程（对服务器和app可持久化存储信息）","compil","complet","connect/auth\")","connect/token\");","continue...","credenti","credentials);","credentials：客户端证书流程（客户端可仅仅可凭借客户端整数申请访问令牌【access","credentials：密码证书流程（之前的流程无法使用或开发阶段使用）","credential：证书","ended.","error","error,","error:","exampl","facebook","flow","github","given","googl","gradle（在build.gradle文件中）","handler：处理器","handling...","handshak","here...","initi","io.vertx","io.vertx:vertx","jboss","jsonobject","jsonobject()","jsonobject().put(\"access_token\",","jsonobject().put(\"code\",","jsonobject();","keycloak","librari","linkedin","maven（在pom.xml文件中）","method,","need","new","now","oauth","oauth2","oauth2.api(httpmethod.get,","oauth2.authorizeurl(new","oauth2.gettoken(new","oauth2.gettoken(tokenconfig,","oauth2/java/","oauth2:3.2.1","oauth2auth","oauth2auth.create(vertx,","oauth2flowtype.auth_code,","oauth2flowtype.client,","oauth2flowtype.password);","object","on","paramet","password","permission：许可","previou","principal：凭证","protect","provid","provider的认证示例实现代码：","re","realm","redirect","refresh_token","res.cause().getmessage());","res.result();","res1","res2","resourc","response.putheader(\"location\",","return","revok","revoked.\");","role：角色","save","section","server.com\")","server）得到访问令牌；","server）通过重定向发送过来的请求。","session","step).","still","string","success","system.err.println(\"access","system.out.println(\"token","token","token.principal().getstring(\"access_token\")),","token.refresh(r","token.revoke(\"access_token\",","token.revoke(\"refresh_token\",","tokenconfig","token】）","token）和刷新令牌（refresh","token），对安全性要求高的客户端（confidenti","token：令牌","twitter","uri","url","us","user","user：用户","valid","valid.","vert.x","vert.x中的oauth2支持下边三种流程：","vert.x的这个组件包含了标准的oauth2的实现。若要在自己的项目中使用它，则需要在构建描述信息的dependencies节点中添加如下信息：","vertx","web","work","{","}","});","下边是基于github中使用vert.x的oauth2","其他通用oauth2的provider配置示例","初探","基本术语","如果用户以第三方应用的方式访问想要的资源，oauth2可以对这些用户进行授权，任何时候可以根据用户想要都有可能启用或禁用它的访问权限。","客户端证书——client","客户端证书流程","客户端证书类型必须用于且仅用于机密客户端。","密码证书——password","密码证书流程","引用：http://vertx.io/docs/vertx","当一个令牌过期后你需要刷新令牌，oauth2提供了访问令牌类accesstoken，它包含了很多实用的方法可以在令牌过期过后对令牌进行刷新。","当你使用令牌访问完成过后想要注销，你可以撤销（revoke）访问令牌和刷新令牌。","当客户端想要申请访问控制之下受保护的资源时，或者其他资源拥有者先前被授权服务器托管时（这种方式超出了本文范畴），客户端仅仅可以使用客户端证书（或者其他表示认证含义的信息）申请访问令牌。","授权码——author","授权码授权类型可以用来获取访问令牌（access","授权码流程","授权码流程主要包含两部分内容：","更多：oauth2","示例代码：","第一步，你的应用客户端向用户申请允许访问它们的数据，如果用户审批后，oauth2服务器发送给客户端一个授权码；","第二步，客户端将这个授权码和客户端密钥放到post请求中发送给授权服务器（author","访问令牌对象","资源拥有者密码证书授权类型比较适合于这样一种情况：当资源拥有者和客户端之间有可信任的关系时使用，如设备操作系统、或高特权应用。授权服务器应该在很特殊的情况时启用这种授权类型，并且仅仅当其他应用都不可见时允许使用这种类型。","这种类型对于客户端要获取资源拥有者证书是合适的。","这种类型对于客户端要获取资源拥有者证书（用户名和密码，通常使用交互式表单）是合适的。它用于从已经存在的直接使用认证模式的如basic或digest的客户端向oauth2认证方式迁移的时候，它会将证书直接转换成oauth2中的访问令牌。"],"reactive/Reactive.html":["reactiv","vert.x","提供了数个组件，可以使你的应用更具有响应性（reactive）。"],"reactive/Rx.html":["\"","\"/the_uri\").toobservable().subscribe(","\"/the_uri\");","\"current","\"http://the","\"localhost\");","\"localhost\",","()",").listen(observable.tohandler());",");","*observ","+",".createhttpserver()",".rxlisten(1234,","//","03","1","100,","10秒后注销","15","15:54:14","2017","8\")));","8\"));","8080,","=",">","@overrid","abstractverticl","action0","action1","actions），我们可以通过","address\");","along)","api","api。","api，有两种方式：","asyncfil","blockingobservable.observeon(scheduler);","bodi","bodystream().","bu","buffer","buffer(1,","buffer.tostring(\"utf","called\"),","cet","class","client","client.request(httpmethod.get,","client.websocketstream(8080,","closed\");","cold","collect(collectors.averagingdouble(d","connect","connect\"),","consum","consumer(\"heat","consumer.bodystream().toobservable();","consumer.toobservable();","core","d))).","data.tostring(\"utf","data:","dataob","dataobs.subscribe(buff","deploy","deployment.subscribe(id","e)","eb","eb.consumer(\"th","embed","end","err","error","event","eventbu","extend","failur","feed\",","file","file.toobservable();","filesystem","filesystem.open(\"/data.txt\",","fire","flatmap","flatmap(httpclientresponse::toobservable).","flow：流","foreach(","fs","fs.open(\"/data.txt\",","get.subscribe(resp","getobservable();","groovi","handler","handler1","handler2","handler3","handler>","handler：（事件）处理器","heat","heat);","here","hook","hook.getcomputationscheduler());","hook.getioscheduler());","hook.getnewthreadscheduler());","hot","http","httpclient","httpclientoptions());","httpclientrequest","httpclientrespons","httpserver","httpserveroptions().","httpserverrequest","http客户端请求","http服务端请求","id","io","io.vertx.core.vertx","io.vertx.rxjava","io.vertx.rxjava.core.abstractverticl","io.vertx.rxjava.core.rxhelper.scheduler(vertx);","io.vertx.rxjava.core.rxhelper.scheduler(workerexecutor);","io.vertx.rxjava.core.rxhelper.schedulerhook(vertx);","io.vertx.rxjava.core.vertx.vertx();","item：对象","java","javascript","json","json解码","jvm","lift(io.vertx.rxjava.core.rxhelper.unmarshaller(mypojo.class)).","lift(io.vertx.rxjava.core.rxhelper.unmarshaller(mypojo.class));","lift：变换","listen","loop","map(sampl","map/reduc","messag","messageconsum","mypojo","myverticl","never","new","o)","ob","observ","observable#tim","observable.","observable.foreach(","observable.foreach(data","observable.interval(100,","observable.lift(io.vertx.rxjava.core.rxhelper.unmarshaller(mypojo.class)).subscribe(","observable.lift(rxhelper.unmarshaller(mypojo.class)).subscribe(","observable.subscribe(","observable.subscribe(id","observable.subscribe(msg","observable.subscribe(rxhelper.tosubscriber(handler1));","observable.timer(100,","observable.tohandler());","observable>","observable>：","observablefutur","observablehandl","observable。","observable，即不管是否有订阅，它们都会产生通知。","observable：","observer()","observer：观察者","oncomplet","oncomplete);","oncompleted()","onerror","onerror(throw","onerror);","onerror,","onnext","onnext(httpserv","onnext(long","openoptions(),","operator：操作符","periodicstream","pojo","pool）创建调度器也是可以的，如果你想为了调度阻塞操作复用特定的线程池，这将会很有帮助：","process","public","pump","pump.pump(readstream,","pump.start();","reactiv","read","readstream","request","request.","request.end();","request.toobservable().","request.toobservable().subscribe(","request.toobservable();","requestobserv","requestobservable.subscribe(request","requeststream","respons","response);","response.toobservable();","result","result.result();","rx","rx*","rx.observ","rx.observable.oper","rx.observable.operator（rx","rx.observable：","rx.schedul","rxfifi","rxhelper","rxhelper.blockingschedul","rxhelper.blockingscheduler(vertx);","rxhelper.deployverticl","rxhelper.deployverticle(vertx,","rxhelper.get","rxhelper.get(client,","rxhelper.observablefutur","rxhelper.observablefuture();","rxhelper.observablehandler();","rxhelper.schedul","rxhelper.scheduler(vertx);","rxhelper.schedulerhook","rxhelper.schedulerhook(vertx);","rxhelper.tofuture(observer);","rxhelper.tofuture(onnext);","rxhelper.tofuture(onnext,","rxhelper.tohandl","rxhelper.toobserv","rxhelper.toobservable(file);","rxhelper.toreadstream","rxhelper.toreadstream(observable);","rxhelper.unmarshal","rxifi","rxified：rx化","rxjava","rxjavahooks.setoncomputationscheduler(f","rxjavahooks.setonioscheduler(f","rxjavahooks.setonnewthreadscheduler(f","rxjavaschedulershook","rx化的","rx化的辅助类也能做同样的事：","samples.","schedul","scheduler);","scheduler。rxhelp","second\");","sensor\").","sequences：可观察序列","server","server\");","server.requeststream().toobservable();","server.websocketstream().toobservable();","serverwebsocket","sethost(\"localhost\")","setport(1234).","singl","single.","single.subscribe(rxhelper.tosubscriber(handler2));","socket","socket.toobservable();","socketobserv","socketobservable.subscribe(","start","start()","stream().","stream：可写流","stream：可读流","sub","sub.unsubscribe();","subscrib","subscribe(","subscribe(heat","subscribe(new","subscriber()","subscriber，然后将其注册在","subscriber：订阅者","subscript","subscription(n.)：订阅","system.out.println(\"callback","system.out.println(\"got","system.out.println(\"read","system.out.println(\"should","system.out.println(\"subscript","system.out.println(\"web","timer","timerstream","timer：定时器","timeunit.milliseconds,","timeunit.seconds).","tohandl","toobserv","toobservable().","toobservable();","unmarshall：重组","unsubscribe();","us","vert.x","verticl","verticle);","verticle）：","vertx","vertx.createhttpclient(new","vertx.createhttpserver(new","vertx.eventbus().","vertx.eventbus().send(\"new","vertx.eventbus();","vertx.filesystem();","vertx.periodicstream(1000).","vertx.settimer(1000,","vertx.settimer(10000,","vertx.timerstream(1000).","vertx.vertx","void","websocket","websocket客户端","websocket服务端","worker","write","ws","{","{}","{};","}","});","},","};","·io.vertx.rxjava.core.vertx·类。","“冷的”(cold)，对应的","上一个流行的库，用于组合异步的、使用可观察序列的、基于事件的程序。","上：","下面的代码也是可以的（直接基于action）：","不能部署一个已经存在的","不需要特别的部署器，使用","与","中","中反映处理。","中英文对照表","中获取单个","中，有些操作通常会有接受一个","为包名前缀，例如","之间互相转化的静态方法。","也是可以的。","也能被配置成使用","以","以一个现有的","作为verticl","保持一致。","关于","出错了","原文档","原文档最后更新于","参数的重载方法用于设定","变换为对象的","只有当订阅发生时，才会开始发射数据，而","只需使用","可以被映射为单个元素的","可以被适配为","可读流支持","可读流转换为","可读流：","同样的，将一个","吧。","周期性的任务可以通过","和","回调","在","在创建完成后就会开始发射数据。更进一步的信息请查阅","在构造(construct)发生时，作为异步方法的最后一个参数的","基于一个命名的工作线程池（name","增强的rx化的","处理","处理响应","处理器支持","处理对象","处理请求","复制了类似的每一个方法，并冠以","定时器","定时器任务可以通过","实例。rxhelper.observablefutur","对于通过订阅执行一个","对于阻塞型的可调度操作（block","对象。如果端口监听失败，订阅者将会得到通知。","对象。这是一个","对象。这这是一个","对象为基础，你可以创建一个","对象可以轻松地转换为","对象的一次性回调，请求错误同样会在","对象，它的","对象，这个操作符的作用是将","对象：","并返回包含部署","异步结果支持","当","当回调失败时，观察者的","当回调成功时，观察者的","很自然地，messageconsum","我们可以从","或","所有工作都在","执行请求","扩展库需要执行一些可调度的操作，例如","接口的实现：","操作也能获得同样的流：","操作符）供重组操作使用：","操作这里使用了阻塞型的调度器：","方法为此提供了一个解决方案。","方法为观察者（observer）和事件处理器（handler）做了适配：","方法会立即被调用。","方法会返回","方法创建了一个","方法创建的调度器钩子对象。对于","方法可以创建一个","方法可以将响应当成","方法可以用来解析","方法对到达的每个请求都提供了回调：","方法对此提供了一次性的回调：","方法将创建一个能周期性发射事件的定时器并返回之。缺省情况下，这些可调度的操作由","方法将在注册时被调用。","方法将被调用。","方法将被调用，参数就是这个对象；且其后","方法提供了带有","方法是很适合的：","方法来创建：","方法获得消息体组成的新流：","方法获得适用的调度器：","方法都会提供一次回调：","方法里自动完成，它会部署一个","方法，其返回的调度器可供","方法：","无法连接","是","是不同的。当方法被调用时，它会返回一次性的","是所谓","有“冷热”(cold/hot)之分。区别在于","有时候","未提供针对","来处理：","样例","格式的请求并将其映射为对象：","每当有新连接到达时，websocketstream","注意：类似","消息流","版本一样。这个","用于将","的","的一个代码自动生成版本，就像","的前缀，它们都返回","的文档。","的方法替换了以前版本中","的方法，这样一个语义上的改变是为了与","的概念和","的流，如果需要，还可以通过","的订阅：","的调度器，这得益于","的这些方法使用。比如：","管理，这意味着定时器线程并非","类上提供了","类中也提供了相似的方法：","类可以创建","类提供了","类提供了一个","类提供了相关的","类是一对完美的匹配：都提供了一个对象流。","类被转化为","类，它会做一些包装（你将获得一个","类，这个辅助类提供了用于","线程上执行的。","线程，因此（这些操作）并不是在","组件源码","组件示例","组合风格在这里是相当有用的：","而","获得响应","获得消息","要使用","警告：执行","订阅绑定端口的事件","让我们通过研究一些样例来了解相关","译者注：在","请求时，这个","请求这样的需求，利用","调度器支持","转变为","转换为","辅以","这样的","连接上或失败时，websocketstream","通过","通过原始的","通过基于","通过注销操作可以取消对","通过继承","通过静态方法","部署verticl","部署一个","部署器即可。","部署失败","部署成功","里，observ","重组为对象。这个方法创建了一个","集成起来很自然：它使得无论什么时候，只要我们能使用流和异步结果，就能使用","静态方法","，我们也能将"],"reactive/Reactivestreams.html":["'io.vertx:vertx","//","03","15","15:54:14","2017","3.4.1","=","akka","akka）获得一个发布者，并将其数据泵入到服务端的","back","build.gradl","cet","compil","core","gradle（在","http","io.vertx","io.vertx.core.streams.pump，可以在将数据从一个流泵到另一个流时，实现流量控制。更多关于","io.vertx.core.streams.writestream","jvm","maven（在","otherpublisher.subscribe(rrs);","pause，resume，writequeueful","pom.xml","pressure：背压机制","publisher(n.)：发布者","pump","pump.pump(request,","pump.pump(rrs,","pump.start();","reactiv","reactivereadstream","reactivereadstream.readstream();","reactivewritestream","reactivewritestream.writestream(vertx);","read","readstream","readstream中一样读取数据（例如使用一个","response);","rr","rw","rws);","rws.subscribe(othersubscriber);","stream","stream(n.)：可写流","stream(n.)：可读流","streams:3.4.1'","subscribe(v.)：注册","subscriber(n.)：订阅者","vert.x","vertx","write","writestream","writestream一样，往其中写入数据（例如使用一个","writestream）。","、","上","上进行非阻塞的带背压机制的异步流处理，","中发布者和订阅者的角色；这使得我们能够以对待","中背压机制传播方面的方法（在请求更多数据项时）。","中英文对照表","中读写流的方式处理任意","为了支持在","你可以把这个类的实例传递给任意的","使用","做了一些初创性的工作来提供这样一份标准。","原文档","原文档最后更新于","发布者（例如来自","可读流的背压时，你会用到","同样的，我们为","和","响应","响应体中。其间，背压机制是自动执行的。","在另外的发布者上注册订阅者","在可写流上注册另外的订阅者","在处理流式数据方面，vert.x","在手动处理","实现中（例如","实现拿到订阅者之后，将服务端的请求体泵入其中。其间背压机制将自动运行。","将","将数据从可读流泵入","我们为","把从","把数据从这个流泵到一个","接口提供了实现类","文件中）：","有自己的机制；通过这三个类：io.vertx.core.streams.readstream","来的数据泵入其中）。","标准的实现。","流方面的信息请查阅","的","的发布者和订阅者。","的发布者角色的实现。拿到任意的","的发布者），随后你就可以像从其他任意的","的订阅者角色。","的订阅者）之后，你就可以像处理其他任意的","组件源码","组件，需要在构建描述符中添加如下依赖：","要使用","订阅者（例如来自","请求泵入可写流","这个库为可读流、可写流都提供了实现，这两者分别扮演了","这个库提供了","这些方法；它们会在内部被自动转换成","这里有个例子，从其他的","这里有个例子，从某个其他的","部分的手册。","，它也是","，它同样也实现了"],"reactive/Sync.html":["\"","\"blah\",","\"localhost\");","\"ping\",","(int","+","//","03","0;","10","15","15:54:14","2017","=",">","@suspend","adaptor","adaptor.receive();","address","address\").handler(adaptor);","address\",","agent","api","awaitevent(h","awaitresult(h","bu","bytecod","cet","consum","consumer:","core","core.jar","coroutine)。fib","eb","eb.consumer(\"som","eb.send(\"som","eb.send(\"someaddress\",","enable_vertx_sync_ag","end","event","eventbu","exampl","fiber","fiber(译者注：这个词国内有译作纤程，类似协程","fiberhandl","fiber。","fiber。字节码增强工作是在运行时使用","fired\");","h));","handler","handler>","handlerreceiveradaptor","handlerreceiveradaptor>","handler（译者注：关于","handler）","http","instrument","instrumentation)的技术实现了","instrumentation，指非运行时织入字节码)的效果。更多细节请参考","instrumentation：字节码修改/增强","io.vertx.ext.sync.syncverticl","jar","jar包为","java","javaagent:/path/to/quasar/core/quasar","jvm","kernel","long","maven","messag","message:","mongo","now","plugin","quasar","receiv","received1","received1.body());","repli","reply.body());","reply:","repositori","req.response().end(\"blah\");","request)。","respons","send","streamadaptor();","sync","sync.awaitev","sync.awaitresult","synchron","syncverticl","system.out.println(\"got","system.out.println(\"receiv","system.out.println(\"tim","thread：内核线程","tid","ture，这样可以启用","vert.x","verticl","verticle，其部署方法和其他","vertx","vertx.createhttpserver().requesthandler(fiberhandler(req","vertx.eventbus();","vertx.settimer(1000,","wait","{","}","})).listen(8080,","——","。","。异步","一节）的执行。这是通过","上面的例子中，在回应返回前，fiber","下面是一个","中使用","中英文对照表","为","为了使这个特性正常工作，需要在启动","也能以同步的方式获得一次性的事件，例如定时器的触发，或者","事件流","会一直被阻塞住，而内核线程不会。","会在","作为最后的参数，例如用","你也可以使用","你可以把它当成一个普通的","你需要一个同时实现了","使你能以同步的方式从这种流中接收事件。","使用","例如","借助","写好的","前设置环境变量","包：","原文档","原文档最后更新于","参数会在运行时传给此","可以有多种风格，包括回调、promise和rx风格。vert.x","可以让你在熟悉的同步风格下继续使用异步","可以让你用同步的方式得到这种一次性的异步操作的结果。这是通过调用","命令行工具，可以在执行","和","在","在vert.x","在此，通往自由之路的功臣乃","在绝大多数地方使用回调(尽管它也支持rx)。","如果你想在一般的","如果你用的是","完全一样。","官方文档。","客户端执行一次查询或者发送一个","库来实现","库，你的代码需要继承","库，这个库借助字节码增强(bytecod","当前只适用于","很多时候，vert.x","技术完成的。","接口的","接口的方法来同步地接收事件。","接收到的是事件流，例如","文档中","方法可以创建这样一个实例。","方法完成成的。","方法完成的。调用这个方法时，需将想要执行的异步操作包装成","时指定","时，错误的传递也会变得更复杂。","是一组工具集，其特点是在不阻塞内核线程的同时，允许用户以同步的方式接收事件、执行异步操作。","是超轻量级的线程，并不是对应于底层的那种内核线程，它们被阻塞时不会导致内核线程也被阻塞。","更多示例","服务器与客户端","服务端的请求处理器（request","服务端请求(server","服务端里的","某些情况下，使用异步","比起很多历史遗留的应用系统，vert.x","注意：vert.x","注解。","消息消费者的例子：","消息然后拿到回应。","消息的消费者(consumer)、http","用到了","的","的一个关键优点是完全非阻塞(于内核线程而言)","的例子可以参见","的形式。handler","的用法。","的配置。","的领域里，很多操作都会接受一个","看下面的例子：","看例子：","简介","类实例。sync.streamadaptor","类，并重载start()方法和stop()方法(stop","组件源码","组件示例","编程比直接使用同步","获得一次性的事件","获得一次性的异步操作结果","要使用","要更具挑战，特别是当你有好几个操作要按顺序完成时。同时，使用异步","转换为","达成离线增强(offlin","这些方法还必须加上","这使它用少量的内核线程就可以处理大量的并发(例如，处理很多的连接、消息之类)，具有优异的可扩展性。","这里有一些示例，展示了","里运行那个一般的","非必需)。","非阻塞性的特性产生了异步的","，然后可以用实现自","，那得首先把这个一般的"],"microservices/ServiceDiscovery.html":["!=","\"*\"","\"*****\"));","\"*****\"),","\"/api\"","\"/api\");","\"/api\",","\"127.0.0.1\")","\"a\"","\"a\",","\"a\"}","\"address\",","\"clement\").put(\"password\",","\"color\"","\"examples.mydata\"","\"examples.myservice\",","\"localhost\")","\"localhost\"),","\"localhost\",","\"name\"","\"records\")","\"red\"","\"red\",","\"red\"的记录","\"some","\"the","&&","'io.vertx:vertx","(ar.result()","(ar.succeeded()","(ar.succeeded())","(build.gradl","(pom.xml文件中)：","));",");","*","...",".put(\"host\",",".put(\"key\",",".put(\"port\",",".put(\"scan",".put(\"som",".registerserviceimporter(new",".send(respons",".setannounceaddress(\"servic",".setbackendconfiguration(",".setlocation(new",".setmetadata(new",".setname(\"mi",".settype(\"eventbu","//","03","15","15:54:14","2000","2000));","2017","3.4.0开始，vert.x提供了另一种更高层次封装、更方便使用的http客户端","3.4.1","8080,","8433,","8500","8500)","=","=>",">","abstractservicereference#close()方法。","addit","address","address\"","address\"))","address\",","address,","agent","agent（服务器），并且会进行周期性的扫描，来更新服务情况：","alreadi","announce\")","api\",","api或可以通过http请求访问的服务。http","api接口。它不能将服务导出到consul，并且也不支持服务的修改。","api服务提供的类型，服务对象的类型是一个配置好了host和port的httpclient（其location表现为一个url）","api等等。vert.x","ar","ar.result()","ar.result(),","ar.result();","attach","backend","backend组件是基于redis的后端存储实现。","bridg","bu","build.gradl","bus中的地址是","bus中都会触发一个事件，这个事件包含着被修改的服务记录。","bus发送消息到某个地址的组件。消息源服务的client是","bus地址、ip/dn","bus实现的一种异步rpc服务。当从一个ev","bus服务中获取一个服务对象时，你实际上得到的某个服务类的服务代理。你也可以使用","bus服务，你可以通过先获取到服务记录然后获取服务引用的方式，也可以直接通过","bus服务，你需要创建一个","bus的address地址）","cet","class","classpath","client","client);","client...","client.get(\"/api/persons\")","client.get(\"/api/persons\").send(","client.getnow(\"/api/persons\",","client、消息消费者","close","compil","complet","conf);","connection\"),","consul","consul:3.4.1'","consulserviceimporter(),","consum","consumer);","consumer.handler(messag","createrecord","creation","data","depend","discoveri","discovery.close();","discovery.getrecord(","discovery.getrecord((jsonobject)","discovery.getrecord(new","discovery.getrecord(r","discovery.getrecords(new","discovery.getrecords(r","discovery.getreference(ar.result());","discovery.getreference(record1);","discovery.getreference(record2);","discovery.getreferencewithconfiguration(","discovery.getreferencewithconfiguration(record,","discovery.publish(record,","discovery.publish(record1,","discovery.unpublish(record.getregistration(),","discovery:3.4.1'","discovery中搜索服务，每次搜索得到的结果是0..n条服务记录（record）。通过这些服务记录，消费者可以获得服务引用（servicereference）。服务引用的作用是绑定服务消费者和服务提供者。通过服务引用，消费者可以得到服务对象来使用服务，也可以通过服务引用释放服务对象。","discovery实例","docker","dockerlinksserviceimporter(),","done","dont'","down：服务不再可用","else,","empty,","endpoint","endpoint:","endpoint服务","endpoint服务发布好了，服务消费者就可以获取到这个服务。对应的服务对象是一个","endpoint服务对象就是一个配置了host、port和ssl的","endpoint服务，你需要一个","endpoint类型。","event","eventbu","eventbusservic","eventbusservice.createrecord(","eventbusservice.getproxy(discovery,","executeblock","fail","filter","forget","futur","future。如果桥接器的启动方法是阻塞型的，那么就必须使用","get","getrecord","getrefer","getx","gradl","gradle（在","handler","host","http","httpclient","httpendpoint","httpendpoint.createrecord(","httpendpoint.createrecord(\"som","httpendpoint.getcli","httpendpoint.getclient(discovery,","httpendpoint.getwebclient(discovery,","id","inf/services/io.vertx.servicediscovery.spi.servicetype文件，并把这个文件打包到自定义类型的jar包中，在这个文件中，需要标明第二步中所创建类的全限定名。","instanc","interfac","io.vertx","jdbc","jdbcclient","jdbcclient，你需要同时提供：服务记录位置信息、元数据以及服务消费者提供的json对象：","jdbcdatasourc","jdbcdatasource.createrecord(","jdbcdatasource.getjdbcclient(discovery,","jdbc数据源服务，服务对象的类型是一个jdbcclient（该client的配置参数，将从location、元数据和服务消费者传递的参数中获取）","jsonobject","jsonobject()","jsonobject());","jsonobject().put(\"connection_string\",","jsonobject().put(\"endpoint\",","jsonobject().put(\"name\",","jsonobject().put(\"som","jsonobject().put(\"url\",","jsonobject().put(\"username\",","jsonobject.class","jsonobject.class,","kubernet","kubernetes.nam","kubernetes.namespace,","kubernetes:3.4.1'","kubernetes中的服务，在导入到vert.x后都会创建对应的服务记录（record）。服务类型是通过","kubernetes的所有服务，都将映射为一条","label\")),","label\",","link","links:3.4.1'","list","locat","location信息将从服务的第一个端口推断出来","lookup","match","maven","maven（在","messag","message.body();","messageconsum","messageconsumer。","messagesourc","messagesource.createrecord(","messagesource.getconsumer(discovery,","metadata","metadata\",","mongo","mongocli","mongoclient。","mongoclient，你需要同时提供：服务记录位置信息、元数据以及服务消费者提供的json对象：","mongodatasourc","mongodatasource.createrecord(","mongodatasource.getmongoclient(discovery,","mongodb","mongo数据源服务，服务对象的类型一个mongoclient（该client的配置参数，将从location、元数据和服务消费者传递的参数中获取）","ms","myservic","myservice.class","myservice.class,","name","name\"));","name\"),","name\",","need","new","null)","null,","oauth","object","object,","ok","openshift","out_of_service：服务目前不可用，但是过段时间会继续提供服务。","path","payload","period","period\",","pom.xml","port","pox.xml","predicate，即判断函数）","proxy\")","public","publish","publishedrecord","r.getname().equals(\"som","record","record()","record1","record2","record。目前桥接器只支持将服务从kubernetes中导入到vert.x中（反过来不行）。","record：","redi","redis:3.4.1'","rediscli","redisclient。","redisclient，你需要同时提供：服务记录位置信息、元数据以及服务消费者提供的json对象：","redisdatasourc","redisdatasource.createrecord(","redisdatasource.getredisclient(discovery,","redis存储后端是基于","redis数据源服务，服务对象的类型是一个redisclient（该client的配置参数，将从location、元数据和服务消费者传递的参数中获取）","refer","reference.get();","reference.getas(httpclient.class);","reference.getas(jdbcclient.class);","reference.getas(messageconsumer.class);","reference.getas(myservice.class);","reference.getas(redisclient.class);","reference.getas(webclient.class);","reference.release();","reference1","reference1.getas(httpclient.class);","reference1.release();","reference2","reference2.getas(messageconsumer.class);","reference2.release();","registerserviceimport","releas","removed,","requir","respons","rest","result","retriev","return","root","scan","servic","service\")","service\"),","service\",","service);","service,","service.typ","service.type.l","servicediscoveri","servicediscovery.create(vertx)","servicediscovery.create(vertx);","servicediscovery.create(vertx,","servicediscovery.releaseserviceobject","servicediscovery.releaseserviceobject(discovery,","servicediscoverybackend","servicediscoveryopt","servicediscoveryoptions()","serviceimport","servicerefer","servicereference）并且使用这个服务","servicetyp","someth","sourc","source）等等。","spi接口，可以自定义服务类型：","spi提供了一种可插拔的存储后端扩展机制。","string","succeed","succeeded,","then,","token（默认是使用/var/run/secrets/kubernetes.io/serviceaccount/token中的内容）","true","true,","type","type:","un","up：服务已经可以使用了","url\"),","url、用户名、密码等）。这些属性既依赖于数据库，同时也依赖于所使用的连接池。","v3）中导入服务到vert.x的服务发现组件中。","value\")","value\"));","value\"),","value\".equals(r.getmetadata().getstring(\"som","vert.x","vert.x服务发现框架还提供了一些现成的后端存储机制支持。","vertx","vertx.discovery.announc","vertx.discovery.announce，你可以自己配置一个（查看服务使用章节）。","vertx.discovery.usag","webclient","webclient。你可以通过如下方式来获取一个","whether","{","}","})","});","—","一个","一个接收","一个服务提供者可以：","一个服务消费者可以：","一定要保持一个指向服务记录对象的引用，因为这个返回的服务记录会带有一个","一旦一个http","一旦使用完后释放服务对象","下面是一个示例：","下面是一些例子：","下面的代码片段，展示了如何通过","不要忘记释放服务对象！","中。然后，这个自定义类型就可以使用了。","中导入服务到","中指定一个spi的实现；如果没有指定，那么将使用默认的存储后端。","中推断出服务类型；如果没有设置，那么服务类型被设置为unknown","中的服务导入到vert.x的服务发现组件中。","中移除的服务将会被移除","中，用来跟踪服务的使用情况。","为rest","为服务提供者创建一个服务记录","从","从vert.x","从上面可以看出，服务提供者和服务消费者，通过服务记录来共享关键的信息。","你也可以使用","你也可以利用","你也可以直接传递服务接口类：","你也可以通过setusageaddress方法，将事件发送地址设置为null，这样就可以禁用服务使用情况的监听功能了。","你可以做一些配置：","你可以获取一条服务记录，也可以通过","你可以通过","使用","使用servic","使用完后，不要忘记释放服务引用。","使用这种服务，将不会产生服务使用的事件。","保存这个发布记录的引用，后面可以用来取消发布或者修改发布","值为","做一些事情。。。","关于服务事件的更详细内容参考后续章节。","其中","其中location是一个json对象，包含了访问mongo数据源的所有属性（url、端口等）","其他存储后端","创建meta","创建servic","创建一个实现了","创建一个继承io.vertx.ext.discovery.types.abstractservicereference的类。你可以对类进行参数化，添加上你要返回的服务对象的类型信息，你必须实现abstractservicereference#retrieve()这个方法，在这个方法中创建服务对象，这个方法只会被调用一次，如果你的服务对象需要释放资源，那另外还需要覆写","创建时，我们同时指明了消息体（payload）的类型，这不是必须的。","前面提到，服务发现使用了服务类型的概念，来封装各种服务的差异性。","动态性","匹配所有\"color\"","匹配所有名称为","匹配所有名称为\"a\"的记录","匹配所有设置了","原文档","原文档最后更新于","发布","发布event","发布http","发布一个","发布一个服务记录","发布服务","发布服务记录","发布消息源服务","发布这个服务记录","发布这条服务记录","取得可访问的","取消发布的服务","另外一种写法，通过对应的服务类型接口获取的方式：","可以通过","可用的服务发现桥接器","号来代表必须存在某个key值，而不管value值","和","和其他服务类型一样，发布","和其他服务类型一样，发布一个消息源服务包含两个步骤：","在","在java中，你可以使用","在使用完服务后，必须释放服务引用，才能清理服务对象和更新服务使用状态。","在前面的示例中，代码中使用的是getas方法，参数是你期望获得的对象类型。如果你使用java语言，那么可以直接用get方法，而其他语言中，你必须传递对象类型。","在服务消费端，你可以手动获取服务记录和服务引用，也可以使用","在服务消费端，第一步要做的事情就是查找服务记录。你可以查找并获取一条服务记录，也可以获取一批满足条件的记录。如果是获取一条记录，那么将返回第一条满足条件的服务记录。","在第二个","在第二种写法中，服务对象的释放是通过","在默认情况下，服务事件发送到event","地址。","基本概念","如何定位服务（uri、ev","如前所述，访问数据源的方式依赖于数据源本身。要创建一个","如果json过滤器未设置（为空或null），获取时将获取到所有的服务记录。当使用函数形式时，要获取所有的服务记录，你只需要返回","如果使用","如果知道服务的类型（jdbc客户端、http客户端），整个过程就可以简化为通过服务类型直接获取服务对象。","存储后端","存储后端，需要将如下的依赖包加入到依赖配置文件中：","实例。","实例。这些实例通过底层的分布式数据结构来协同保持服务集合的同步。","实例来使用服务发现模块：","实例，就可以发布服务了。发布的流程如下：","实例，并且已经配置好了host和port参数。","实例：","实现的，所以配置内容和","对于","对象。","对象。你可以通过调用httpendpoint.createrecord创建这样一个服务记录对象。","对象时，不要忘记关掉它（通过","对象的函数，这个函数返回一个布尔值（就是一个","对象）来描述服务提供者提供的服务，它包含了服务名称、一些元数据和一个描述服务所在位置的位置对象。","对象：","将已经发布的服务记录注销","将第一步的服务接口、第二步第三步的实现类以及第四步中的服务描述文件打包成一个jar包，然后将这个jar包放到你应用的","属性一致。","属性中记录了事件的类型，类型分为bind和releas","属性中记录了服务发现实例的id（服务发现实例的名称或节点id）","属性中，包含了服务记录信息","属性，配置","属性，配置扫描的频率，扫描的单位是毫秒（ms），默认是","并且\"color\"值为\"red\"的记录","并且能够读取所选择的命名空间。","当你不再需要","当你在容器或云上部署你的服务时，可能你不能确定公开的ip地址和端口。所以，服务的发布必须通过其他拥有这些信息的实体来进行，这通常是一个桥接对象（bridge）。","当你将一个docker容器与另外一个docker容器链接在一起(link)的时候，docker将会注入一组环境变量。该桥接器将分析这些环境变量，并且针对每个链接(link)，生成一个服务记录。服务记录的类型从service.type.lable属性中推断；如果没有设置，那么服务类型将被设置为unknown。目前暂时只支持","当你选择好了服务记录后，你就可以获得到一个servicereference，然后得到服务对象：","当使用","当使用json过滤器，设置status属性为你想要的值（或者","当使用函数过滤器，将","当使用完后，释放绑定的服务","当使用服务引用的方式，你需要如下方式：","当服务发现实例被关闭的时候，对应的桥接器也一块被关闭了。执行关闭操作的时候，服务发现组件会调用","当服务提供者准备好可以提供服务时，会发布一条服务记录，在服务停止的时候，会收回这条服务记录。","当桥接器注册后，start","我们用服务记录","所传递的","接口中的辅助方法来完成服务对象的查找和获取：","接口创建一个","接口创建一条服务记录","接口创建服务记录","接口就可以了。比如，vert.x还通过实现该接口提供了基于redis的存储后端。","接口或者第一步定义的接口的类，这个类必须有一个","接口提供的辅助方法直接获取。","接口时，你可以通过如下方式获得代理对象：","接口的辅助方法来查询和获取服务对象：","接口的辅助方法来获得服务代理。","接口的辅助方法，来查询和获取服务对象：","接口，代码如下：","接口，将两步合并成一次方法调用。","接口，然后再使用","推断出来的。如果该属性没有设置，那么服务类型被设置为unknown。目前暂时只支持","提供了一个服务发现的基础组件，用来发布和发现各种类型的资源，比如服务代理、http端点（endpoint）、数据源（data","提供服务的对象的性质（服务代理、http","提供的一种服务类型，对应的服务对象是","收到的record中有个status字段，用来表示服务的状态：","收到的消息是一个包含如下内容的jsonobject对象：","数据源","数据源可以代表各种类型的数据库，而这些数据库的访问方式一般是不同的，服务记录很难有统一结构。在服务记录中，locat","数据源指的是数据库或数据存储。jdbc数据源通过jdbc驱动访问数据库，jdbc数据源服务对象是是","数据源服务","数据源服务共两个步骤：","数据源服务是专门为","数据源服务是专门为redis提供的服务类型，对应服务对象是","数据源服务需要两步：","文件中)：","文件中）：","文件中）：compil","新的服务被导入","方法以及","方法以进行资源的释放以及移除导入/导出的服务。这个方法必须调用所传递的","方法和一个用来创建","方法将会被调用，这样你可以对桥接器进行一些配置。当桥接器配置好了，已经准备导入导出初始的服务时，必须","方法注册一下。你可以通过第二个参数传递一些可选的配置信息给桥接器。","方法的参数includeoutofservice设置为tru","方法获取一个服务引用或者通过","方法获取所有匹配到的服务记录。默认情况下，服务查找只会包含状态为up的服务，可以通过如下方式覆盖默认设置：","方法返回的名称，要和关联到自定义类型的","方法进行封装，并且complete所传递的","方法释放一个服务引用时，都会有事件发送到","方法（这里的x指的是将返回的服务对象的类型）等等。可以查看","方法）。它会把你配置的不同的服务导入/导出模块都关掉，并且释放服务引用。","无类型的服务","是一个json对象，包含访问redis数据源的属性（url、端口等）。","更新已发布服务记录的状态（下线、服务暂停等等）","有了","服务","服务事件","服务代理，服务对象是一个代理，它的类型是所代理的接口（其location表现为一个ev","服务发布者和服务消费者都必须通过单独创建自己的","服务发现桥接器","服务发现组件中，我们通过","服务发现组件使用vert.x的分布式数据结构来存储服务记录。所以，集群中所有的成员都可以访问到所有的服务记录，这是服务后端的默认实现。你也可以实现自己的服务记录存储后端，只要实现","服务发现组件实现了面向服务计算中定义的服务交互。此外，在某种程度上，还提供了动态的面向服务计算交互，这样应用程序可以对各种服务的上线、下线作出反应。","服务发现组件提供了一些现成的服务类型，但你也可以添加自己的服务类型。","服务发现组件支持桥接的方式，来从其他服务发现技术中导入和导出服务。","服务发现组件通过实现","服务发现组件通过服务类型的概念来处理这种差异。每种服务类型都需要定义：","服务发现组件除了支持桥接器机制以外，还提供了一些现成的桥接器。","服务发现组件，需要将下列依赖加入到依赖配置中文件：","服务存储后端","服务对象","服务对象为服务消费者提供了一条获取服务的通道，它有各种实现方式，比如一个代理对象、一个客户端对象、甚至某些类型的服务可能不存在这样一个服务对象。服务对象的表现有赖于服务的类型。","服务就是资源。有很多各种各样的服务，比如功能性的服务组件、数据库、rest","服务引用代表了一个绑定的服务提供者。","服务提供者和发布者","服务提供者和消费者，必须创建他们自己的","服务提供者是提供服务的实体，而发布者的职责是发布服务记录，通过该服务记录来描述服务提供者的信息。服务提供者和发布者可以是同一个实体，也可以是不同的实体。","服务搜索的命名空间（默认是default）","服务是一种服务代理，是基于event","服务消费者","服务消费者在servic","服务消费者访问服务的步骤：","服务消费者通过传递一个过滤器来选择服务，有两种形式的过滤器：","服务的标签（label）都被映射为服务记录的元数据","服务的类型是通过tags推断出来的，如果有一个tag和已知的服务类型一样，那么就使用这种服务类型，如果没有匹配的，那么服务导入后将标记为unknown类型。目前暂时只支持http","服务类型","服务类型。","服务记录","服务记录按照如下的步骤进行创建：","服务记录的元数据、甚至位置的格式，都有赖于服务的类型（详见后续章节）。","服务记录的名称就是服务的名称","服务记录的映射","本节将解释服务发现机制所涉及到的一些概念。","本节将详细介绍一下服务类型，以及如何使用服务发现框架已提供的几种服务类型。","本节讲述的是最基本的获取服务的方法。每种服务类型接口，都提供了快捷的方法，来简化获取服务的步骤。","来导入。","来接收所有的状态）","来描述每个服务。","某些服务记录也可以不带有类型（servicetype.unknown）。通过这种服务记录，是无法获取到服务引用的，但是你可以通过服务记录（record）的location和metadata来创建连接的细节。","查找各种服务","查找服务","查找满足它需求的服务记录","桥接器","桥接器可以从","桥接器可以从kubernetes（或者","桥接器可以将","桥接器将会在启动(start)的时候导入所有的服务，在停止(stop)的时候移除所有的服务。在运行期间，它将监听","桥接器的使用","桥接器的配置","桥接器的配置项有：","此外还会加上：kubernetes.uuid,","每当发布或回收服务时，event","每当有一个服务引用被绑定或者被释放，都会有相应的事件发送到","每当服务发布或者取消发布，都会有相应的事件发送到","每当通过","注册id。","注意服务代理（服务实现和服务接口）都需要用java语言开发。","注意服务发现模块并不需要运行在vert.x","消息源服务","消息源服务的location是消息所发送的ev","消息源服务，就是通过event","消息源服务，服务对象的类型是一个messageconsumer（其location表现为一个ev","消费","消费消息源服务","然后，在创建服务发现对象的时候，像下面这样注册桥接器：","由一个简单的json对象组成，里面包含访问数据源的各种属性（jdbc","由于docker容器只在启动的时候创建链接，所以这个桥接器只会在启动的时候导入服务记录，然后此后就都不改变了。","由于vert.x的多语言特性，当你从java、groovy或其他语言中获取服务对象的时候，可能会有差异。","的","的complete方法，来通知调用者关闭操作已经完成。","的http","的公共接口。在这个接口中，仅需要提供一些辅助方法，来简化自定义类型的使用，比如提供","的地址，默认是localhost","的方法，这个","的服务发现组件中。","的服务，并且动态地导入新加入的服务，移除被删除的服务。","的端口，默认的端口是","的记录","的配置内容一致。","监听服务的上线、下线和状态变更的消息","监听服务的上线与下线","监听服务的使用","目前服务发现组件提供了几种默认的服务类型：","端点(endpoint)，就是一个rest","端点，如果服务带有ssl标签的话，那么服务记录的ssl(https)属性将被设置为true。","第一种方式对应的代码示例如下：","等接口例子来了解这种设计。","等）","类型的参数：","类或者各种服务类型类提供的快捷方法来创建服务记录。","组件介绍","组件源码","组件示例","绑定到某个服务（它所获取到的","维护模式下的服务或已经从","而不需要管服务记录的内容。","自定义的服务类型","自定义配置","获取服务引用","获取服务引用的时候，可以传递一个jsonobject对象来配置服务对象，可以包括用来配置服务对象的各种参数。某些服务类型不需要额外的配置，有些需要（比如数据库对象）：","要使用","要使用vert.x","要使用该服务发现桥接器，需要将如下的依赖包加入到依赖配置文件中：","要发布一个event","要发布一个http","要取消一个已发布的服务，可以用如下方式：","要想自定义桥接器，你可以通过实现","要调用（消费）event","让我们看一些json过滤器的例子","请注意，应用程序必须能够访问","调用","调用http","过滤器是一个json对象。对象中的每个条目，将会用来过滤服务记录。服务记录必须满足所有的条目要求。这些条目可以使用","这个地址。这个地址可以通过servicediscoveryoptions配置。","这个方法完成的，因此在这种情况下你是不需要持有一个服务引用的。","这个方法，一步就完成服务查找和服务获取：","这个桥接器使用的是","这个桥接器可以连接","这些资源都可以称为服务。服务就是一个可以被发现和访问的功能，可以通过它的类型、元数据和位置来进行描述。所以，服务可以是一个数据库、一个服务代理、一个http应用，以及任何你能想到的可描述、可发现、可交互的资源。它不一定是vert.x实体，它可以是任何组件。在vert.x","这种桥接器不需要任何进一步的配置。","这里的","进行配置。默认情况下，在单节点时它的值是localhost，在集群模式时是节点的id。","通过","通过实现","通过服务对象来访问服务","通过桥接器（bridge），你可以从其他服务发现组件中导入和导出服务，比如docker，kubernetes，consul等。每种类型的桥接器，决定了服务如何导入和导出，并且不一定都是双向的。","通过这个事件，可以监听服务的使用和服务的映射。","配置","集群模式下。在单机模式下，服务记录存储于本地，并且可以通过","需要提醒的是，在一个集群中，只需要有一个节点注册了服务桥接器，集群中所有成员就都能使用了。","需要注意的是，你只能在","（record","（可选）创建一个继承了"],"microservices/CircuitBreaker.html":["!=","\"/\",","\"hello\";","\"localhost\",","'io.vertx:vertx","(response.statuscode()","(在",").fallback(v",").openhandler(v",");",")，并且在回调中，执行",".bodyhandler(buff",".exceptionhandler(future::fail)",".listen(8080);",".requesthandler(router::accept)",".setfallbackonfailure(true)",".sethandler(ar",".setmaxfailures(5)",".setresettimeout(10000)",".settimeout(2000)","//","03","15","15:54:14","200)","2017","3.4.1","=",">","ar","ar.result();","breaker","breaker\",","breaker.execute(","breaker.execute(futur","breaker.executewithfallback(","breaker2","breaker:3.4.1'","breaker。","breaker是","breaker：熔断器","bu","build.gradl","bus上发布事件。事件发送的地址可以使用","cet","circuit","circuitbreak","circuitbreaker.create(\"mi","circuitbreakeroptions()","circuitbreakeroptions().setmaxfailures(5).settimeout(2000)","closed\");","command","command.observe().subscribe(result","compil","context","context.runoncontext(v2","context下(ev","dashboard","error\");","event","execut","executeandreport","executeblock","failures:","futur","future(超时)","future.complete();","future.complete(buffer.tostring());","future.complete(somecommand.execute()),","future.fail(\"http","getorcreatecontext","getsomecommandinstance();","gradl","half","halfopenhandl","handler","hystrix","hystrixcommand","hystrixmetrichandl","hystrix带有一个仪表板（dashboard），用于显示熔断器的当前状态。","hystrix提供了熔断器模式的实现。可以在vert.x中使用hystrix提供的熔断器或组合使用。本节介绍在vert.x应用程序中使用hystrix的技巧。","io.vertx","isfallbackonfailure，其结果是失败回调函数的输出。失败回调函数将","local）","loop线程。如果不这样做的话，您将失去vert.x并发模型的优势，并且必须自行管理线程同步和执行顺序：","loop线程中","loop线程或worker线程)","maven","metrics\").handler(hystrixmetrichandler.create(vertx));","metric：指标","name:","netflix","new","node:","null","open","opened\");","pom.xml","r","respons","result","result;","return","router","router.get(\"/hystrix","router.router(vertx);","runoncontext","second","setmaxretries。如果将其设置为高于0的值，则您的代码在最终失败之前进行尝试多次执行。如果代码在其中一个重试中成功，则处理程序将得到通知，并且跳过剩余的重试。此配置仅当熔断器未生效时工作。","setnotificationaddress","somecommand","somecommand.execute();","state:","state）。在这种状态下，允许下一次熔断器的调用实际调用如果成功，熔断器将复位并返回到关闭状态，回归正常的模式；但是如果这次调用失败，则熔断器返回到熔断状态，直到下次半开状态。","string","system.out.println(\"circuit","throwabl","url），如：http://localhost:8080/metrics。仪表板将使用vert.x熔断器的指标。","v","vert.x","verticle中调用：","vertx","vertx);","vertx,","vertx.circuit","vertx.createhttpclient().getnow(8080,","vertx.createhttpserver()","vertx.executeblocking(","vertx.getorcreatecontext();","vertx.runoncontext(v","web","{","}","})","}).closehandler(v","}).sethandler(ar","});","},","上：","中英文对照表","为了使用熔断器我们需要以下的步骤：","也可以提供一个失败时回调方法(fallback)：","事件通知收集的。如果您不使用默认通知地址，则需要在创建时指定。","以下是例子:","仪表板中，配置流网址（stream","仪表板使用。","仪表板需要一个发送指标的sse流，此流由","传递给此方法，则通知将被禁用。默认情况下，使用的地址是","但是，命令执行是阻塞的，必须结合","作为参数，以表示操作和结果的成功或失败。","你能够配置熔断生效/关闭时回调。","使用","使用熔断器","使用熔断器执行代码","例如在下面的例子中，对应的结果就是rest调用的输出：","函数将当前线程切换回event","创建","创建http服务器，并分配路由","创建一个熔断器，并配置成你所需要的(超时，最大故障次数)","半开启状态","原文档","原文档最后更新于","可以指定熔断器在生效之前的尝试次数，使用","和","回到event","回到vert.x","回调","在hystrix","在熔断器中执行的代码","处理结果","失败回调可以直接设置在","如果future在这里被标记为失败，熔断器将自增失败数","如果您使用hystrix的异步支持，请注意，对应的回调函数不会在vert.x线程中执行，并且必须在执行前保留对上下文的引用（使用","对象作为参数，并返回预期类型的​​对象。","将熔断器指标推送到hystrix","异步","当熔断器决定尝试复位的时候（","当熔断器在熔断状态中，对其调用会立即失败，不会执行实际操作。经过适当的时间（setresettimeout","当熔断器熔断时将调用此处代码","执行块中接收","执行模型。","提供：","操作的结果以下面的方式提供：","故障的数量","文件中):","方式返回","方法执行，或者在worker","时作为参数提供的","时失败","最大故障次数","每次事件信息包含以下：","每次熔断器状态发生变化时，会在event","没有完成的","注册指标handler","熔断器","熔断器可以发布其指标（metric），以供hystrix","熔断器支持以下的故障：","熔断器模式","熔断器用来追踪故障次数，当失败次数达到阈值时触发熔断，并且可选择性提供失败回调。","熔断器的名字","熔断器的新状态","熔断器要旨是保护","熔断器，只需要在依赖中增加以下代码片段：","熔断状态中都会调用失败回调（fallback），或者设置","状态），我们也可以注册","的","的vert.x实现。","的回调从而得到回调通知。","的行为，以便受益于vert.x","组件介绍","组件源码","组件示例","节点的标志符（如果运行在单节点模式是","要使用","设置是否失败回调","设置），熔断器决定是否恢复状态，此时进入半开启状态（half","请注意，这些指标量是由","调用","超时时间","路由","运行时抛出异常","这个","这里的代码可以成功或者失败","进行配置。如果将","通知","重置状态超时","隔离“受保护的”调用。你可以这样执行它：","非阻塞","首先，您需要将hystrix添加到你的依赖中。详细信息请参阅hystrix页面。然后，您需要使用","（open，closed，half_open）"],"microservices/Config.html":["\"*.json\"))));","\"/a\"));","\"/conf\"));","\"/path/to/my/conf\")","\"address","\"config\")","\"configmap","\"dir/*.properties\")","\"dir/*json\"))","\"false\"));","\"http://localhost:8888/foo/development\"));","\"https://github.com/cescoffier/vertx","\"local\")","\"localhost\")","\"localhost\").put(\"port\",","\"localhost:2181\")","\"mi","\"path","\"properties\"))","\"value\"));","'io.vertx:vertx","(a,","(ar.failed())","(b,","(在","));",");",".add(new",".addstore(httpstore).addstore(filestore).addstore(syspropsstore);",".addstore(store1)",".addstore(store2);",".endhandler(v",".exceptionhandler(t",".handler(conf",".put(\"address\",",".put(\"connection\",",".put(\"defaulthost\",",".put(\"defaultport\",",".put(\"filesets\",",".put(\"format\",",".put(\"host\",",".put(\"key\",",".put(\"name\",",".put(\"namespace\",",".put(\"path\",",".put(\"port\",",".put(\"secret\",",".put(\"ssl\",",".put(\"url\",",".setconfig(new",".setformat(\"hocon\")",".setformat(\"properties\")",".setformat(\"yaml\")",".setscanperiod(2000)",".settype(\"configmap\")",".settype(\"directory\")",".settype(\"env\");",".settype(\"ev",".settype(\"file\")",".settype(\"git\")",".settype(\"http\")",".settype(\"json\")",".settype(\"redis\")",".settype(\"spr",".settype(\"sys\")",".settype(\"zookeeper\")","//","03","1000","15","15:54:14","2017","3","3.4.1","3000","5","6379)","8080)","8080).put(\"path\",","=",">","a)，我们最终得到的结果是：{a:value,","apach","ar.result();","b","b)，那我们的配置结果将是：{a:value2,","b:1,","b:1}","backoff","basesleeptimebetweenretries：","branch(分支，默认为","bu","build.gradl","bus\")","c:2}","c:2}。","c:2}。如果我们将配置顺序颠倒为","cach","cet","change.getnewconfiguration();","change.getpreviousconfiguration();","client","compil","conf","conf\")","config","config()","config.conf\")","config.json\"));","config.yaml\")","config:3.4.1'","configmap","configmap:3.4.1'","configmap：","configprocessor","configretriev","configretriever.create(vertx);","configretriever.create(vertx,","configretriever.create(vertx.vertx(),","configretriever.getconfigasfuture(retriever);","configretrieveropt","configretrieveroptions()","configretrieveroptions().addstore(git));","configretrieveroptions().addstore(store));","configretriever：","configstorefactori","configstoreopt","configstoreoptions()","configstoreoptions().settype(\"sys\");","configur","configuration\")","configuration。","config会周期性的去检查变更并更新本地仓库。","curat","default。如果环境变量中有","dir","eb","event","fail","field（字段），默认值是","file","file.properties\"));","fileset","filestor","format","futur","future.sethandler(ar","get","git","git:3.4.1'","gradl","hgetal","hocon","hocon)","hocon:3.4.1'","hocon。","host、port","http","httpclientconfiguration:","httpstore","includes,","initi","io.vertx","json","json,","jsonarray()","jsonarray().add(new","jsonobject","jsonobject()","jsonobject().put(\"cache\",","jsonobject().put(\"key\",","jsonobject().put(\"path\",","jsonobject().put(\"pattern\",","jsonobject().put(\"url\",","json。","json）","key","kubernet","kubernetes_namespace，则会优先使用此值","last","macros等。","master)，并且可以指定","maven","maxretries：尝试重新连接的次数，默认是","ms","name","name\")","namespac","namespace\")","new","option","options);","origin）","overloading：重载","password:","path","path（本地路径）","pom.xml","previou","project","properties,","reconfiguration)","redi","redis:3.4.1'","rediscli","remote（远程）仓库名称（默认读取","repository)的","retriev","retriever,","retriever.configstream()","retriever.getcachedconfig();","retriever.getconfig(ar","retriever.getconfig(json","retriever.listen(chang","retriever，只需要在依赖中增加以下代码片段：","secret","secret\")","server","server\")","server:3.4.1'","setconfig","spi，用来增加对新格式的支持","spi，用来增加对配置仓库（读取配置的位置）的支持","spring","store","store：配置仓库","syspropsstor","test.git\")","timeout:","true)","true）。此配置项决定是否在初次获取系统属性时对其进行缓存，并且在后面不会重新加载。","true：","url:","url（地址）","url（必填）","user:","vert.x","verticl","vertx","yaml","yaml:3.4.1'","yaml。","znode","zookeep","zookeeper:3.4.1'","{","{a:value,","{a:value2,","}","})","});","——","一些配置仓库需要一些额外的配置项（比如路径）。我们可以通过","一旦完成以上步骤，我们第一步所需要做的就是实例化","一旦成功实例化","一旦添加完依赖，我们就需要配置","一旦添加完依赖，我们需要配置","不存在，那首先将配置的","中的","中英文对照表","中获取配置。这种方式让你可以在本地和分布式组件中分发你的配置。","中获得配置。","中读取数据，必须设置","为了从","为了使用","也提供额外的格式支持组件，并可以在你的应用中使用。","也提供额外的配置仓库支持，并可以在你的应用中使用。","也支持采用","仓库(git","仓库(repository)中获取配置。","仓库克隆下来，然后从中读取匹配的文件集合。","仓库克隆的","以下的参数可供配置：","会定期地从配置仓库处读取配置。如果读取的结果和当前的配置不一样，那么应用就会重新进行配置，默认情况下，配置的刷新时间是","会按照以下的顺序进行配置：","作为访问","作为返回值的方式获取配置：","你也可以配置","你仅仅需要将","你可以通过下列示例自定义配置：","你可以通过以下spi对其进行扩展：","你需要对配置仓库进行配置，来找到正确的","使用","使用此配置仓库通常需要配置","使用流的方式读取配置","关闭时","关闭时（endhandl","其中","内的文件必须是同一种格式）。","函数","原文档","原文档最后更新于","参数是必须的。","参数用来指示存储配置对应的","参数确定哪一个才是我们要读取的。另外，应用必须要拥有对","只读取一个配置文件，而这种方式会从一个目录中读取一批配置文件。","可以快速、无需“等待”地获得最近一次获取的配置内容：","可用如下代码获取配置：","含有","命令来检索配置。","和","在后续章节会将更加详细的重载规则和其他可用的配置仓库设置一一展现。","在每一次重新尝试连接的间隔（exponenti","地址获得配置，可以使用任何支持的格式。","声明每一个数据存储源就必须要指明存储类型（type）。它可以指定格式（format），默认将使用","如果","如果我们配置的顺序是","如果本地","存在，那首先尝试更新（如果需要切换分支就切换分支）。如果更新失败，那配置读取也会失败。","它会创建一个vert.x","它包含：","它是如何工作的","定义了配置项的数据源和语法（默认是","实例。关于此部分的配置可以参考","实例将通过","实现","客户端以及存储我们配置内容的","客户端的配置","客户端（httpclient）来访问配置仓库（请看下面的代码）。你也可以通过配置","密码","对象(jsonobject)的形式取出。","对象传入，作为全局配置。","对象来进行上述的配置。","对象（jsonobject）进行配置。","对配置仓库进行配置","属性为","属性包含连接","属性进行配置（默认为","应用实例化以及使用；它配置了一系列的配置仓库","应用的方式。","底层所使用的","当","您可以对","或者其它任意支持的类型。","扩展","提供了一种配置","提供了一系列的配置存储支持和格式支持。更多的种类支持以扩展组件的形式提供，当然你也可以实现自己的扩展组件。","提供流(stream)的方式去获取配置。对应的流是","支持多种存储方式（文件、目录、http、git（扩展）、redis（扩展）、系统属性、环境变量等）","支持多种配置语法（json、properties、yaml（扩展）、hocon（扩展）等）","支持的配置仓库","支持自定义配置处理顺序和配置重载(overloading)","支持运行时重新配置(runtim","文件","文件中):","文件所在的根结点路径","文档。","方式读取配置","方法会被调用）","方法传入一个","明确配置仓库的顺序对于重载极为重要。对于冲突的键名，后面的配置值将替换掉之前的。举个例子，比如我们有两个配置仓库：","最终创建的","服务器中获取配置。","服务器中获得配置。","服务器的地址和包含我们所配置的节点","本组件基于如下几个概念：","本配置仓库仅支持","来使用此格式：","来使用此配置仓库。","来使用此配置仓库：","格式","格式。","格式的支持。","检索到新的配置","检索最近一次获取的配置内容","概念","此方式有两个必要的参数：","此格式支持","此组件底层使用","此配置仓库不支持","此配置仓库也支持所有的格式。","此配置仓库仅仅从文件中读取配置，支持所有的格式。","此配置仓库会从","此配置仓库会创建一个","此配置仓库会通过给定的","此配置仓库将环境变量中的键值对映射成","此配置仓库将系统属性中的键值对映射成","此配置仓库需要以下几个参数：","此配置仓库需要传入一系列参数：configur","每一个","环境变量","用户（默认无权限）","由vert.x","由多个元素部分构成，你可以使用","的名称。","的客户端。","的扩展。它提供了对","的扩展，并且提供","的扩展，支持从","的支持。","的读权限。","监听配置变更","目录","秒钟。","策略），默认是","类型的可读流(readstream)。你可以注册相应的处理器(handler)，来获得下面的事件通知：","系统属性","系统配置","组件介绍","组件源码","至少一个","获取新配置时发生错误","获取配置发生错误","要使用","设置为","读取配置的","读取配置的超时时间，单位是毫秒，默认为","路径。","路径（path）。此节点的数据格式可以是","这些属性来简化这个过程。","这种配置仓库非常像","都包含：pattern（匹配模式），即用于选取文件的ant风格的匹配模式。此匹配模式使用相对路径确定配置文件位置。format（格式）作为可选的参数（每一个","都可以使用不同的格式，但是在一个","配置仓库","配置仓库仅支持通过给定的","配置仓库组件是对","配置仓库，您需要添加以下依赖：","配置使用","配置内容","配置文件最终会以","配置方式，但是不同的是，file","配置格式","配置格式组件是对","配置格式，您需要添加以下依赖：","配置的数据结构","配置项。","重载规则","除了上文所提到的一系列现成的格式支持以外，vert.x","除了上文所提到的一系列现成的配置仓库支持以外，vert.x","除此之外，你可以设置","需要读取的文件列表（模式）","需要读取的文件列表（模式）（等同于目录配置仓库的配置方式）","项目的命名空间，默认是","额外可以配置的有：","额外的配置仓库","额外的配置格式","默认配置下，config"],"devops/Devops.html":["devop","vert.x"],"devops/MetricsUsingDropwizard.html":["dropwizard","metric","us","vert.x"],"devops/MetricsUsingHawkular.html":["hawkular","metric","us","vert.x"],"devops/Shell.html":["shell","vert.x"],"devops/Docker.html":["docker","vert.x"],"devops/StackManager.html":["manag","stack","vert.x"],"testing/Testing.html":["test","vert.x"],"clustering/Clustering.html":["apach","cluster","core","hazelcast","hazelcast（默认实现）","ignit","infinispan（预览版）","manager）来实现集群管理。在","vert.x","zookeeper（预览版）","中，采用","中，集群化与高可用均是开箱即用的。vert.x","作为默认的集群管理器。","在","提供了四种集群管理器实现：","文档手册","文档手册中的相关章节。","目前","组件源码","通过可插拔的集群管理器（cluster","集群管理器","集群管理器实现","集群管理器的介绍见"],"clustering/Hazelcast.html":["\"com.hazelcast:hazelcast:enter_your_version_here\"","#","${version}","'com.hazelcast',","'hazelcast'","'io.vertx:vertx","(\"io.vertx:vertx","(res.succeeded())",")应该在",",是vert.x",".","...",".setgroupconfig(new",".setnetworkconfig(new","//","//创建hazelcastcli","//创建hazelcast配置","0","1","192.168.1.20","24","25","3.4.1","3.6.3","=",">","address","api","api=tru","api。当在程序启动时，设置选项","async","azelcast.logging.typ","classpath","clientconfig()","clientnetworkconfig().addaddress(\"hosts\"))));","cluster","cluster.xml","clustermanag","com.hazelcast","com.hazelcast.level=info","com.hazelcast.map.merge.latestupdatemapmergepolici","compil","conf","config","config();","config.xml","cp","default","depend","dhazelcast.config","dhazelcast.logging.type=slf4j","documentation。","dvertx.hazelcast.async","dvertx.hazelcast.config=./config/mi","dvertx.hazelcast.config=classpath:my/package/config/mi","ec2","enabl","enter_your_version_her","eventbu","eventloop","exclud","failed!","fals","fat","gradl","gradle(build.gradle)","group:","groupconfig(\"groupname\",\"password\")","hazelcast","hazelcast:${version}。","hazelcast:3.4.1\"){","hazelcast:3.4.1'","hazelcastclient.newhazelcastclient(","hazelcastclustermanag","hazelcastclustermanager();//创建clustermanger对象","hazelcastclustermanager(hazelcastconfig);","hazelcastclustermanager(hazelcastinstance);","hazelcastconfig","hazelcastinst","hazelcast支持多种不同的传输协议，包括组播和tcp。默认配置中采用组播传输协议，因此您必须在网络上启用组播才能使其工作。","hazelcast，需要做以下工作：","hazlecast","ha（高可用或故障转移）时，请不要使用","host","iatomiclong","icompletablefuture，这与","imap","instanc","interfac","io.vertx","ip","issu","jar","java","java.util.logging.consolehandler.level=info","java.util.logging.filehandler.level=info","java.util.loging（jul）","jdk","jul","jul）。如果想切换至其他日志库，通过设置","logging.properti","maco","manag","map","maven","maven(pom.xml)","method","mgr","module:","myverticl","myverticle.j","new","none","option","put","re","remov","res.result();","run","setclusterhost","setclustermanag","shutdownhook。参考上述的","tcp","true","tsao，校对","vert.x","vert.x，对应集群管理器","vertx","vertx.clusteredvertx(options,","vertx.executeblock","vertx.hazelcast.config","vertxopt","vertxoptions().setclustermanager(mgr);","vertxoptions().setclustermanager(mgr);//设置到vertx启动参数中","vpn","woker","xml","{","}","});","、","。","。如果开发者想使用其他版本的","。这意味着，counter","上使用","不正确配置的话，vpn","与","中","中。举个例子：","中内嵌","中加载一个文件为自定义配置文件","中安装包中。","中所有的","中没有其它的","中添加","中添加一个","中的","中的配置保持一致。","中节点中的通信是直接由","中集群管理器中的默认实现。由于","中，vert.x将自动检测到，并将其作为集群管理。需要注意的是，要确保","为了确保","从","任意一个","使用","使用vpn","使用公共","使用其他","使用已存在的","使用正确的网络接口。当通过命令行模式时，可以设置","使用正确的网络接口，在配置文件中将","使用的","使用错误的网络接口","例如：","依赖添加至","值不为空时，将覆盖","先于","公共","其中","具体详细配置，请参阅","决定的。","分布式","分布式计数器","分布式锁","包(","包。","即可达到目的。","参数：","参考代码如下：","发现并管理集群中的节点","可以在集群管理器通过设置","同时也可以通过编程的形式达到配置的目的：","同时要确保","在","在当前路径中","在排除故障时，开启","在某些情况下，因为特殊的运行环境，可能无法使用组播。在这种情况下，应该配置其他网络传输，例如在","在这种情况下，vert.x不是","地址）","均有异步调用方法，其返回值为","失败时，系统将选取","套接字，在亚马逊云上使用","如果","如果在","如果是","如果机器上有多个网络接口（也有可能是在运行","如果要覆盖此配置，可以在","如果通过命令行来使用","如果默认的组播配置不能正常运行，通常有以下原因：","宋子豪、赵亮","实例需要配置：","实现","实现依赖：io.vertx:vertx","实现（参考","客户端，因为他们不会通知他们何时离开集群，同时有可能丢失数据，还有可能将集群置于不一致的状态。更多情况请翻阅","将目标版本的","属性设置为","工程中使用","并不支持","开启日志","当","当前的","当然在内嵌","当运行集群模式时，需要确保","当通过编程模式使用","很有可能是使用了错误的网络接口。","必须与","必须是一个","或者","所以，如果你的软件运行在","执行。","指定一个外部文件为自定义配置文件","接口(数据结构)","接口将被选择，而不是正确的接口。","操作都将通过","支持","故障排除","文件。如果想在","文件（默认的jul记录时），这是一个标准","文件，但是如果加载","文档。","方法显式指定集群管理器。","日志配置","日志，将会给予很大的帮助。在","时关闭","时，可以调用方法","时，通过编程的方式创建","是基于","暴露。","更多传输方式，以及如何配置它们，请咨询","有关","机器禁用组播","来复用现有集群：","来实现：","来设置参数","注意事项","注意：vert.x","版本","版本为","环境中，参考上述章节，设置正确的网络接口。","环境中，如果","的","的官方网站，可以找到具体的配置描述。","的形式，在构建工具中使用正确的版本","的情况下），那么","的日志默认采用","的根目录中。如果此文件是一个外部文件，则必须将其添加至","的线程模型完美契合。但是即使这些接口已经存在一段时间，却没有通过","目录中","管理集群端的主题订阅清单（这样就可以轻松得知集群中的那些节点订阅了那些","系统变量来实现。","线程来执行，而不是通过","线程的","组播不可用","群集的所有者，所以不要关闭","翻译：ranger","计数操作、asyncmap的","设置为指定ip地址，同时确保","设置方式，请不要使用。","设置相关的hazlcast配置，在这里省略掉，不再赘述","详细文档请参考","请注意，自定义","软件通常通过创建不支持组播的虚拟网络接口来进行工作。在","还是下面需要提到的","还有一种方式来覆盖默认的配置文件，那就是利用系统配置","通常情况下，集群管理器的相关配置是由打包的jar中的默认配置文件","配置","配置文件。具体配置如下：","配置文件，在","配置，或者通过","重要提醒","链接处理的。","集群","集群。","集群使用","集群关闭。同时需要禁用","集群启动，后于","集群器并不处理节点之间的通信，在","集群模式实例，调用","集群管理器包含一下几个功能：","集群管理的可插拔性，也可轻易切换至其它的集群管理器。","集群通讯交互时，将采用","默认情况下，hazelcastclustermanag","默认禁用组播。google一下启用组播。","，只需要在工程依赖中加上相应的","，将代表系统在与","，此文件必须在","，甚至直接使用默认配置。"],"clustering/Infinispan.html":["#","$(oc","'io.vertx:vertx","(1)","(res.succeeded())",".","...","//","0.9.0","3","3.4.1","3.4.1.jar","3，需要在配置以及依赖上做一些改动。","8080","8888","=",">","add","address","bind_addr","cach","classpath","cluster","clustermanag","compil","compos","conf","core","cp","defaultcachemanag","discoveri","djava.net.preferipv4stack=tru","djgroups.tcp.address=192.168.1.20","djgroups.tcp.address=non_loopback","docker","dorg.jboss.logging.provider=log4j2","dvertx.infinispan.config=./config/mi","dvertx.infinispan.config=my/package/config/mi","env","eventbu","expos","failed!","fat","gradl","gradle(gradle.xml)","host","http","infinispan","infinispan.xml","infinispan.xml\");//加载自定义配置文件","infinispan:3.4.1'","infinispanclustermanag","infinispanclustermanager(\"custom","infinispanclustermanager();//创建","infinispanclustermanager(cachemanager);","io.undertow","io.vertx","ip","ipv4","ipv4:","ipv6","jar","java","jboss","jdk","jgoups.xml","jgroup","jgroup.xml","jgroups.tcp.address","jgroups与","jgroups文档","jvm","kube_p","kubernet","lib","log","log4j","log4j2","maco","manag","manager。","map","maven","maven(pom.xml)","mgr","myverticl","myverticle.j","n","new","oc","openshift","openshift3","openshift_kube_ping_namespac","option","org.jboss.logging.provid","org.jgroups.kubernet","polici","project","protocol","q)","q):default","re","res.result();","role","run","s3_ping","server","setclusterhost","system:serviceaccount:$(oc","tcp","tcpping","tsao，校对","undertow","user","vert.x","vertx","vertx.clusteredvertx(options,","vertx.infinispan.config","vertxopt","vertxoptions().setclustermanager(mgr);","vertxoptions().setclustermanager(mgr);//","view","vpn","vpn软件通常通过创建不支持多播虚拟网络接口来进行工作。如果有一个","{","}","});","、","。","。jboss","上使用","不正确配置的话，vpn接口将被选择，而不是正确的接口。","与","中","中。","中。举个例子：","中内嵌相应的配置文件","中加载一个文件为自定义配置文件","中所有的","中添加对应的文件。如果想在","中的日志框架实现。","中的配置保持一致。","中节点中的通信是直接由","中，通过构建工具可以轻松引入：","为了使","为了确保","从","任意一个","使用","使用vpn","使用已有","使用正确的网络接口。当通过命令行模式时，可以设置","使用正确的网络接口，在配置文件中将","使用错误的网络接口","例如：","依赖,","依赖与","值不为空时，将覆盖","其中","分别是","分布式","分布式计数器","分布式锁","创建的虚拟网络接口。","包","包中内嵌的两个文件来配置自身属性：","协议依赖：","去掉","参数：","发现并管理集群中的节点","另外，如果需要修改打包好的","同其他集群管理器，亦可通过编程的形式来进行配置，举例：","同样需要设置项目命名空间作为发现范围：","因此在构建容器镜像时，需要显式声明：","在","在启动时","在当前路径中","在某些情况下，因为特殊的运行环境，可能无法使用组播。在这种情况下，应该配置其他网络传输协议，例如在","在组件","在这种情况下，vert.x","地址配置有难点，请强制使用","地址）","失败时，系统将选取","如果在","如果想查阅更详细的信息，或实现自己的日志后端，请参考","如果机器上有多个网络接口（也有可能是在运行","如果系统变量","如果要覆盖其中任意一个配置文件，可以在","宋子豪、赵亮","实例：","实现。","实现。同时也支持","实现。由于","并不是","开发者可以通过","当运行集群模式时，需要确保","当通过编程模式使用","很有可能是使用了错误的网络接口。","必须与","成为其发现协议，代码如下：","或","所以，如果你运行在","所有的设置需要一个服务账号：","才能正确的挑选出","指定一个外部文件为自定义配置文件","支持","故障排除","文件，但是如果加载","文件，可以通过设置","日志文档","日志配置","时，停止","时，可以调用方法","是一个与多种日志框架的桥接器。","是基于","更多传输方式，以及如何配置它们，请咨询","更多配置信息请参考","最后,","有关","有关更多配置详情，请参考","有多种日志框架，可以通过设置系统变量","来复用已经存在的","来实现：","来指定具体的实现，例子：","来设置参数","构建工具使用","正常运行","没有其他的","注意事项","然后覆盖默认的","然后，通过设置系统变量，确保","环境中，参考上述章节，设置正确的网络接口。","的安装路径中的","的实现。不过需要确保在","的情况下），那么","的所有者，因此不能在关闭","的根目录中。如果此文件是一个外部文件，则必须将其添加至","目录下。","目录中","确保","确认","端口,","管理集群端的主题订阅清单（这样就可以轻松得知集群中的那些节点订阅了那些","系统变量来达到目的","组播未正常开启","组播被禁用","编程形式调用","翻译：ranger","能够从","能够在","能够自动检测使用","自动检测并使用出","设置为指定ip地址。","设置了下面两项配置：","设置集群管理器","请注意，当前版本还处于预览版，请慎重在生产环境中使用","路径的","运行，如果","还有一种方式来覆盖默认的配置文件，那就是利用系统配置","适配","通常情况下，infinispanclustermanag","通过","通过上述两项系统配置，jgroup","通过命令行使用","通过编码的形式，设置集群管理器实现，例子：","配置","配置文件。在对应的官方可以网站可以详细的配置攻略。","配置，确保","采用","链接处理的。","错误","集群器并不处理节点之间的通信，在","集群管理器包含以下几个功能：","集群管理的可插拔性，也可轻易切换至其它的集群管理器。","集群能够正常运行在","需要注意的是，需要通过如下配置来自定义","首先，添加","默认监听","默认禁用组播。google一下启用组播。","默认采用","，在亚马逊云上使用","，如果相应的","，此文件必须在","，甚至直接使用默认配置。"],"clustering/ApacheIgnite.html":["'io.vertx:vertx","(res.succeeded())","//","3.4.1","3.4.1.jar","=",">","address","amazon","apach","cfg","classpath","cluster","clustermanag","compil","default","dvertx.clustermanagerfactory=io.vertx.spi.cluster.ignite.igniteclustermanag","eventbu","failed!","finder。tcp","gradl","gradle(gradle.xml)","host","ignit","ignite.xml","ignite.xml。","ignite:3.4.1'","igniteclustermanag","igniteclustermanager();//创建","igniteclustermanager(cfg);","igniteconfigur","igniteconfiguration();","ignite。","io.vertx","ip","jar","java.util.logging.consolehandler.level=info","java.util.logging.filehandler.level=info","java.util.loging（jul）","jul","lib","logging.properti","maco","manag","map","maven","maven(pom.xml)","myverticle.j","new","option","org.apache.ignite.level=info","re","res.result();","run","s3","setclusterhost","socket","tcp","tcpdiscoverymulticastipfind","tcpdiscoverys3ipfind","tcpdiscoveryvmipfind","tsao，校对","vert.x","vertx","vertx.clusteredvertx(options,","vertxopt","vertxoptions().setclustermanager(clustermanager);","vertxoptions().setclustermanager(clustermanager);//设置集群管理器实现","vpn","{","}","});","。","不正确配置的话，vpn","与","中内嵌了一个默认配置文件","中添加","中的配置保持一致。","中节点中的通信是直接由","为了确保","事先配置好","使用","使用vpn","使用正确的网络接口。当通过命令行模式时，可以设置","使用正确的网络接口，在配置文件中将","使用配置文件","使用错误的网络接口","例如：","其中","具体","分布式","分布式计数器","分布式锁","参数：","发现器","发现并管理集群中的节点","另外","可以通过设置","在","在一些情况下，运行环境中，无法开启组播。在这种情况下，需要配置合适的","在排除故障时，开启","在默认配置中使用","地址列表。具体","地址）","如果机器上有多个网络接口（也有可能是在运行","如果需要覆盖此配置文件，需要在","宋子豪、赵亮","实现。","实现。由于","实现，这网络发现实现，需要开启组播。如果组播被禁用，可以采用","开启日志","当运行集群模式时，需要确保","当通过编程模式使用","很有可能是使用了错误的网络接口。","必须与","必须是一个","或","所以，如果你的软件运行在","接口将被选择，而不是正确的接口。","支持","故障排除","文件（默认的jul记录时），这是一个标准","日志，将会给予很大的帮助。在","时，可以调用方法","是基于","替代，前提是在","来使用指定的","来设置参数","构建工具使用","没有其他的","注意事项","环境中，参考上述章节，设置正确的网络接口。","环境中，如果","的安装路径中的","的官方中文文档中，可以找到具体的配置描述。","的实现。不过需要确保在","的情况下），那么","目录下。","确保","管理集群端的主题订阅清单（这样就可以轻松得知集群中的那些节点订阅了那些","组播未正常开启","组播被禁用","编程形式调用","编程配置","翻译：ranger","能够从","自动发现及网络传输配置","自动检测并使用出","设置为指定ip地址。","路径中添加","路径的","软件通常通过创建不支持组播的虚拟网络接口来进行工作。在","通过","通过命令行使用","通过编码的形式，设置集群管理器实现，例子：","配置","配置文件。具体配置如下：","配置文件，在","链接处理的。","集群器并不处理节点之间的通信，在","集群管理器","集群管理器包含以下几个功能：","集群管理器实现。","集群管理的可插拔性，也可轻易切换至其它的集群管理器。","集群配置，可以参考文档","默认禁用组播。google一下启用组播。","，或者","，此处省略配置代码"],"clustering/ApacheZookeeper.html":["\"127.0.0.1\");//","\"io.vertx\");//","#","'io.vertx:vertx","(res.succeeded())",".","...",".put(\"initialsleeptime\",",".put(\"maxtimes\",","//","/io.vertx/asyncmap/$name/","/io.vertx/asyncmultimap/$name/","/io.vertx/cluster/nodes/","/io.vertx/counters/","/io.vertx/locks/","2.1.1","3));","3.4.1","3.4.1.jar","3.4.8","3.5.x","3000)","5","=",">","apach","asyncmap","asyncmultimap","classpath","cluster","clustermanag","compil","conf","conf.json","config.json","cp","curat","default","dvertx.zookeeper.config=./config/mi","dvertx.zookeeper.config=classpath:my/package/config/mi","eventbu","failed!","fat","gradl","gradle(gradle.xml)","guava","host","io.vertx","io.vertx.core.shareddata.asyncmap","io.vertx.core.spi.cluster.asyncmultimap","io.vertx，同时还有","jar","java","java.util.logging.consolehandler.level=info","java.util.logging.filehandler.level=info","java.util.loging（jul）","jsonobject","jsonobject()","jsonobject();","jul","lib","logging.properti","manag","map","maven","maven(pom.xml)","mgr","myverticl","new","option","org.apache.ignite.level=info","re","res.result();","root","run","slf4j","tcp","tsao，校对","vert.x","vertx","vertx.clusteredvertx(options,","vertx.zookeeper.config","vertx.zookeeper.host","vertxopt","vertxoptions().setclustermanager(mgr);","vertxoptions().setclustermanager(mgr);//","zk","zkconfig","zkconfig.put(\"retry\",","zkconfig.put(\"rootpath\",","zkconfig.put(\"zookeeperhosts\",","zookeep","zookeeper.json","zookeeper:3.4.1'","zookeeperclustermanag","zookeeperclustermanager();//创建","zookeeperclustermanager(zkconfig);","zookeeper，因此不支持","{","}","});","、","个","中。举个例子：","中内嵌","中加载一个文件为自定义配置文件","中定义默认的根路径是","中已经通过注释的形式，详细说明每个配置项的作用。","中所有的","中添加","中添加一个","中的最新特性。","中节点中的通信是直接由","中，通过构建工具可以轻松引入：","也可以达到配置","从","任意一个","使用","值不为空时，将覆盖","分布式","分布式计数器","分布式锁","创建的","包。","包中内嵌的","发现并管理集群中的节点","各路径作用为：","同其他集群管理器，亦可通过编程的形式来进行配置，举例：","在","在当前路径中","在排除故障时，开启","在组件","在配置文件","地址","地址）","失败时，系统将选取","如果系统变量","如果要覆盖此配置，可以在","子路径用来存储用于管理","存储分布式计数器","存储分布式锁","存储通过接口","宋子豪、赵亮","实现。","实现。由于","客户端，因此需要依赖","对应","工作原理","开启日志","或","指定一个外部文件为自定义配置文件","支持","文件。如果想在","文件（默认的jul记录时），这是一个标准","文件，但是如果加载","日志，将会给予很大的帮助。在","是基于","来实现：","构建工具使用","根路径","框架而不是原生zookeep","没有其他的","注意事项","注意：通过系统变量","版本","版本的","由于","的安装路径中的","的实现。不过需要确保在","的根目录中。如果此文件是一个外部文件，则必须将其添加至","的目的。","目录下。","目录中","确保","等其他第三方","管理集群端的主题订阅清单（这样就可以轻松得知集群中的那些节点订阅了那些","编程形式调用","翻译：ranger","能够从","自动检测并使用出","节点信息","记录","设置相关配置项","设置相应的配置。","设置集群管理器","请注意，当前版本还处于预览版，请慎重在生产环境中使用","路径作为命名空间，在默认的","路径的","还有一种方式来覆盖默认的配置文件，那就是利用系统配置","通常情况下，zookeeperclustermanag","通过","通过命令行使用","通过编码的形式，设置集群管理器实现，例子：","配置","配置文件。具体配置如下：","采用字典树来存储数据，便可以以","重试策略","链接处理的。","集群器并不处理节点之间的通信，在","集群的相关信息。所有的路径中，只有跟路径可以自定义配置。","集群管理器包含以下几个功能：","集群管理的可插拔性，也可轻易切换至其它的集群管理器。","，其使用","，此文件必须在","，甚至直接使用默认配置。"],"clustering/JGroups.html":["#","'io.vertx:vertx","(res.succeeded())","*",",来指定集群管理器。","//","127.0.0.1","192.168.1.3","224.0.0.0/5","224.0.0.1","231.255.255.254","232.0.0.0/5","232.0.0.1","239.255.255.254","3.4.0","3.4.1","3.4.1.jar","3.4.1.jar，应该在vert.x中安装包中。同时也要将jgroup","=",">","[hazlcast]|(/clustering/hazelcast.md)，也可以通过编程的方式来实现：","[infinispan]|(/clustering/infinispan.md)","add","address","address:挑选任务符合ip地址规则的地址，例如：192.168.*","classpath","cluster","clustermanag","compil","default","djava.net.preferipv4stack=true）。有关这方面更多的细节可在https://developer.jboss.org/wiki/ipv6。","dvertx.clustermanagerfactory=io.vertx.spi.cluster.jgroups.jgroupsclustermanag","ec2。","failed!","global:挑选一个可用的全局地址。如果不能，使用","gradle(build.gradle)","host","host:挑选任何符合域名规则的地址，例如：linux.*","host参数：","interface:挑选任何匹配网络接口名的地址，例如匹配接口：eth\\","io.vertx","ip","ipv4","ipv6","ipv6，但路由表配置不正确，或使用","jar","java.util.logging.consolehandler.level=info","java.util.logging.filehandler.level=info","java.util.loging（jul）配置文件。具体配置如下：","jgoup","jgroup","jgroups.bind_addr","jgroups.xml","jgroups:3.4.1'","jgroupsclustermanager();","jgroups与","jgroups支持多种传播方式，包括多播与tcp。默认配置时多播方式，所以需要确保网络是否启用多播。","jul","link_local:挑选一个链接本地ip地址从169.254.1.0到169.254.254.255","logging.properti","loopback:挑选一个环回地址，例如127.0.0.1","mac系统例子：","manag","match","maven(pom.xml)","mgr","multicast","myverticle.j","net","new","non_loopback:挑选任何非回送地址","option","org.jgroups.level=info","re","res.result();","rout","run","setclusterhost","site_loc","site_local:挑选一个本地（非路由）的ip地址，例如从192.168.0.0或10.0.0.0地址","sudo","tcp","vert.x","vertx","vertx.clusteredvertx(options,","vertxopt","vertxoptions().setclustermanager(mgr);","vpn","vpn软件通常通过创建不支持多播虚拟网络接口来进行工作。如果有一个","{","}","});","。不建议在生产或测试环境中使用","上使用","下面这些配置参数同样有效：","不正确配置的话，vpn接口将被选择，而不是正确的接口。","中没有其它的","中添加","中添加一个","中的配置保持一致。","中，vert.x将自动检测到，并将其作为集群管理。需要注意的是，要确保vert.x的","从","使用","使用vpn","使用错误的网络接口","例如：jgroups.bind_addr=192.168.1.5。","其中","内嵌在对应jar包中。","包。也可以通过设置启动参数:","同","在","在排除故障时，开启jgroups日志，将会给予很大的帮助。在","在构建工具中添加依赖即可：","在某些情况下，因为特殊的运行环境，可能无法使用多播。在这种情况下，应该配置其他网络传输，例如在","地址。","多播不可用","套接字，在亚马逊云上使用","如下：","如果","如果机器上上有多个网络接口（也有可能是在运行vpn的情况下），那么jgroups很有可能是使用了错误的网络接口。","如果要覆盖此配置，可以在","如果通过命令行来使用vert.x，jar包vertx","如果默认的多播配置不能正常运行，通常有以下原因：","实现","实现，已经由","已经弃用","开启日志","开始，vert.x","当使用udp时，ip多播是必需的，在一些系统中，多播路由需要被添加到路由表中，否则，缺省路由将被使用，请注意，有些系统并不适用路由表中的ip组播路由，只为单播路由","当运行集群模式时，需要确保vert.x使用正确的网络接口。当通过命令行模式时，可以设置clust","当通过编程模式使用","必须与","所以，如果你运行在","故障排除","文件。此配置文件必须是一个","文件（默认的jul记录时），这是一个标准","时，可以调用方法","更多传输方式，以及如何配置它们，请咨询jgroups文档。","有关","机器禁用多播","来设置参数","环境中，参考上述章节，设置正确的网络接口。","用来确定绑定的网络接口,","的jar加到lib目录中。","的官方网站中，可以找到具体的配置描述。","的配置文件","解决方法：查看","路由或强制使用","运行，如果","配置","配置参数","配置文件，在","错误配置的ipv6","默认情况下，jvm","（"],"services/Services.html":["servic","vert.x"],"services/ServiceFactories.html":["\"app.js\"","\"bar\"","\"com.mycompany.cleverdb.mainverticle\"","\"com.mycompany.cleverdb.mainverticle\",","\"config\"","\"foo\":","\"isolationgroup\":","\"main\":","\"maven:com.mycompany:clev","\"mygroup\"","\"options\":","\"worker\":","'io.vertx:vertx","3.2.1",":","clever","compil","db","db:1,2::clever","factori","factory:3.2.1'","factory的maven依赖，如果你使用的是fat","gradle(在你的build.gradle文件中)","io.vertx","jar的方式，你可以用如下依赖：","json还能提供options属性，可精确的被映射到deploymentoptions对象中。","maven(在你的pom.xml中)","options);","processor","run","servic","service\"","service\",","service,foo","service,org.widgets.widget","service,那么他的服务描述符文件为：`com.mycompany.clev","service.json","service:com.mycompani","serviceverticlefactory());","source使用手册","true,","tsao、宋子豪","vert.x","verticlefactory，所以需要你的classpath中确保vertx","verticle工厂在运行时动态的从maven中加载服务：","vertx","vertx.deployverticle(\"service:com.mycompany.clev","vertx.registerverticlefactory(new","{","}","},","。","不推荐但是有效的命名：account","也可以通过命令行的方式部署：","但是config是一个例外。任意的config在部署时传递的任何配置都将覆盖任何呈现在文件描述符文件中对应的属性。","你也可以通过编程的方式用registerverticlefactory方法注册verticlefactory实例","使其可用","使用","例如：对于一个服务名：com.mycompany.clev","当使用服务描述符来部署一个服务时，任何属性如worker,isolationgroup等不能被在部署时传递的部署参数所覆盖。","当部署一个服务时使用service:，选择服务verticle工厂。这个verticle可以通过编程的方式部署,例如:","当部署一个服务时，这个服务工厂首先在classpath中查找这个文件描述符。这个文件描述器就是服务名加.json。","或者","或者你甚至可以重定向到一个不同的verticle工厂。例如，这个maven","打包和部署vert.x的独立服务。","推荐命名：com.mycompany.services.clev","文件描述符文件是一个简单的text文件，内容为有效的json对象。json中至少必须提供main属性，用于指定实际被部署的verticle，例如：","是verticlefactori","服务使用者从实际被部署的verticle中解耦是很有用的，并且允许服务提供默认的部署参数和配置。","服务名字是一个简单的字符串，可以随用户定义，但是建议用户使用域名反转的方式（如java包的定义），这样避免你类路径中的其他服务同名。例如：","服务名被用于查找json描述符文件，json描述符文件决定实际被部署的verticle，包含部署参数例如是否作为一个worker来运行等等。","服务描述符","服务要实现","标识符","注意这个factory与vert.x服务代理没有直接关系，而是一个关于部署单个组件的设施。","的jar文件。首先你需要添加verticl","的一个实现，能根据服务id部署一个verticl","翻译：赵亮，校对：ranger"],"services/ServiceProxies.html":["\"","\"action\":","\"collection\":","\"databas","\"document\":","\"in","\"io.vertx:vertx","\"mycollection\")","\"mycollection\",","\"name\":","\"save\"","\"save\");","\"the","\"tim\"","\"tim\"));","\"tim\"),","'io.vertx:vertx","(!shoesize.equals(\"9\"))","(exc.failurecode()","(res2.succeeded())","(result.cause()","(result.succeeded())","(serviceexception)","(shoesizeexception)","));","+","...","....",".put(\"document\",","//","03","15","15:54:14","2017","3.4.1","42;","43;","9!\",","=","==",">","@dataobject","@fluent","@proxyclos","@proxygen","@vertxgen","[arg_name,","[key,","action","address\");","address\",","address)","address);","arg_value]相对应（译者注：key对应参数名，value对应参数值）。","asyncresult","bad","bad_shoe_s","bad_shoe_size_error","body:","body）应该是一个","build.gradl","bus。","bus。而有了vert.x","bus上暴露（expose）一个服务，所以，只要它们在服务发布时清楚服务的地址（address），其他任意的vert.x组件都可以去调用它。","bus上访问你的服务的模板代码，同时也会生成对应的","bus上（可能是在不同的机器上），调用端代理类都能正常工作。","bus上）区分开，以便确定到底发生了哪一种业务逻辑错误。下面是一个例子：","bus上，你需要做以下的事情来调用服务：","bus上：","bus下","bus中的消息、将其分派到合适的方法并将结果返回到ev","bus中的消息遵循一定的格式，因此能被用于服务的调用。","bus发送消息。","bus发送消息。不管你的服务实际在哪个ev","bus发送消息，被调用端收到消息调用服务并且返回结果来实现的。为了使其更容易使用，服务代理组件可以生成一个代理类，你可以直接调用这个代理（通过服务接口中的api）。","bus支持的任何类型。如果需要表示调用失败，可以使用","bus注册了对应的messagecodec，服务就可以直接向调用者返回自定义的异常类型：","bus注册了对应的默认messagecodec就可以。比如给定下面的serviceexception子类：","bus注册对应的自定义异常类型的messagecodec实例。","bus消息更加容易。下面我们就来看一下：","bus的别处。想要利用多语言代码生成功能，不要忘记添加对应支持语言的依赖。以下是使用示例：","bus调用服务的约定（不使用服务代理的情况下）","cet","class","classifier会自动通过","close();","codegen","codegen:3.4.1'","codegen也提供数据对象转换器（data","collection,","commit(handler>","compil","compileonli","connect","connection_fail","connectionerror(\"fail","consum","converter）的生成，这使得在服务代理中处理数据实体更加容易。生成的转换器提供了一个接受","create(vertx","createconnection(str","createproxi","createproxy(vertx","db\")));","deliveryopt","deliveryoptions().addheader(\"action\",","document,","dodbconnection(result","dosomething();","error","error)，如服务代理没有对应的已注册的服务","eventbu","exc","exc.getdebuginfo().getstring(\"shoesize\"))","exc.getshoesize())));","extend","extra;","fail(int","failurecode,","final","findone(str","foo(str","futur","future.failedfuture(new","future。比如：","getshoesize()","gradle(在","gradle中也可以进行配置：","groovi","groovy。","handler)","handler.handle(future.failedfuture(","handler>","handler）：","headers:","ide通常会支持注解处理器。","implement","inf/servic","insert(jsonobject","instanceof","interfac","invalid","invalidinputerror(\"y","io.vertx","io.vertx.serviceproxy.serviceproxyprocessor","io.vertx:vertx","json","jsonarray，primit","jsonobject","jsonobject().put(\"name\",","jsonobject().put(\"shoesize\",","jsonobject();","jsonobject），这些函数对于在服务代理中处理数据实体来说都是必要的。","lang","list","map","maven","maven(在","messag","message,","message.fail(…​)","message.put(\"collection\",","message.reply(…​)","messageconsum","meta","mydatabaseconnect","myserviceexception(failurecode,","myserviceproxyhandl","myservicevertxebproxy。","myservice，则对应的处理器类命名为","new","object","occurred:","option","options);","options,","plugin","pom.xml","primit","privat","processor","processor）会在编译期生成这些类。这是java编译器的一个特性，所以不需要额外的步骤，只需要去配置一下对应的构建配置：","provid","proxi","proxy:3.4.1'","proxy:3.4.1:processor\"","proxy:processor","proxyhelp","proxyhelper.createproxy(somedatabaseservice.class,","proxyhelper.registerservice(somedatabaseservice.class,","proxyhelper.unregisterservic","proxyhelper.unregisterservice(consumer);","proxy组件，请先加入以下依赖：","proxy）的目的。它允许你在ev","proxy），这样你的服务调用端就可以使用一个相当符合习惯的api（译者注：即相同的服务接口）进行服务调用，而不是去手动地向ev","proxy）：一个编译时产生的代理类，用","public","query,","received:","res2","result","result);","result.cause().getmessage())","result.cause().getmessage()));","result.cause();","resulthandler)","resulthandler);","resulthandler.handle(future.succeededfuture(mydbconnection));","resulthandler.handle(future.succeededfuture(result.result()));","resulthandler.handle(serviceexception.fail(bad_shoe_size,","resulthandler.handle(serviceexception.fail(connection_failed,","resulthandler.handle(shoesizeexception.fail(shoesize));","resulttyp","return","save(str","servic","service,","service.createconnection(\"8\",","service.save(\"mycollection\",","service2","service_address);","serviceexcept","serviceexception)","serviceexception.fail","set","shoe","shoesize)","shoesize));","shoesize);","shoesize,","shoesize;","shoesizeexcept","shoesizeexception(str","shoesizeexception)","shoesizeexceptionmessagecodec());","side","side）可以检查它接收到的失败状态的asyncresult包含的throwable对象是否为serviceexception实例。如果是的话，继续检查内部的特定的错误状态码。调用端可以通过这些信息来将业务逻辑错误与系统错误（如服务没有被注册到ev","size","size:","somedata);","somedatabaseservic","somedatabaseservice.createproxy(vertx,","somedatabaseserviceimpl","somedatabaseserviceimpl();","somedatabaseserviceimpl(vertx","somedatabaseserviceimpl(vertx);","somedatabaseserviceimpl.bad_shoe_size)","somedatabaseserviceimpl.connection)","somedatabaseservicevertxebproxy(vertx,","somedatabaseservicevertxebproxy。","somedatabaseservice，则代理名就是","static","string","super(bad_shoe_size_error,","systemerror(\"an","this.shoes","timeout）。","tojson","unexpect","value]","vert.x","vert.x用一个java接口来描述一个","verticl","vertx","vertx)","vertx,","vertx.eventbus().registerdefaultcodec(shoesizeexception.class,","vertx.eventbus().send(\"databas","vertxebproxy。比如你的服务接口类名是","void","{","|","}","});","——","一个编译时产生的","一些用于创建服务实例和服务代理实例的工厂方法","一旦注册了，这个服务就可用了。如果你的应用运行在集群上，则集群中节点都可访问。","中完成，也可以在你的代码的任何其它位置完成。","中：","为了使服务访问的方式一致，所有的服务都必须遵循以下的消息格式。格式非常简单：","举个例子，假如我们要去执行一个名为save的操作，此操作接受一个字符串类型的collection参数和一个jsonobject类型的document参数：","也可以指定消息传递的配置","也就是说，你可以通过以下方式进行服务调用：","产生的服务代理和处理器的命名是在类名的后面加相关的字段，例如，如果一个服务接口名为","代理的创建","代码生成","令","以及：","任何枚举类型","任何被","任意原生类型或包装的原生类型。","你也可以使用生成的代理类，代理类名是服务接口类名加上","你也可以将多语言api生成功能（@vertxgen注解）与","你可以通过声明一个特殊方法，并给其加上","你需要将服务接口抽象成一个java接口，并且加上","使用vert.x","使用代理类进行服务调用","例如：","依赖。","其中第二个方法会接受一个","函数（译者注：用于将数据实体类转换为","创建连接","包含一个整形（int）的错误状态码、一条消息和一个可选的","原文档","原文档最后更新于","参数类型可以是以下类型中任意一个：","参数类型和异步返回类型","另一个代理类","只要向event","只需要在构建配置中加上","可以是另一种代理类型（所以一个代理类可以作为另一个代理类的工厂）。","可能是一个系统错误(system","同时vert.x","向数据库中存储一些数据","因为服务代理会共享同一个vertx实例","在上面的例子中，action对应的值应该与服务接口的某个方法名称相对应，而消息体中每个","在服务方法中可用的参数类型和返回值类型是有限制的，这样使得转化为event","在服务端（被调用端）注册messagecodec。如果运行在单机模式下这就足够了","处理器类，用于响应由服务代理发送的事件。","如果你使用vert.x","如果想注销这个服务，可使用","如果想要的话，你也可以通过正常的jar来使用注解处理器，但是你需要显式地声明注解处理器。比如在","如果运行在集群模式下，那么需要将shoesizeexceptionmessagecodec注册到当前节点的ev","如果需要生成不同语言的服务代理代码，你需要添加对应的语言支持依赖，比如","如果需要的话，服务实现的时候也可以返回serviceexception的子类，只要向ev","如果需要返回异步结果，可以提供一个","实例的","实例）来返回错误。一个","实例，你可以在这里配置消息传递的相关参数（如","实际的服务方法","对于返回值，服务需使用","对应","对象（用于包含额外的重要信息）。为了方便起见，我们可以使用","对象，里面需要包含操作需要的所有参数。","工厂方法来创建一个已经是失败状态并且包装着","异步rpc","异步接口","异步方法，仅通知调用是否完成，不返回结果","异步方法，包含jsonobject类型的返回结果","当你写好服务接口以后，执行构建操作以生成代码。然后你需要将你的服务“注册”到event","当你的服务发布（expose）以后，你可能想要去调用它。这时，你需要创建一个服务代理，而代理的创建可以利用","当我们用这种方式写服务模块的时候，需要写很多重复的模板代码来监听event","当然，如果不愿意的话，你也可以不用服务代理类来访问远程服务。被广泛接受的与服务交互的方式就是直接在event","当编写一个vert.x应用时，你可能想将某个功能在某处隔离开来，并对应用的其它部分提供服务。","想要正确地生成服务代理类，服务接口的设计必须遵循一些规则。首先是需要遵循异步模式。如果需要返回结果，对应的方法需要包含一个","插件机制向jar包中添加服务代理注解处理器的配置。","文件中)：","方法。","方法去向调用端发送回一个返回值","方法返回类型","方法：","无论有没有用到服务代理，都应该用上面这种方式编写服务，因为这样允许服务交互时保持一致性。","暴露你的服务","更多服务接口的限制会在下面详解。","最后调用端可以检查自定义的异常类型了：","有了这个接口，vert.x会生成所有需要的用于在ev","服务代理介绍","服务代理假定event","服务代理类（servic","服务代理组件","服务代理组件提供的功能其实就是一种","服务代理组件的话，生成的代码会自动帮你处理这些问题。","服务代理组件，你就不必再写这么多的模板代码了，只需要专注服务的实现即可。","服务处理器类（servic","服务接口中不允许有重载的服务方法（即方法名相同，参数列表不同）。","服务接口的约束","服务方法可能会通过向方法的处理器（handler）传递一个失败状态的","服务调用端（client","服务，这个接口包含的方法遵循异步模式。在底层，服务调用是通过调用端向event","正常调用","注册服务","注意在vert.x","注意服务代理机制依赖于代码生成，所以每次修改服务接口以后都需重新执行构建过程来重新生成代码。","注解处理器（annot","注解来注销代理。当此方法被调用时，代理实例被清除。","注解的服务接口会触发生成对应的服务辅助类：","注解的类","注解相结合，用于生成其它vert.x支持的jvm语言对应的服务代理","注解，比如：","注解：","注销服务","消息体（messag","消息头(header)，作为要执行操作的名称","生成其他语言的代码","生成服务代理","用于创建服务代理实例的方法","的","的功能，其底层实现依赖于event","的构造函数（译者注：用于将","类型的参数放到最后。其中类型r可以是：","类型的参数，其中","类：","组件源码","组件示例","被","要使用vert.x","要实现服务代理（译者注：即生成服务代理类），还需要加入以下依赖：","让我们先看看服务代理并了解一下为什么它们有用。假设有一个数据库服务暴露在event","译者注：vert.x","调用失败","调用完毕","调用成功","调用端代理类（client","转换为数据实体类）以及一个","返回此服务实例的引用（this）并标注","返回类型必须是以下其中之一：","这个值可以是event","这个过程既可以在","这就是服务代理（servic","这意味着你可以只用java编写你的服务一次，就可以在其他语言中以一种习惯的api风格进行服务调用，而不必管服务是在本地还是在ev","这是一个针对maven的配置示例：","这是因为方法不能阻塞，并且如果服务是远程的，不可能立即返回结果而不阻塞。","进行方法调用","通常情况下，服务接口中会包含一个","通过event","通过消息与服务交互。","都要与服务方法中的某个","重载的方法","错误处理","集群模式下，你需要向集群中每个节点的event","需要有一个名为","静态方法用来创建服务代理实例，但这不是必须的：","（包含一个","，对应的服务代理类命名为"],"services/SockJSServiceProxies.html":["proxi","servic","sockj","vert.x"],"services/MavenServiceFactory.html":["factori","maven","servic","vert.x"],"services/HTTPServiceFactory.html":["factori","http","servic","vert.x"],"cloud/Cloud.html":["cloud","vert.x"],"cloud/OpenShiftCartridge.html":["cartridg","openshift","vert.x"],"cloud/OpenShiftUsingDIYCartridge.html":["cartridg","diy","openshift","us","vert.x"],"PLAN.html":["03","05","06","07","2017","28","3.4.1","3.4.2","[","[x]","]","access：","access：已翻译校对完成","boliza负责翻译，wuziqiang负责校对","breaker：已翻译校对完成","cet63负责翻译","chengenzhao负责翻译，zlf负责校对","circuit","client：已翻译校对完成","clustering：","clustering：boliza负责翻译，wuziqiang负责校对","clustering：已翻译校对完成","common","config：已翻译校对完成","core：","core：已翻译校对完成","dac1989负责翻译，kkkoko校对","data","discovery：已翻译校对完成","gy负责翻译，chengenzhao校对","integr","interface：已翻译校对完成","iot：","iot：lizhenxiang负责翻译，943470549@qq.com负责校对","iot：计划中","jdbc","kafka","lizhenxiang负责翻译，943470549@qq.com负责校对","microservic","microservices：","mongo","mysql/postgresql","proxy：已重新翻译","reactive：","reactive：已翻译校对完成","redi","servic","silentbalanceyh负责翻译，chengenzhao、kkkoko、gy、hxl、toyer、漓江校对","sql","test","troopson@163.com，me.yan.xia@qq.com负责翻译和校对","unit：待认领","unit：计划中","vert.x","web","webclient：","web：","web：已翻译校对完成","发布后，更新相应的文档翻译。","官方文档翻译工作计划","对应版本：vert.x","当前进度","待","截至：2017","本次计划预计五月下旬完成。","本次计划预计五月中旬完成。","翻译计划"]},"length":57},"tokenStore":{"root":{"0":{"3":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294},"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}},"5":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.016129032258064516}}},"6":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}},"7":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}},"9":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},"/":{"docs":{},"/":{"docs":{},"属":{"docs":{},"性":{"docs":{},"变":{"docs":{},"量":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},"，":{"docs":{},"它":{"docs":{},"表":{"docs":{},"示":{"docs":{},"：":{"docs":{},"监":{"docs":{},"听":{"docs":{},"所":{"docs":{},"有":{"docs":{},"可":{"docs":{},"用":{"docs":{},"地":{"docs":{},"址":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"端":{"docs":{},"口":{"docs":{},"号":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"1":{"0":{"docs":{},".":{"1":{"docs":{},".":{"1":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}},"docs":{}}},"docs":{}}},"docs":{}},"9":{"docs":{},".":{"0":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}},"docs":{}}},"docs":{}},"，":{"docs":{},"这":{"docs":{},"也":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"殊":{"docs":{},"值":{"docs":{},"，":{"docs":{},"它":{"docs":{},"告":{"docs":{},"诉":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"随":{"docs":{},"机":{"docs":{},"选":{"docs":{},"择":{"docs":{},"并":{"docs":{},"监":{"docs":{},"听":{"docs":{},"一":{"docs":{},"个":{"docs":{},"本":{"docs":{},"地":{"docs":{},"没":{"docs":{},"有":{"docs":{},"被":{"docs":{},"占":{"docs":{},"用":{"docs":{},"的":{"docs":{},"端":{"docs":{},"口":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"默":{"docs":{},"认":{"docs":{},"大":{"docs":{},"小":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}}}}}}}}},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"是":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"表":{"docs":{},"示":{"docs":{},"一":{"docs":{},"直":{"docs":{},"存":{"docs":{},"在":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"永":{"docs":{},"远":{"docs":{},"存":{"docs":{},"活":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"1":{"0":{"0":{"0":{"0":{"0":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}},"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"的":{"docs":{},"反":{"docs":{},"向":{"docs":{},"查":{"docs":{},"找":{"docs":{},"类":{"docs":{},"似":{"docs":{},"的":{"docs":{},"事":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"2":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}}},"docs":{}}},"docs":{}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"。":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}},"秒":{"docs":{},")":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}},"后":{"docs":{},"注":{"docs":{},"销":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"2":{"0":{"0":{"0":{"0":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"（":{"2":{"docs":{},"分":{"docs":{},"钟":{"docs":{},"）":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"3":{"4":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}},"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"7":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"docs":{}}},"docs":{}}},"docs":{}}},"8":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"k":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}},"docs":{}},"4":{"5":{"6":{"docs":{},"m":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"docs":{}},"docs":{},"|":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"5":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},":":{"5":{"4":{"docs":{},":":{"1":{"4":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"|":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"6":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}},"|":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"进":{"docs":{},"制":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"中":{"docs":{},"导":{"docs":{},"出":{"docs":{},"创":{"docs":{},"建":{"docs":{},"时":{"docs":{},"间":{"docs":{},"。":{"docs":{},"若":{"docs":{},"您":{"docs":{},"选":{"docs":{},"择":{"docs":{},"其":{"docs":{},"他":{"docs":{},"类":{"docs":{},"型":{"docs":{},"作":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}},"作":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"8":{"docs":{},"|":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"1":{"docs":{},".":{"2":{"0":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}},"docs":{}},"3":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"|":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211}},".":{"0":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.017543859649122806},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"缺":{"docs":{},"省":{"docs":{},"值":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"）":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"8":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.017543859649122806},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052}},"/":{"docs":{},"/":{"docs":{},"新":{"docs":{},"增":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"基":{"docs":{},"础":{"docs":{},"知":{"docs":{},"识":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}},".":{"0":{"docs":{},"u":{"7":{"4":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"|":{"docs":{},"j":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"/":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"/":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"m":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"/":{"docs":{},"s":{"docs":{},"c":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"代":{"docs":{},"理":{"docs":{},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{},"参":{"docs":{},"数":{"docs":{},"化":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"4":{"docs":{},"j":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}}}}}}}}}},")":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"，":{"docs":{},"以":{"docs":{},"此":{"docs":{},"类":{"docs":{},"推":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"返":{"docs":{},"回":{"docs":{},"所":{"docs":{},"有":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"2":{"0":{"0":{"0":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},")":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.008403361344537815}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"1":{"7":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294},"PLAN.html":{"ref":"PLAN.html","tf":0.024193548387096774}}},"docs":{}},"4":{"5":{"8":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}},"8":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.016172506738544475}}},"docs":{}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"|":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"1":{"docs":{},"/":{"0":{"4":{"docs":{},"/":{"2":{"0":{"1":{"7":{"docs":{},".":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"|":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"t":{"0":{"0":{"docs":{},":":{"0":{"0":{"docs":{},":":{"0":{"0":{"docs":{},"+":{"0":{"0":{"docs":{},":":{"0":{"0":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"2":{"4":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},"/":{"5":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}},"docs":{}}},"1":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{},"|":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"3":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}}},"docs":{}}},"docs":{}}},"1":{"docs":{},".":{"2":{"5":{"5":{"docs":{},".":{"2":{"5":{"5":{"docs":{},".":{"2":{"5":{"4":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"2":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},"/":{"5":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}},"docs":{}}},"1":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}},"docs":{}}},"docs":{}}},"docs":{}}},"9":{"docs":{},".":{"2":{"5":{"5":{"docs":{},".":{"2":{"5":{"5":{"docs":{},".":{"2":{"5":{"4":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"|":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"4":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"|":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"5":{"6":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.018867924528301886}}},"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"|":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"6":{"docs":{},"/":{"0":{"4":{"docs":{},"/":{"2":{"0":{"1":{"7":{"docs":{},".":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.011695906432748537},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"|":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"7":{"0":{"0":{"0":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"docs":{}},"1":{"7":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"设":{"docs":{},"置":{"docs":{},"了":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"8":{"0":{"0":{"0":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"docs":{}},"docs":{}},"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":5.001652892561983}},".":{"1":{"1":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},".":{"4":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}},"docs":{}},"，":{"docs":{},"来":{"docs":{},"自":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}},"docs":{},".":{"1":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}},"docs":{}}},"4":{"docs":{},".":{"2":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403}}},"docs":{}}},"6":{"docs":{},".":{"3":{"2":{"docs":{},".":{"1":{"6":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"x":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"分":{"docs":{},"钟":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"和":{"docs":{},"s":{"docs":{},"l":{"docs":{},"f":{"4":{"docs":{},"j":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"预":{"docs":{},"设":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"类":{"docs":{},"名":{"docs":{},"为":{"docs":{},"：":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"4":{"docs":{},"j":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"，":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"4":{"docs":{},"j":{"2":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"和":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"s":{"docs":{},"l":{"docs":{},"f":{"4":{"docs":{},"j":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"。":{"docs":{},"如":{"docs":{},"您":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"些":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"还":{"docs":{},"应":{"docs":{},"确":{"docs":{},"保":{"docs":{},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"4":{"docs":{},"j":{"docs":{},"或":{"docs":{},"s":{"docs":{},"l":{"docs":{},"f":{"4":{"docs":{},"j":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"在":{"docs":{},"您":{"docs":{},"的":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"上":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"docs":{}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"的":{"docs":{},"代":{"docs":{},"理":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"像":{"docs":{},"s":{"docs":{},"l":{"docs":{},"f":{"4":{"docs":{},"j":{"docs":{},"代":{"docs":{},"理":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"{":{"docs":{},"}":{"docs":{},"语":{"docs":{},"法":{"docs":{},"，":{"docs":{},"j":{"docs":{},"u":{"docs":{},"l":{"docs":{},"代":{"docs":{},"理":{"docs":{},"使":{"docs":{},"用":{"docs":{},"如":{"docs":{},"{":{"docs":{},"x":{"docs":{},"}":{"docs":{},"语":{"docs":{},"法":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}},"）":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"n":{"docs":{},"是":{"docs":{},"组":{"docs":{},"中":{"docs":{},"节":{"docs":{},"点":{"docs":{},"数":{"docs":{},"。":{"docs":{},"若":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"的":{"docs":{},"q":{"docs":{},"节":{"docs":{},"点":{"docs":{},"少":{"docs":{},"于":{"docs":{},"h":{"docs":{},"a":{"docs":{},"节":{"docs":{},"点":{"docs":{},"，":{"docs":{},"h":{"docs":{},"a":{"docs":{},"部":{"docs":{},"署":{"docs":{},"将":{"docs":{},"被":{"docs":{},"撤":{"docs":{},"销":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"/":{"docs":{},"当":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"：":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"s":{"docs":{},"/":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"auth/Auth.html":{"ref":"auth/Auth.html","tf":0.041666666666666664}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},"}":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407}}}},"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},")":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}},"docs":{}},"1":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"、":{"3":{"0":{"2":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"、":{"3":{"0":{"3":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"3":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"4":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"7":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},";":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"3":{"0":{"6":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"0":{"0":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.016172506738544475}}},"docs":{}},"8":{"4":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.01078167115902965}}},"docs":{}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},".":{"0":{"docs":{},".":{"0":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"docs":{}}},"1":{"docs":{},".":{"0":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"docs":{}}},"2":{"docs":{},".":{"1":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}},"docs":{}}},"3":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403}}},"4":{"docs":{},".":{"0":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"开":{"docs":{},"始":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"另":{"docs":{},"一":{"docs":{},"种":{"docs":{},"更":{"docs":{},"高":{"docs":{},"层":{"docs":{},"次":{"docs":{},"封":{"docs":{},"装":{"docs":{},"、":{"docs":{},"更":{"docs":{},"方":{"docs":{},"便":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"1":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.004975124378109453},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0025549310168625446},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.013711151736745886},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825},"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"。":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"，":{"docs":{},"应":{"docs":{},"该":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"安":{"docs":{},"装":{"docs":{},"包":{"docs":{},"中":{"docs":{},"。":{"docs":{},"同":{"docs":{},"时":{"docs":{},"也":{"docs":{},"要":{"docs":{},"将":{"docs":{},"j":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"2":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}},"8":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}},"docs":{}}},"5":{"docs":{},".":{"docs":{},"x":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}},"6":{"docs":{},".":{"3":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}},"docs":{}}},"docs":{}},"以":{"docs":{},"上":{"docs":{},"版":{"docs":{},"本":{"docs":{},"需":{"docs":{},"要":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}},"要":{"docs":{},"求":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},")":{"docs":{},";":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"配":{"docs":{},"置":{"docs":{},"以":{"docs":{},"及":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"上":{"docs":{},"做":{"docs":{},"一":{"docs":{},"些":{"docs":{},"改":{"docs":{},"动":{"docs":{},"。":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}}},"4":{"0":{"1":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"3":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}},"4":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"1":{"3":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"docs":{}},"2":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}},"3":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"6":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403}}},"docs":{}}},"1":{"2":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}},"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}},"3":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}},"4":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}},"docs":{}}},"5":{"0":{"0":{"0":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{},"是":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"3":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"1":{"2":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.008086253369272238}},"算":{"docs":{},"法":{"docs":{},"加":{"docs":{},"密":{"docs":{},"后":{"docs":{},"进":{"docs":{},"行":{"docs":{},"存":{"docs":{},"储":{"docs":{},"，":{"docs":{},"之":{"docs":{},"后":{"docs":{},"会":{"docs":{},"连":{"docs":{},"接":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"值":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"值":{"docs":{},"和":{"docs":{},"密":{"docs":{},"码":{"docs":{},"存":{"docs":{},"储":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"表":{"docs":{},"里":{"docs":{},"。":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"改":{"docs":{},"变":{"docs":{},"存":{"docs":{},"储":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"值":{"docs":{},"的":{"docs":{},"字":{"docs":{},"段":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"是":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"\"":{"docs":{},"，":{"docs":{},"你":{"docs":{},"同":{"docs":{},"样":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"来":{"docs":{},"改":{"docs":{},"变":{"docs":{},"一":{"docs":{},"些":{"docs":{},"行":{"docs":{},"为":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"调":{"docs":{},"用":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"y":{"docs":{},"方":{"docs":{},"法":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"读":{"docs":{},"取":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"策":{"docs":{},"略":{"docs":{},"设":{"docs":{},"置":{"docs":{},"。":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"2":{"1":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}},"docs":{}},"4":{"3":{"2":{"docs":{},"，":{"docs":{},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}},"docs":{}},"docs":{}},"8":{"7":{"docs":{},"}":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}},"docs":{}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.002677702044790652},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},".":{"1":{"docs":{},".":{"2":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}}},"2":{"docs":{},".":{"0":{"docs":{},"上":{"docs":{},"的":{"docs":{},"工":{"docs":{},"作":{"docs":{},"部":{"docs":{},"署":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"docs":{}}},"docs":{}},"}":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"秒":{"docs":{},"后":{"docs":{},"我":{"docs":{},"们":{"docs":{},"释":{"docs":{},"放":{"docs":{},"该":{"docs":{},"锁":{"docs":{},"其":{"docs":{},"他":{"docs":{},"人":{"docs":{},"可":{"docs":{},"以":{"docs":{},"得":{"docs":{},"到":{"docs":{},"它":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"再":{"docs":{},"恢":{"docs":{},"复":{"docs":{},",":{"docs":{},"继":{"docs":{},"续":{"docs":{},"读":{"docs":{},"取":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},")":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"6":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"docs":{}},"docs":{}},"docs":{}},"3":{"7":{"9":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"docs":{}},"docs":{}},"4":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"8":{"0":{"8":{"0":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"1":{"9":{"2":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0027155465037338763}}}},"docs":{}},"docs":{}},"4":{"3":{"3":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"docs":{}},"docs":{}},"6":{"0":{"1":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}},"（":{"docs":{},"y":{"docs":{},"y":{"docs":{},"y":{"docs":{},"i":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}},"docs":{}},"docs":{}},"8":{"5":{"9":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}},"8":{"8":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}},"docs":{}},"docs":{}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"以":{"docs":{},"上":{"docs":{},"版":{"docs":{},"本":{"docs":{},"方":{"docs":{},"能":{"docs":{},"运":{"docs":{},"行":{"docs":{},"；":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}},"可":{"docs":{},"运":{"docs":{},"行":{"docs":{},"，":{"docs":{},"且":{"docs":{},"大":{"docs":{},"量":{"docs":{},"应":{"docs":{},"用":{"docs":{},"了":{"1":{"docs":{},".":{"8":{"docs":{},"加":{"docs":{},"入":{"docs":{},"的":{"docs":{},"新":{"docs":{},"语":{"docs":{},"法":{"docs":{},"糖":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"匿":{"docs":{},"名":{"docs":{},"函":{"docs":{},"数":{"docs":{},"l":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"d":{"docs":{},"a":{"docs":{},"。":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}},".":{"1":{"docs":{},".":{"7":{"docs":{},".":{"docs":{},"v":{"2":{"0":{"1":{"6":{"0":{"1":{"2":{"1":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"完":{"docs":{},"整":{"docs":{},"列":{"docs":{},"表":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}}},"8":{"docs":{},".":{"4":{"docs":{},".":{"4":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}},"8":{"docs":{},".":{"8":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}}},"docs":{}}},"docs":{}},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{},"应":{"docs":{},"该":{"docs":{},"通":{"docs":{},"过":{"docs":{},"其":{"docs":{},"他":{"docs":{},"方":{"docs":{},"式":{"docs":{},"启":{"docs":{},"用":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"行":{"docs":{},"版":{"docs":{},"用":{"docs":{},"以":{"docs":{},"支":{"docs":{},"持":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"的":{"docs":{},"j":{"docs":{},"d":{"docs":{},"k":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"环":{"docs":{},"境":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"编":{"docs":{},"码":{"docs":{},"方":{"docs":{},"式":{"docs":{},"写":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"编":{"docs":{},"码":{"docs":{},"方":{"docs":{},"式":{"docs":{},"编":{"docs":{},"码":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"和":{"docs":{},"以":{"docs":{},"指":{"docs":{},"定":{"docs":{},"方":{"docs":{},"式":{"docs":{},"编":{"docs":{},"码":{"docs":{},"编":{"docs":{},"码":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"、":{"docs":{},"或":{"docs":{},"写":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}},"9":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"杀":{"docs":{},"死":{"docs":{},"进":{"docs":{},"程":{"docs":{},"来":{"docs":{},"测":{"docs":{},"试":{"docs":{},"）":{"docs":{},"，":{"docs":{},"运":{"docs":{},"行":{"docs":{},"m":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},")":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"!":{"docs":{},"\"":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}},"docs":{},".":{"0":{"0":{"0":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}},"docs":{}},"docs":{}},"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635}},"/":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"v":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},":":{"docs":{},":":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},")":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0063025210084033615}}}}}}}}}}}}}}},"t":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}},"(":{"docs":{},"\"":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"\"":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{},"u":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}},"_":{"docs":{},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.005390835579514825},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.005390835579514825},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.005484460694698354}}}}}}},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}},"r":{"docs":{},"l":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.01487603305785124}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.01487603305785124}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.005390835579514825}}}}}}},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.011570247933884297}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.011570247933884297}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}}}}}}}}},"d":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"_":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}}}}}}},"a":{"docs":{},"n":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.01487603305785124}}}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}}}}}}}},"o":{"docs":{},"m":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"s":{"docs":{},"l":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.002742230347349177}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"b":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"/":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"8":{"0":{"8":{"0":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.0074487895716946}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},".":{"docs":{},".":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.009708737864077669},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.007677543186180422},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.008213552361396304},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.011661807580174927},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}},".":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0009289363678588017}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"o":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"c":{"docs":{},"h":{"docs":{},"o":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"c":{"docs":{},"h":{"docs":{},"o":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0009289363678588017}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"1":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}},"2":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}},"docs":{}}}}}}}}}}}}}},"s":{"docs":{},"(":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},")":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"/":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"1":{"2":{"3":{"4":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"docs":{}},"docs":{}},"8":{"0":{"8":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{},":":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"v":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"1":{"2":{"3":{"4":{"docs":{},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"1":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"2":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}},"docs":{}}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"o":{"docs":{},"/":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{},"/":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"1":{"2":{"3":{"4":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.015539305301645339}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"e":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0009289363678588017}}}}}}}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}},"y":{"docs":{},"a":{"docs":{},"m":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"1":{"2":{"7":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"1":{"0":{"8":{"0":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"docs":{}},"docs":{}},"docs":{}},"3":{"1":{"2":{"8":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}}}},"1":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"docs":{}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"3":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"docs":{}},"docs":{}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"5":{"docs":{},")":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}},"docs":{}}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"8":{"0":{"8":{"0":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"y":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544}}}}},"docs":{}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"1":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}}}}},"s":{"docs":{},"l":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"3":{"0":{"2":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}},"docs":{}},"docs":{}},"4":{"0":{"4":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"5":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"d":{"docs":{},"(":{"2":{"0":{"0":{"0":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"\"":{"docs":{},"e":{"docs":{},"v":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"u":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"n":{"docs":{},"v":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.003656307129798903}}}}}}}},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.002742230347349177}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"y":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"z":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{},"/":{"docs":{},"v":{"3":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"docs":{}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"2":{"0":{"0":{"0":{"docs":{},")":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"i":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"i":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.012104283054003724}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"l":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"t":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"u":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}},"h":{"docs":{},"b":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"、":{"docs":{},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"s":{"docs":{},"、":{"docs":{},".":{"docs":{},"j":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"8":{"0":{"8":{"0":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"5":{"0":{"0":{"0":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"4":{"4":{"3":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"docs":{}},"docs":{}},"8":{"0":{"8":{"0":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.0111731843575419}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},":":{"4":{"0":{"4":{"3":{"docs":{},"/":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},":":{"docs":{},":":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"2":{"5":{"6":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},"docs":{}},"docs":{}},"docs":{}}}}}}},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0063025210084033615}}}}}}}}}}}}}}}}}}},"b":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"u":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.004381694255111977},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.009554140127388535},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.005109862033725089},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.007312614259597806},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"s":{"docs":{},"/":{"docs":{},"m":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001207617278216442}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"1":{"2":{"3":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"1":{"0":{"0":{"0":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"0":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}}},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"1":{"docs":{},":":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"\\":{"docs":{},"n":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"2":{"docs":{},":":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"o":{"docs":{},"u":{"docs":{},"?":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"3":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"4":{"docs":{},":":{"docs":{},"\\":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.008824895494658615},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.003693444136657433}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"1":{"2":{"3":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"2":{"4":{"5":{"docs":{},"l":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"r":{"docs":{},"(":{"1":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}},"docs":{}},"2":{"8":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}},"docs":{}},"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}},")":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"1":{"2":{"docs":{},".":{"3":{"4":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"4":{"3":{"2":{"docs":{},"l":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"1":{"2":{"docs":{},".":{"3":{"4":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"1":{"2":{"3":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"3":{"2":{"1":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"1":{"2":{"3":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"1":{"docs":{},".":{"2":{"3":{"docs":{},"f":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}},"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413}}}},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"您":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"若":{"docs":{},"您":{"docs":{},"知":{"docs":{},"道":{"docs":{},"您":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"将":{"docs":{},"会":{"docs":{},"在":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"之":{"docs":{},"前":{"docs":{},"拷":{"docs":{},"贝":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"长":{"docs":{},"度":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"，":{"docs":{},"在":{"docs":{},"写":{"docs":{},"入":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"它":{"docs":{},"也":{"docs":{},"存":{"docs":{},"在":{"docs":{},"各":{"docs":{},"种":{"docs":{},"不":{"docs":{},"同":{"docs":{},"数":{"docs":{},"据":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"当":{"docs":{},"数":{"docs":{},"据":{"docs":{},"从":{"docs":{},"网":{"docs":{},"络":{"docs":{},"到":{"docs":{},"达":{"docs":{},"时":{"docs":{},"，":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"可":{"docs":{},"以":{"docs":{},"多":{"docs":{},"次":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"这":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"的":{"docs":{},"大":{"docs":{},"小":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"和":{"docs":{},"先":{"docs":{},"调":{"docs":{},"用":{"docs":{},"带":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"编":{"docs":{},"码":{"docs":{},"方":{"docs":{},"式":{"docs":{},"编":{"docs":{},"码":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"缓":{"docs":{},"冲":{"docs":{},"区":{"docs":{},"（":{"docs":{},"一":{"docs":{},"些":{"docs":{},"地":{"docs":{},"方":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"要":{"docs":{},"写":{"docs":{},"入":{"docs":{},"的":{"docs":{},"缓":{"docs":{},"冲":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"读":{"docs":{},"取":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"、":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"、":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"(":{"1":{"docs":{},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"docs":{}}}}}},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"则":{"docs":{},"需":{"docs":{},"要":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"任":{"docs":{},"何":{"docs":{},"o":{"docs":{},"s":{"docs":{},"g":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"s":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"（":{"docs":{},"非":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"只":{"docs":{},"要":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"链":{"docs":{},"接":{"docs":{},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"每":{"docs":{},"一":{"docs":{},"次":{"docs":{},"都":{"docs":{},"与":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"建":{"docs":{},"立":{"docs":{},"链":{"docs":{},"接":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"而":{"docs":{},"有":{"docs":{},"了":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}},"上":{"docs":{},"注":{"docs":{},"册":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"时":{"docs":{},"，":{"docs":{},"注":{"docs":{},"册":{"docs":{},"信":{"docs":{},"息":{"docs":{},"会":{"docs":{},"花":{"docs":{},"费":{"docs":{},"一":{"docs":{},"些":{"docs":{},"时":{"docs":{},"间":{"docs":{},"才":{"docs":{},"能":{"docs":{},"传":{"docs":{},"播":{"docs":{},"到":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"节":{"docs":{},"点":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"相":{"docs":{},"互":{"docs":{},"通":{"docs":{},"信":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"发":{"docs":{},"布":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{},"事":{"docs":{},"件":{"docs":{},"发":{"docs":{},"送":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}},"暴":{"docs":{},"露":{"docs":{},"（":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"）":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"它":{"docs":{},"们":{"docs":{},"在":{"docs":{},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"布":{"docs":{},"时":{"docs":{},"清":{"docs":{},"楚":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"（":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"）":{"docs":{},"，":{"docs":{},"其":{"docs":{},"他":{"docs":{},"任":{"docs":{},"意":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"组":{"docs":{},"件":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"去":{"docs":{},"调":{"docs":{},"用":{"docs":{},"它":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"访":{"docs":{},"问":{"docs":{},"你":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"模":{"docs":{},"板":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"也":{"docs":{},"会":{"docs":{},"生":{"docs":{},"成":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"在":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"机":{"docs":{},"器":{"docs":{},"上":{"docs":{},"）":{"docs":{},"，":{"docs":{},"调":{"docs":{},"用":{"docs":{},"端":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"都":{"docs":{},"能":{"docs":{},"正":{"docs":{},"常":{"docs":{},"工":{"docs":{},"作":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"区":{"docs":{},"分":{"docs":{},"开":{"docs":{},"，":{"docs":{},"以":{"docs":{},"便":{"docs":{},"确":{"docs":{},"定":{"docs":{},"到":{"docs":{},"底":{"docs":{},"发":{"docs":{},"生":{"docs":{},"了":{"docs":{},"哪":{"docs":{},"一":{"docs":{},"种":{"docs":{},"业":{"docs":{},"务":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"做":{"docs":{},"以":{"docs":{},"下":{"docs":{},"的":{"docs":{},"事":{"docs":{},"情":{"docs":{},"来":{"docs":{},"调":{"docs":{},"用":{"docs":{},"服":{"docs":{},"务":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"连":{"docs":{},"接":{"docs":{},"替":{"docs":{},"换":{"docs":{},"传":{"docs":{},"统":{"docs":{},"的":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"注":{"docs":{},"册":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"当":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"中":{"docs":{},"收":{"docs":{},"到":{"docs":{},"任":{"docs":{},"意":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"是":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"消":{"docs":{},"息":{"docs":{},"、":{"docs":{},"将":{"docs":{},"其":{"docs":{},"分":{"docs":{},"派":{"docs":{},"到":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"并":{"docs":{},"将":{"docs":{},"结":{"docs":{},"果":{"docs":{},"返":{"docs":{},"回":{"docs":{},"到":{"docs":{},"e":{"docs":{},"v":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}},"遵":{"docs":{},"循":{"docs":{},"一":{"docs":{},"定":{"docs":{},"的":{"docs":{},"格":{"docs":{},"式":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"能":{"docs":{},"被":{"docs":{},"用":{"docs":{},"于":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}},"都":{"docs":{},"会":{"docs":{},"触":{"docs":{},"发":{"docs":{},"一":{"docs":{},"个":{"docs":{},"事":{"docs":{},"件":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"事":{"docs":{},"件":{"docs":{},"包":{"docs":{},"含":{"docs":{},"着":{"docs":{},"被":{"docs":{},"修":{"docs":{},"改":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}},"也":{"docs":{},"支":{"docs":{},"持":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"会":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"将":{"docs":{},"消":{"docs":{},"息":{"docs":{},"传":{"docs":{},"递":{"docs":{},"到":{"docs":{},"注":{"docs":{},"册":{"docs":{},"在":{"docs":{},"e":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"可":{"docs":{},"形":{"docs":{},"成":{"docs":{},"跨":{"docs":{},"越":{"docs":{},"多":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"节":{"docs":{},"点":{"docs":{},"和":{"docs":{},"多":{"docs":{},"个":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"的":{"docs":{},"点":{"docs":{},"对":{"docs":{},"点":{"docs":{},"的":{"docs":{},"分":{"docs":{},"布":{"docs":{},"式":{"docs":{},"消":{"docs":{},"息":{"docs":{},"系":{"docs":{},"统":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"地":{"docs":{},"址":{"docs":{},"感":{"docs":{},"兴":{"docs":{},"趣":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"、":{"docs":{},"i":{"docs":{},"p":{"docs":{},"/":{"docs":{},"d":{"docs":{},"n":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}},"支":{"docs":{},"持":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"发":{"docs":{},"布":{"docs":{},"/":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"、":{"docs":{},"点":{"docs":{},"对":{"docs":{},"点":{"docs":{},"、":{"docs":{},"请":{"docs":{},"求":{"docs":{},"/":{"docs":{},"响":{"docs":{},"应":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"通":{"docs":{},"信":{"docs":{},"方":{"docs":{},"式":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"需":{"docs":{},"要":{"docs":{},"表":{"docs":{},"示":{"docs":{},"调":{"docs":{},"用":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"很":{"docs":{},"简":{"docs":{},"单":{"docs":{},"。":{"docs":{},"基":{"docs":{},"本":{"docs":{},"上":{"docs":{},"只":{"docs":{},"涉":{"docs":{},"及":{"docs":{},"注":{"docs":{},"册":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"、":{"docs":{},"撤":{"docs":{},"销":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"和":{"docs":{},"发":{"docs":{},"送":{"docs":{},"和":{"docs":{},"发":{"docs":{},"布":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"地":{"docs":{},"址":{"docs":{},"）":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}}}}},"别":{"docs":{},"处":{"docs":{},"。":{"docs":{},"想":{"docs":{},"要":{"docs":{},"利":{"docs":{},"用":{"docs":{},"多":{"docs":{},"语":{"docs":{},"言":{"docs":{},"代":{"docs":{},"码":{"docs":{},"生":{"docs":{},"成":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"不":{"docs":{},"要":{"docs":{},"忘":{"docs":{},"记":{"docs":{},"添":{"docs":{},"加":{"docs":{},"对":{"docs":{},"应":{"docs":{},"支":{"docs":{},"持":{"docs":{},"语":{"docs":{},"言":{"docs":{},"的":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"。":{"docs":{},"以":{"docs":{},"下":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"节":{"docs":{},"点":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"传":{"docs":{},"输":{"docs":{},"，":{"docs":{},"这":{"docs":{},"是":{"docs":{},"由":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"事":{"docs":{},"件":{"docs":{},"总":{"docs":{},"线":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"发":{"docs":{},"送":{"docs":{},"消":{"docs":{},"息":{"docs":{},"到":{"docs":{},"某":{"docs":{},"个":{"docs":{},"地":{"docs":{},"址":{"docs":{},"的":{"docs":{},"组":{"docs":{},"件":{"docs":{},"。":{"docs":{},"消":{"docs":{},"息":{"docs":{},"源":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"是":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"不":{"docs":{},"管":{"docs":{},"你":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"实":{"docs":{},"际":{"docs":{},"在":{"docs":{},"哪":{"docs":{},"个":{"docs":{},"e":{"docs":{},"v":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}},"，":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"端":{"docs":{},"收":{"docs":{},"到":{"docs":{},"消":{"docs":{},"息":{"docs":{},"调":{"docs":{},"用":{"docs":{},"服":{"docs":{},"务":{"docs":{},"并":{"docs":{},"且":{"docs":{},"返":{"docs":{},"回":{"docs":{},"结":{"docs":{},"果":{"docs":{},"来":{"docs":{},"实":{"docs":{},"现":{"docs":{},"的":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"使":{"docs":{},"其":{"docs":{},"更":{"docs":{},"容":{"docs":{},"易":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"组":{"docs":{},"件":{"docs":{},"可":{"docs":{},"以":{"docs":{},"生":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"直":{"docs":{},"接":{"docs":{},"调":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"代":{"docs":{},"理":{"docs":{},"（":{"docs":{},"通":{"docs":{},"过":{"docs":{},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"中":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"）":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"的":{"docs":{},"一":{"docs":{},"种":{"docs":{},"异":{"docs":{},"步":{"docs":{},"r":{"docs":{},"p":{"docs":{},"c":{"docs":{},"服":{"docs":{},"务":{"docs":{},"。":{"docs":{},"当":{"docs":{},"从":{"docs":{},"一":{"docs":{},"个":{"docs":{},"e":{"docs":{},"v":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"中":{"docs":{},"获":{"docs":{},"取":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"时":{"docs":{},"，":{"docs":{},"你":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"得":{"docs":{},"到":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"。":{"docs":{},"你":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"先":{"docs":{},"获":{"docs":{},"取":{"docs":{},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"然":{"docs":{},"后":{"docs":{},"获":{"docs":{},"取":{"docs":{},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"直":{"docs":{},"接":{"docs":{},"通":{"docs":{},"过":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"下":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}},"注":{"docs":{},"册":{"docs":{},"了":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"直":{"docs":{},"接":{"docs":{},"向":{"docs":{},"调":{"docs":{},"用":{"docs":{},"者":{"docs":{},"返":{"docs":{},"回":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"异":{"docs":{},"常":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"给":{"docs":{},"定":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"子":{"docs":{},"类":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"异":{"docs":{},"常":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"更":{"docs":{},"加":{"docs":{},"容":{"docs":{},"易":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"我":{"docs":{},"们":{"docs":{},"就":{"docs":{},"来":{"docs":{},"看":{"docs":{},"一":{"docs":{},"下":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"约":{"docs":{},"定":{"docs":{},"（":{"docs":{},"不":{"docs":{},"使":{"docs":{},"用":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"）":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"a":{"docs":{},"n":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},"(":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"t":{"docs":{},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"=":{"docs":{},"\"":{"docs":{},"+":{"docs":{},"b":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"组":{"docs":{},"件":{"docs":{},"是":{"docs":{},"基":{"docs":{},"于":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"的":{"docs":{},"后":{"docs":{},"端":{"docs":{},"存":{"docs":{},"储":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"d":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"_":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"_":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"e":{"docs":{},"r":{"docs":{},"：":{"docs":{},"负":{"docs":{},"载":{"docs":{},"均":{"docs":{},"衡":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}},"s":{"docs":{},"e":{"6":{"4":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.004103967168262654}},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407}}},"y":{"docs":{},"）":{"docs":{},"，":{"docs":{},"后":{"docs":{},"边":{"docs":{},"跟":{"docs":{},"着":{"docs":{},"零":{"docs":{},"个":{"docs":{},"或":{"docs":{},"多":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},")":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},")":{"docs":{},"，":{"docs":{},"如":{"docs":{},"下":{"docs":{},"所":{"docs":{},"示":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"阻":{"docs":{},"塞":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}},"：":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0013005109150023223},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.006517690875232775},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}},"y":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"：":{"docs":{},"请":{"docs":{},"求":{"docs":{},"/":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"（":{"docs":{},"有":{"docs":{},"些":{"docs":{},"地":{"docs":{},"方":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"成":{"docs":{},"请":{"docs":{},"求":{"docs":{},"/":{"docs":{},"响":{"docs":{},"应":{"docs":{},"正":{"docs":{},"文":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}},"a":{"docs":{},"s":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"(":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}},"）":{"docs":{},"应":{"docs":{},"该":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.017543859649122806},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.009852216748768473},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.013605442176870748}},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"$":{"docs":{},"{":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"}":{"docs":{},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"k":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.004073319755600814}}}},"x":{"docs":{},"：":{"docs":{},"标":{"docs":{},"准":{"docs":{},"环":{"docs":{},"境":{"docs":{},"（":{"docs":{},"开":{"docs":{},"箱":{"docs":{},"即":{"docs":{},"用":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"）":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"某":{"docs":{},"些":{"docs":{},"针":{"docs":{},"对":{"docs":{},"认":{"docs":{},"证":{"docs":{},"和":{"docs":{},"授":{"docs":{},"权":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"查":{"docs":{},"询":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"想":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"）":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"查":{"docs":{},"询":{"docs":{},"内":{"docs":{},"容":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"下":{"docs":{},"边":{"docs":{},"几":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"进":{"docs":{},"行":{"docs":{},"更":{"docs":{},"改":{"docs":{},"：":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},"集":{"docs":{},"合":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"，":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"字":{"docs":{},"段":{"docs":{},"使":{"docs":{},"用":{"docs":{},"\"":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"进":{"docs":{},"行":{"docs":{},"存":{"docs":{},"储":{"docs":{},"和":{"docs":{},"读":{"docs":{},"取":{"docs":{},"。":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"p":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725}},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"上":{"docs":{},"加":{"docs":{},"上":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"负":{"docs":{},"责":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"，":{"docs":{},"w":{"docs":{},"u":{"docs":{},"z":{"docs":{},"i":{"docs":{},"q":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"负":{"docs":{},"责":{"docs":{},"校":{"docs":{},"对":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"分":{"docs":{},"支":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"g":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"eventbusbridge/CamelBridge.html":{"ref":"eventbusbridge/CamelBridge.html","tf":5.333333333333333},"eventbusbridge/TCPEventbusBridge.html":{"ref":"eventbusbridge/TCPEventbusBridge.html","tf":3.583333333333333},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0030659172202350538}},"e":{"docs":{},"e":{"docs":{},"v":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0019474196689386564}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"b":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"b":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"5":{"0":{"0":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"：":{"docs":{},"桥":{"docs":{},"接":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"2":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}},"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":3.3501400560224086}},"\"":{"docs":{},",":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.014705882352941176}}}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}},"docs":{}}},"docs":{}}},"docs":{}},"。":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}},"是":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}},"：":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}},"已":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"校":{"docs":{},"对":{"docs":{},"完":{"docs":{},"成":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"[":{"4":{"0":{"docs":{},"]":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"docs":{}},"docs":{},"]":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"s":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}},")":{"docs":{},"，":{"docs":{},"那":{"docs":{},"我":{"docs":{},"们":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"结":{"docs":{},"果":{"docs":{},"将":{"docs":{},"是":{"docs":{},"：":{"docs":{},"{":{"docs":{},"a":{"docs":{},":":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"2":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},":":{"1":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}},"}":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"docs":{}}},"c":{"3":{"docs":{},"p":{"0":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"（":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"参":{"docs":{},"数":{"docs":{},"：":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"传":{"docs":{},"递":{"docs":{},"一":{"docs":{},"个":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.011695906432748537},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},"z":{"docs":{},"h":{"docs":{},"a":{"docs":{},"o":{"docs":{},"负":{"docs":{},"责":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"，":{"docs":{},"z":{"docs":{},"l":{"docs":{},"f":{"docs":{},"负":{"docs":{},"责":{"docs":{},"校":{"docs":{},"对":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"：":{"docs":{},"块":{"docs":{},"（":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789}},"，":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.01282051282051282},"core/Core.html":{"ref":"core/Core.html","tf":0.0023223409196470044}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.005202043660009289},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":5.0307262569832405},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":5.004752206381534},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":5.0661764705882355},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":5.008639308855291},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":5.012437810945274},"integration/MailClient.html":{"ref":"integration/MailClient.html","tf":5.333333333333333},"integration/STOMPClient&Server.html":{"ref":"integration/STOMPClient&Server.html","tf":2.7},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":5.00596421471173},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.007153806847215125},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"1":{"2":{"3":{"4":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"docs":{}},"docs":{}},"4":{"3":{"2":{"1":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"8":{"0":{"8":{"0":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00558659217877095}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"\"":{"docs":{},"/":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"/":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"8":{"0":{"8":{"0":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"\"":{"docs":{},"/":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"/":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},".":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"(":{"docs":{},"u":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"x":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"r":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"u":{"docs":{},"p":{"4":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"6":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"docs":{},"(":{"docs":{},"\"":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"i":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"a":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"a":{"docs":{},"a":{"docs":{},"a":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"c":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"x":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"p":{"docs":{},"t":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"1":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"0":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}}}}},"s":{"docs":{},"r":{"docs":{},"v":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"\"":{"1":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"8":{"0":{"8":{"0":{"docs":{},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}},"、":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"消":{"docs":{},"息":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"：":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"已":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"校":{"docs":{},"对":{"docs":{},"完":{"docs":{},"成":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.04838709677419355}}}}}}}}}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},"docs":{}}},"docs":{}}},"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}},"会":{"docs":{},"为":{"docs":{},"您":{"docs":{},"设":{"docs":{},"置":{"docs":{},"好":{"docs":{},"传":{"docs":{},"输":{"docs":{},"泵":{"docs":{},"以":{"docs":{},"平":{"docs":{},"滑":{"docs":{},"传":{"docs":{},"输":{"docs":{},"流":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"流":{"docs":{},"长":{"docs":{},"度":{"docs":{},"未":{"docs":{},"知":{"docs":{},"则":{"docs":{},"使":{"docs":{},"用":{"docs":{},"分":{"docs":{},"块":{"docs":{},"传":{"docs":{},"输":{"docs":{},"（":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"得":{"docs":{},"发":{"docs":{},"送":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}},"可":{"docs":{},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"与":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"并":{"docs":{},"未":{"docs":{},"提":{"docs":{},"供":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"的":{"docs":{},"回":{"docs":{},"顾":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"目":{"docs":{},"的":{"docs":{},"并":{"docs":{},"非":{"docs":{},"为":{"docs":{},"了":{"docs":{},"替":{"docs":{},"换":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"发":{"docs":{},"送":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"包":{"docs":{},"装":{"docs":{},"在":{"docs":{},"异":{"docs":{},"步":{"docs":{},"结":{"docs":{},"果":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"选":{"docs":{},"项":{"docs":{},"继":{"docs":{},"承":{"docs":{},"自":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}},"（":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"）":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}},"以":{"docs":{},"下":{"docs":{},"简":{"docs":{},"称":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"）":{"docs":{},"来":{"docs":{},"与":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"底":{"docs":{},"层":{"docs":{},"实":{"docs":{},"现":{"docs":{},"基":{"docs":{},"于":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}},"，":{"docs":{},"请":{"docs":{},"先":{"docs":{},"加":{"docs":{},"入":{"docs":{},"以":{"docs":{},"下":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"让":{"docs":{},"我":{"docs":{},"们":{"docs":{},"的":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}},"需":{"docs":{},"要":{"docs":{},"添":{"docs":{},"加":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"：":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}},"）":{"docs":{},"是":{"docs":{},"很":{"docs":{},"不":{"docs":{},"错":{"docs":{},"的":{"docs":{},"（":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"）":{"docs":{},"一":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"。":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"基":{"docs":{},"于":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"的":{"docs":{},"流":{"docs":{},"程":{"docs":{},"，":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"必":{"docs":{},"须":{"docs":{},"能":{"docs":{},"和":{"docs":{},"资":{"docs":{},"源":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"者":{"docs":{},"的":{"docs":{},"用":{"docs":{},"户":{"docs":{},"代":{"docs":{},"理":{"docs":{},"交":{"docs":{},"互":{"docs":{},"（":{"docs":{},"通":{"docs":{},"常":{"docs":{},"是":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"）":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"要":{"docs":{},"能":{"docs":{},"接":{"docs":{},"受":{"docs":{},"从":{"docs":{},"授":{"docs":{},"权":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"（":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0025549310168625446}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"转":{"docs":{},"换":{"docs":{},"的":{"docs":{},"类":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"描":{"docs":{},"述":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"界":{"docs":{},"面":{"docs":{},"的":{"docs":{},"模":{"docs":{},"型":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"也":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"解":{"docs":{},"析":{"docs":{},"器":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"解":{"docs":{},"析":{"docs":{},"器":{"docs":{},"可":{"docs":{},"支":{"docs":{},"持":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"语":{"docs":{},"法":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.011695906432748537},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.006423982869379015},"core/Core.html":{"ref":"core/Core.html","tf":0.0010218300046446818},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}},"\"":{"docs":{},":":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}}},"=":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"要":{"docs":{},"触":{"docs":{},"发":{"docs":{},"重":{"docs":{},"新":{"docs":{},"部":{"docs":{},"署":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"显":{"docs":{},"示":{"docs":{},"构":{"docs":{},"造":{"docs":{},"项":{"docs":{},"目":{"docs":{},"或":{"docs":{},"模":{"docs":{},"块":{"docs":{},"（":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"您":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"添":{"docs":{},"加":{"docs":{},"其":{"docs":{},"他":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"随":{"docs":{},"着":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"/":{"docs":{},"m":{"docs":{},"y":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},":":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"/":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"。":{"docs":{},"始":{"docs":{},"终":{"docs":{},"使":{"docs":{},"用":{"docs":{},"路":{"docs":{},"径":{"docs":{},"引":{"docs":{},"用":{"docs":{},"您":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"资":{"docs":{},"源":{"docs":{},"，":{"docs":{},"不":{"docs":{},"要":{"docs":{},"将":{"docs":{},"它":{"docs":{},"们":{"docs":{},"放":{"docs":{},"在":{"docs":{},"系":{"docs":{},"统":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"上":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"会":{"docs":{},"导":{"docs":{},"致":{"docs":{},"部":{"docs":{},"署":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"隔":{"docs":{},"离":{"docs":{},"问":{"docs":{},"题":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0009289363678588017},"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.01727447216890595},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.02053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.014705882352941176},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.023323615160349854},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.019704433497536946}},"）":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},":":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"通":{"docs":{},"过":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"。":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"选":{"docs":{},"择":{"docs":{},"使":{"docs":{},"用":{"docs":{},"其":{"docs":{},"中":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0010218300046446818},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"r":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"(":{"docs":{},")":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}},"u":{"docs":{},"d":{"docs":{"cloud/Cloud.html":{"ref":"cloud/Cloud.html","tf":10.5}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0013934045517882026},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":10.029411764705882},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.02495201535508637},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.022587268993839837},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.022058823529411766},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.026239067055393587},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.014778325123152709}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.009596928982725527},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.01026694045174538},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.022058823529411766},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.011661807580174927},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.009852216748768473}}}}}}},"开":{"docs":{},"关":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"若":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"h":{"docs":{},"a":{"docs":{},"就":{"docs":{},"假":{"docs":{},"定":{"docs":{},"是":{"docs":{},"集":{"docs":{},"群":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"此":{"docs":{},"选":{"docs":{},"项":{"docs":{},"确":{"docs":{},"定":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"是":{"docs":{},"否":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"与":{"docs":{},"网":{"docs":{},"络":{"docs":{},"上":{"docs":{},"的":{"docs":{},"其":{"docs":{},"他":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"形":{"docs":{},"成":{"docs":{},"集":{"docs":{},"群":{"docs":{},"，":{"docs":{},"集":{"docs":{},"群":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"允":{"docs":{},"许":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"与":{"docs":{},"其":{"docs":{},"他":{"docs":{},"节":{"docs":{},"点":{"docs":{},"形":{"docs":{},"成":{"docs":{},"分":{"docs":{},"布":{"docs":{},"式":{"docs":{},"e":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.01727447216890595}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"：":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"负":{"docs":{},"责":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"，":{"docs":{},"w":{"docs":{},"u":{"docs":{},"z":{"docs":{},"i":{"docs":{},"q":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"负":{"docs":{},"责":{"docs":{},"校":{"docs":{},"对":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}},"已":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"校":{"docs":{},"对":{"docs":{},"完":{"docs":{},"成":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.011695906432748537},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.013711151736745886},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"e":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0025549310168625446}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"，":{"docs":{},"也":{"docs":{},"很":{"docs":{},"接":{"docs":{},"近":{"docs":{},"于":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"（":{"docs":{},"或":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"o":{"docs":{},"s":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.008565310492505354},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},"e":{"docs":{},"(":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"：":{"docs":{},"当":{"docs":{},"前":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"l":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"1":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"f":{"1":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"1":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"1":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"1":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"：":{"docs":{},"并":{"docs":{},"发":{"docs":{},"合":{"docs":{},"并":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},".":{"docs":{},"a":{"docs":{},"c":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"中":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"a":{"docs":{},"c":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},".":{"docs":{},"*":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"；":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"包":{"docs":{},"含":{"docs":{},"通":{"docs":{},"配":{"docs":{},"符":{"docs":{},"的":{"docs":{},"可":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"某":{"docs":{},"个":{"docs":{},"包":{"docs":{},"或":{"docs":{},"子":{"docs":{},"包":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"=":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},".":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},".":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215}},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"条":{"docs":{},"目":{"docs":{},"来":{"docs":{},"配":{"docs":{},"置":{"docs":{},"默":{"docs":{},"认":{"docs":{},"命":{"docs":{},"令":{"docs":{},"。":{"docs":{},"若":{"docs":{},"在":{"docs":{},"没":{"docs":{},"有":{"docs":{},"命":{"docs":{},"令":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"启":{"docs":{},"动":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"s":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"o":{"docs":{},"n":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":5.00547195622435},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":5.016666666666667},"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},":":{"3":{"docs":{},".":{"2":{"docs":{},".":{"1":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}},"docs":{}}},"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"docs":{}}},"docs":{}}},"docs":{}},"/":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"/":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{"auth/Auth.html":{"ref":"auth/Auth.html","tf":0.041666666666666664}}}}}}}}}}}},"：":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"s":{"docs":{},"/":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"auth/Auth.html":{"ref":"auth/Auth.html","tf":0.041666666666666664}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"/":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}},"）":{"docs":{},"默":{"docs":{},"认":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"(":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},">":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.002136553646075244},"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}},")":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403}}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"'":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"'":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"(":{"docs":{},"(":{"docs":{},"v":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"v":{"2":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}},"docs":{}}}}}}}}}}}}}},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"（":{"docs":{},"根":{"docs":{},"据":{"docs":{},"配":{"docs":{},"置":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"e":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"）":{"docs":{},"，":{"docs":{},"之":{"docs":{},"后":{"docs":{},"此":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"，":{"docs":{},"它":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"到":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"并":{"docs":{},"且":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"运":{"docs":{},"都":{"docs":{},"会":{"docs":{},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"不":{"docs":{},"同":{"docs":{},"于":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"例":{"docs":{},"如":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"：":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"环":{"docs":{},"境":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"。":{"docs":{},"非":{"docs":{},"特":{"docs":{},"别":{"docs":{},"说":{"docs":{},"明":{"docs":{},"指":{"docs":{},"代":{"docs":{},"路":{"docs":{},"由":{"docs":{},"的":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"下":{"docs":{},"(":{"docs":{},"e":{"docs":{},"v":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}},"n":{"docs":{},"t":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413},"web/Web.html":{"ref":"web/Web.html","tf":0.0021908471275559884},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"它":{"docs":{},"将":{"docs":{},"在":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"发":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"状":{"docs":{},"态":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"持":{"docs":{},"续":{"docs":{},"响":{"docs":{},"应":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"在":{"docs":{},"发":{"docs":{},"送":{"docs":{},"剩":{"docs":{},"余":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"之":{"docs":{},"前":{"docs":{},"先":{"docs":{},"发":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"回":{"docs":{},"复":{"docs":{},"临":{"docs":{},"时":{"docs":{},"响":{"docs":{},"应":{"docs":{},"状":{"docs":{},"态":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"：":{"docs":{},"容":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"、":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635}},"i":{"docs":{},"g":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0027155465037338763},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.012254901960784314},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.009950248756218905},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.00927766732935719},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.005390835579514825},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"microservices/Config.html":{"ref":"microservices/Config.html","tf":5.045703839122487},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"u":{"docs":{},"r":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.007312614259597806}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.007352941176470588},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.005390835579514825},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}},"(":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.004638833664678595}}},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},".":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0066269052352551355}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},".":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"y":{"docs":{},"a":{"docs":{},"m":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211}}}}}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.007312614259597806}}}},"docs":{}}},"docs":{}}},"docs":{}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.008226691042047532}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"docs":{}}},"docs":{}}},"docs":{}},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.02010968921389397}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.008226691042047532}}},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"a":{"docs":{},"s":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.002742230347349177}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.002742230347349177}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.006398537477148081}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.01736745886654479}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.016453382084095063}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"周":{"docs":{},"期":{"docs":{},"性":{"docs":{},"的":{"docs":{},"去":{"docs":{},"检":{"docs":{},"查":{"docs":{},"变":{"docs":{},"更":{"docs":{},"并":{"docs":{},"更":{"docs":{},"新":{"docs":{},"本":{"docs":{},"地":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"已":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"校":{"docs":{},"对":{"docs":{},"完":{"docs":{},"成":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001207617278216442},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"(":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"r":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}},"g":{"docs":{},"o":{"docs":{},"a":{"docs":{},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"docs":{}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"g":{"docs":{},"o":{"docs":{},"a":{"docs":{},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"u":{"docs":{},"t":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}},"(":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"(":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"b":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}},"、":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"4":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"m":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"/":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"u":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.009940357852882704},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.006369426751592357},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},"a":{"docs":{},"r":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"1":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"docs":{}}}}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"s":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"s":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"s":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"v":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"e":{"docs":{},"k":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"b":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}},"：":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}},":":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"l":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0035769034236075624}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"docs":{}}},"docs":{}}},"docs":{}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"'":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"的":{"docs":{},"生":{"docs":{},"成":{"docs":{},"，":{"docs":{},"这":{"docs":{},"使":{"docs":{},"得":{"docs":{},"在":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"中":{"docs":{},"处":{"docs":{},"理":{"docs":{},"数":{"docs":{},"据":{"docs":{},"实":{"docs":{},"体":{"docs":{},"更":{"docs":{},"加":{"docs":{},"容":{"docs":{},"易":{"docs":{},"。":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{},"转":{"docs":{},"换":{"docs":{},"器":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"接":{"docs":{},"受":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403},"core/Core.html":{"ref":"core/Core.html","tf":10.001207617278217},"web/Web.html":{"ref":"web/Web.html","tf":0.0021908471275559884},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.006369426751592357},"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"/":{"docs":{},"/":{"docs":{},"新":{"docs":{},"增":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}},"的":{"docs":{},"依":{"docs":{},"赖":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"，":{"docs":{},"如":{"docs":{},"您":{"docs":{},"对":{"docs":{},"此":{"docs":{},"还":{"docs":{},"不":{"docs":{},"熟":{"docs":{},"悉":{"docs":{},"，":{"docs":{},"请":{"docs":{},"先":{"docs":{},"熟":{"docs":{},"悉":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}},"、":{"docs":{},"您":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"和":{"docs":{},"所":{"docs":{},"有":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"项":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"很":{"docs":{},"酷":{"docs":{},"的":{"docs":{},"是":{"docs":{},"：":{"docs":{},"我":{"docs":{},"们":{"docs":{},"并":{"docs":{},"不":{"docs":{},"强":{"docs":{},"迫":{"docs":{},"您":{"docs":{},"在":{"docs":{},"书":{"docs":{},"写":{"docs":{},"诸":{"docs":{},"如":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"的":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"功":{"docs":{},"能":{"docs":{},"相":{"docs":{},"当":{"docs":{},"底":{"docs":{},"层":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"主":{"docs":{},"题":{"docs":{},"，":{"docs":{},"该":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"也":{"docs":{},"可":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"以":{"docs":{},"提":{"docs":{},"供":{"docs":{},"资":{"docs":{},"源":{"docs":{},"或":{"docs":{},"处":{"docs":{},"理":{"docs":{},"文":{"docs":{},"件":{"docs":{},"上":{"docs":{},"传":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"于":{"docs":{},"解":{"docs":{},"析":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"程":{"docs":{},"序":{"docs":{},"的":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"参":{"docs":{},"数":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"打":{"docs":{},"包":{"docs":{},"成":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"，":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"更":{"docs":{},"丰":{"docs":{},"富":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"以":{"docs":{},"便":{"docs":{},"更":{"docs":{},"容":{"docs":{},"易":{"docs":{},"地":{"docs":{},"开":{"docs":{},"发":{"docs":{},"实":{"docs":{},"际":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}},"：":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"已":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"校":{"docs":{},"对":{"docs":{},"完":{"docs":{},"成":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"（":{"docs":{},"跨":{"docs":{},"域":{"docs":{},"资":{"docs":{},"源":{"docs":{},"共":{"docs":{},"享":{"docs":{},"）":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{},"。":{"docs":{},"f":{"docs":{},"i":{"docs":{},"b":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.002136553646075244},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.011570247933884297}},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"：":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"编":{"docs":{},"解":{"docs":{},"码":{"docs":{},"器":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}},"编":{"docs":{},"解":{"docs":{},"码":{"docs":{},"器":{"docs":{},"（":{"docs":{},"编":{"docs":{},"码":{"docs":{},"及":{"docs":{},"解":{"docs":{},"码":{"docs":{},"工":{"docs":{},"具":{"docs":{},"）":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}},"\"":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.012104283054003724}}},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"_":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"授":{"docs":{},"权":{"docs":{},"码":{"docs":{},"流":{"docs":{},"程":{"docs":{},"（":{"docs":{},"对":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"和":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"可":{"docs":{},"持":{"docs":{},"久":{"docs":{},"化":{"docs":{},"存":{"docs":{},"储":{"docs":{},"信":{"docs":{},"息":{"docs":{},"）":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"docs":{}}},"docs":{}}},"docs":{}},"也":{"docs":{},"提":{"docs":{},"供":{"docs":{},"数":{"docs":{},"据":{"docs":{},"对":{"docs":{},"象":{"docs":{},"转":{"docs":{},"换":{"docs":{},"器":{"docs":{},"（":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"：":{"docs":{},"集":{"docs":{},"合":{"docs":{},"，":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"专":{"docs":{},"用":{"docs":{},"（":{"docs":{},"概":{"docs":{},"念":{"docs":{},"稍":{"docs":{},"同":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"的":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"）":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}}}}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"d":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"：":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"会":{"docs":{},"为":{"docs":{},"每":{"docs":{},"个":{"docs":{},"用":{"docs":{},"户":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"“":{"docs":{},"值":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"存":{"docs":{},"储":{"docs":{},"在":{"docs":{},"用":{"docs":{},"户":{"docs":{},"表":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"列":{"docs":{},"中":{"docs":{},"；":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.006085686465433301}},"e":{"docs":{},"头":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"(":{"5":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"docs":{}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}},"可":{"docs":{},"参":{"docs":{},"考":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"会":{"docs":{},"在":{"docs":{},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{},"里":{"docs":{},"包":{"docs":{},"含":{"docs":{},"这":{"docs":{},"个":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"基":{"docs":{},"于":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"回":{"docs":{},"写":{"docs":{},"到":{"docs":{},"响":{"docs":{},"应":{"docs":{},"里":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"因":{"docs":{},"此":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"特":{"docs":{},"指":{"docs":{},"有":{"docs":{},"效":{"docs":{},"期":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001114723641430562},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"y":{"docs":{},"、":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"、":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"、":{"docs":{},"c":{"docs":{},"h":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.011695906432748537},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"i":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}},"y":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.01652892561983471}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.013223140495867768}}}},"：":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"证":{"docs":{},"书":{"docs":{},"流":{"docs":{},"程":{"docs":{},"（":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"可":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"可":{"docs":{},"凭":{"docs":{},"借":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"整":{"docs":{},"数":{"docs":{},"申":{"docs":{},"请":{"docs":{},"访":{"docs":{},"问":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"【":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"密":{"docs":{},"码":{"docs":{},"证":{"docs":{},"书":{"docs":{},"流":{"docs":{},"程":{"docs":{},"（":{"docs":{},"之":{"docs":{},"前":{"docs":{},"的":{"docs":{},"流":{"docs":{},"程":{"docs":{},"无":{"docs":{},"法":{"docs":{},"使":{"docs":{},"用":{"docs":{},"或":{"docs":{},"开":{"docs":{},"发":{"docs":{},"阶":{"docs":{},"段":{"docs":{},"使":{"docs":{},"用":{"docs":{},"）":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"证":{"docs":{},"书":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.006839945280437756},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.006611570247933884}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.009917355371900827}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677},"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"f":{"docs":{},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"c":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228}}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"u":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"s":{"docs":{},"e":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{"eventbusbridge/CamelBridge.html":{"ref":"eventbusbridge/CamelBridge.html","tf":5.333333333333333}}}}},"r":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"g":{"docs":{"cloud/OpenShiftCartridge.html":{"ref":"cloud/OpenShiftCartridge.html","tf":5.333333333333333},"cloud/OpenShiftUsingDIYCartridge.html":{"ref":"cloud/OpenShiftUsingDIYCartridge.html","tf":2.7}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}},"i":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"t":{"6":{"3":{"docs":{},"负":{"docs":{},"责":{"docs":{},"翻":{"docs":{},"译":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}},"docs":{}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"i":{"docs":{},"p":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"r":{"docs":{},"c":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":3.3585434173669464},"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.01680672268907563}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"i":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.014705882352941176}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"5":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"2":{"0":{"0":{"0":{"docs":{},")":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.008403361344537815}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.008746355685131196}},"u":{"docs":{},"核":{"docs":{},"数":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"标":{"docs":{},"示":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"每":{"docs":{},"次":{"docs":{},"当":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"帧":{"docs":{},"数":{"docs":{},"据":{"docs":{},"到":{"docs":{},"达":{"docs":{},"时":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"这":{"docs":{},"而":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"帧":{"docs":{},"到":{"docs":{},"达":{"docs":{},"时":{"docs":{},"就":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"它":{"docs":{},"。":{"docs":{},"以":{"docs":{},"下":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"?":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"v":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.008086253369272238}}},"a":{"docs":{},"t":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635}}}}}},"s":{"docs":{},"r":{"docs":{},"f":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"(":{"4":{"0":{"1":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"docs":{}},"docs":{}},"docs":{}}}}}},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"m":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"2":{"docs":{},"}":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"如":{"docs":{},"果":{"docs":{},"我":{"docs":{},"们":{"docs":{},"将":{"docs":{},"配":{"docs":{},"置":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"颠":{"docs":{},"倒":{"docs":{},"为":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}},"docs":{}},"f":{"docs":{},"g":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}},"d":{"docs":{},"e":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"v":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}},"o":{"docs":{},"p":{"docs":{"devops/Devops.html":{"ref":"devops/Devops.html","tf":10.5}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"e":{"docs":{},"d":{"docs":{},"）":{"docs":{},"。":{"docs":{},"稍":{"docs":{},"后":{"docs":{},"，":{"docs":{},"您":{"docs":{},"完":{"docs":{},"成":{"docs":{},"了":{"docs":{},"所":{"docs":{},"有":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"做":{"docs":{},"的":{"docs":{},"事":{"docs":{},"（":{"docs":{},"如":{"docs":{},"：":{"docs":{},"启":{"docs":{},"动":{"docs":{},"其":{"docs":{},"他":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"）":{"docs":{},"，":{"docs":{},"您":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"1":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"6":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}},"docs":{}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"=":{"1":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.011029411764705883},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.008746355685131196},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.014778325123152709}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}},"_":{"docs":{},"d":{"docs":{},"b":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"环":{"docs":{},"境":{"docs":{},"变":{"docs":{},"量":{"docs":{},"中":{"docs":{},"有":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},")":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"y":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"d":{"docs":{},"：":{"docs":{},"销":{"docs":{},"毁":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"n":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"c":{"docs":{"./":{"ref":"./","tf":0.038461538461538464}},":":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725}},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.006788866259334691},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}},"：":{"docs":{},"文":{"docs":{},"档":{"docs":{},"，":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"专":{"docs":{},"用":{"docs":{},"（":{"docs":{},"概":{"docs":{},"念":{"docs":{},"稍":{"docs":{},"同":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"中":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"）":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0025549310168625446},"devops/Docker.html":{"ref":"devops/Docker.html","tf":10.5},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"e":{"1":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}},"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.00728959575878065},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0030659172202350538}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406}}}}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.004638833664678595}}}}}}}}}}}}},"’":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"t":{"docs":{},"'":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.004598875830352581}}}}},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}},"w":{"docs":{},"n":{"docs":{},"：":{"docs":{},"服":{"docs":{},"务":{"docs":{},"不":{"docs":{},"再":{"docs":{},"可":{"docs":{},"用":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"4":{"docs":{},"j":{"2":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}},"i":{"docs":{},"r":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"=":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":3.340487140180548},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"(":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}},"(":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0025549310168625446}}}}},"r":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}},"s":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"r":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0025549310168625446}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"1":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"2":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"docs":{}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"1":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.004087889626980072}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"docs":{}}},"docs":{}}},"docs":{}},"中":{"docs":{},"搜":{"docs":{},"索":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"每":{"docs":{},"次":{"docs":{},"搜":{"docs":{},"索":{"docs":{},"得":{"docs":{},"到":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"是":{"0":{"docs":{},".":{"docs":{},".":{"docs":{},"n":{"docs":{},"条":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"）":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"些":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"可":{"docs":{},"以":{"docs":{},"获":{"docs":{},"得":{"docs":{},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{},"（":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"）":{"docs":{},"。":{"docs":{},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"作":{"docs":{},"用":{"docs":{},"是":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"服":{"docs":{},"务":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"可":{"docs":{},"以":{"docs":{},"得":{"docs":{},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"来":{"docs":{},"使":{"docs":{},"用":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{},"释":{"docs":{},"放":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"：":{"docs":{},"已":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"校":{"docs":{},"对":{"docs":{},"完":{"docs":{},"成":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}}}}},"y":{"docs":{"cloud/OpenShiftUsingDIYCartridge.html":{"ref":"cloud/OpenShiftUsingDIYCartridge.html","tf":2.7}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{},"）":{"docs":{},"。":{"docs":{},"若":{"docs":{},"您":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"data/Data.html":{"ref":"data/Data.html","tf":5.333333333333333},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.004598875830352581},"PLAN.html":{"ref":"PLAN.html","tf":0.016129032258064516}},"\"":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"(":{"docs":{},")":{"docs":{},"：":{"docs":{},"保":{"docs":{},"存":{"docs":{},"接":{"docs":{},"收":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"a":{"docs":{},"s":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0013934045517882026}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"本":{"docs":{},"地":{"docs":{},"地":{"docs":{},"址":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"：":{"docs":{},"数":{"docs":{},"据":{"docs":{},"报":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"）":{"docs":{},"包":{"docs":{},"含":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"安":{"docs":{},"全":{"docs":{},"地":{"docs":{},"在":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"部":{"docs":{},"分":{"docs":{},"之":{"docs":{},"间":{"docs":{},"、":{"docs":{},"同":{"docs":{},"一":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"能":{"docs":{},"够":{"docs":{},"避":{"docs":{},"免":{"docs":{},"把":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"加":{"docs":{},"载":{"docs":{},"到":{"docs":{},"内":{"docs":{},"存":{"docs":{},"中":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"得":{"docs":{},"到":{"docs":{},"的":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"保":{"docs":{},"存":{"docs":{},"接":{"docs":{},"收":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}}},":":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}},"o":{"docs":{},"b":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407}},"，":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},",":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}},"s":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}},"c":{"1":{"9":{"8":{"9":{"docs":{},"负":{"docs":{},"责":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"，":{"docs":{},"k":{"docs":{},"k":{"docs":{},"k":{"docs":{},"o":{"docs":{},"k":{"docs":{},"o":{"docs":{},"校":{"docs":{},"对":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"a":{"docs":{},"w":{"docs":{},"t":{"docs":{},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"v":{"4":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228}},"e":{"docs":{},"）":{"docs":{},"。":{"docs":{},"有":{"docs":{},"关":{"docs":{},"这":{"docs":{},"方":{"docs":{},"面":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"细":{"docs":{},"节":{"docs":{},"可":{"docs":{},"在":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"j":{"docs":{},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"w":{"docs":{},"i":{"docs":{},"k":{"docs":{},"i":{"docs":{},"/":{"docs":{},"i":{"docs":{},"p":{"docs":{},"v":{"6":{"docs":{},"。":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"=":{"1":{"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"1":{"docs":{},".":{"2":{"0":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"=":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0013934045517882026}}}}}}}},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"，":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"查":{"docs":{},"询":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"列":{"docs":{},"表":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.016172506738544475}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"：":{"docs":{},"若":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"被":{"docs":{},"认":{"docs":{},"为":{"docs":{},"不":{"docs":{},"再":{"docs":{},"满":{"docs":{},"，":{"docs":{},"则":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"将":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"1":{"2":{"3":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}},"docs":{}},"docs":{}},"docs":{}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"b":{"docs":{},"o":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"devops/MetricsUsingDropwizard.html":{"ref":"devops/MetricsUsingDropwizard.html","tf":3.583333333333333}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"=":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"=":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"i":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"j":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"完":{"docs":{},"全":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"高":{"docs":{},"速":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"设":{"docs":{},"置":{"docs":{},"不":{"docs":{},"是":{"docs":{},"没":{"docs":{},"有":{"docs":{},"后":{"docs":{},"果":{"docs":{},"的":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"将":{"docs":{},"无":{"docs":{},"法":{"docs":{},"从":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{},"任":{"docs":{},"何":{"docs":{},"文":{"docs":{},"件":{"docs":{},"（":{"docs":{},"仅":{"docs":{},"从":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"）":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"此":{"docs":{},"设":{"docs":{},"置":{"docs":{},"时":{"docs":{},"要":{"docs":{},"非":{"docs":{},"常":{"docs":{},"小":{"docs":{},"心":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"=":{"docs":{},".":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"/":{"docs":{},"m":{"docs":{},"i":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{},"m":{"docs":{},"y":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"/":{"docs":{},"m":{"docs":{},"i":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"=":{"docs":{},".":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"/":{"docs":{},"m":{"docs":{},"i":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"/":{"docs":{},"m":{"docs":{},"i":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"z":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"=":{"docs":{},".":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"/":{"docs":{},"m":{"docs":{},"i":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{},"m":{"docs":{},"y":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"/":{"docs":{},"m":{"docs":{},"i":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.056074766355140186}},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}},"、":{"docs":{},"建":{"docs":{},"立":{"docs":{},"连":{"docs":{},"接":{"docs":{},"、":{"docs":{},"断":{"docs":{},"开":{"docs":{},"连":{"docs":{},"接":{"docs":{},"、":{"docs":{},"授":{"docs":{},"权":{"docs":{},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{},"命":{"docs":{},"令":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"提":{"docs":{},"供":{"docs":{},"授":{"docs":{},"权":{"docs":{},"的":{"docs":{},"密":{"docs":{},"码":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"(":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}},":":{"1":{"docs":{},",":{"2":{"docs":{},":":{"docs":{},":":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}},"docs":{}}},"docs":{}},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"h":{"docs":{},":":{"docs":{},"m":{"docs":{},"m":{"docs":{},":":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"s":{"docs":{},"s":{"docs":{},"）":{"docs":{},"格":{"docs":{},"式":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"。":{"docs":{},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"=":{"docs":{},"s":{"docs":{},"l":{"docs":{},"f":{"4":{"docs":{},"j":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"1":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"2":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{"./":{"ref":"./","tf":0.01282051282051282}},"i":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.01282051282051282},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.007312614259597806}},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.0641025641025641}}}}}},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{"./":{"ref":"./","tf":0.02564102564102564},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"docs":{}}},"docs":{}}},"docs":{}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},":":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}},"i":{"docs":{},"d":{"docs":{},"，":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{},"在":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"中":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"，":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"组":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"可":{"docs":{},"以":{"docs":{},"消":{"docs":{},"费":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"中":{"docs":{},"（":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"实":{"docs":{},"例":{"docs":{},"时":{"docs":{},"通":{"docs":{},"过":{"docs":{},"配":{"docs":{},"置":{"docs":{},"指":{"docs":{},"定":{"docs":{},"）":{"docs":{},"。":{"docs":{},"当":{"docs":{},"然":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"通":{"docs":{},"过":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"消":{"docs":{},"费":{"docs":{},"组":{"docs":{},"（":{"docs":{},"k":{"docs":{},"a":{"docs":{},"f":{"docs":{},"k":{"docs":{},"a":{"docs":{},"中":{"docs":{},"的":{"docs":{},"设":{"docs":{},"计":{"docs":{},"）":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"v":{"docs":{},"y":{"docs":{},":":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"y":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"i":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"d":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.004975124378109453},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.007312614259597806},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"e":{"docs":{},"（":{"docs":{},"您":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"两":{"docs":{},"种":{"docs":{},"常":{"docs":{},"用":{"docs":{},"的":{"docs":{},"项":{"docs":{},"目":{"docs":{},"构":{"docs":{},"建":{"docs":{},"工":{"docs":{},"具":{"docs":{},"）":{"docs":{},"，":{"docs":{},"将":{"docs":{},"以":{"docs":{},"下":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"项":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"您":{"docs":{},"的":{"docs":{},"项":{"docs":{},"目":{"docs":{},"描":{"docs":{},"述":{"docs":{},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036}},"您":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"文":{"docs":{},"件":{"docs":{},"中":{"docs":{},"）":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"在":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},"你":{"docs":{},"的":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"文":{"docs":{},"件":{"docs":{},"里":{"docs":{},")":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}},"中":{"docs":{},")":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"文":{"docs":{},"件":{"docs":{},"里":{"docs":{},")":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{},")":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635}}}}}}}}}}}}}},"中":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"进":{"docs":{},"行":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"o":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}},"a":{"docs":{},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}}}}}},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"c":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}},"c":{"docs":{},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"x":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"：":{"docs":{},"按":{"docs":{},"照":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"方":{"docs":{},"法":{"docs":{},"会":{"docs":{},"创":{"docs":{},"建":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0063025210084033615}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"时":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"、":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"d":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"x":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"x":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}},"、":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"、":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"/":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"/":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"y":{"docs":{},"a":{"docs":{},"s":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"；":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"知":{"docs":{},"道":{"docs":{},"它":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"；":{"docs":{},"否":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}}}}},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"o":{"docs":{},"w":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.002793296089385475}}}}}}}},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"，":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"以":{"docs":{},"及":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"请":{"docs":{},"求":{"docs":{},"没":{"docs":{},"有":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"，":{"docs":{},"可":{"docs":{},"用":{"docs":{},"以":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"发":{"docs":{},"送":{"docs":{},"无":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"的":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"方":{"docs":{},"法":{"docs":{},"获":{"docs":{},"得":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"主":{"docs":{},"键":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.008086253369272238}},"p":{"docs":{},"a":{"docs":{},"i":{"docs":{},"r":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.008086253369272238}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.008086253369272238}}}}}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"/":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}},"u":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}},"l":{"docs":{},"o":{"docs":{},"b":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{},"挑":{"docs":{},"选":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"全":{"docs":{},"局":{"docs":{},"地":{"docs":{},"址":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"不":{"docs":{},"能":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"负":{"docs":{},"责":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"，":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"z":{"docs":{},"h":{"docs":{},"a":{"docs":{},"o":{"docs":{},"校":{"docs":{},"对":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}}}}}}}}}},"h":{"2":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"之":{"docs":{},"上":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"（":{"docs":{},"未":{"docs":{},"加":{"docs":{},"密":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"/":{"2":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"）":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"可":{"docs":{},"能":{"docs":{},"不":{"docs":{},"受":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"docs":{}}}}}}}}}},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"在":{"docs":{},"建":{"docs":{},"站":{"docs":{},"时":{"docs":{},"，":{"docs":{},"您":{"docs":{},"应":{"docs":{},"该":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"和":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"t":{"docs":{},"t":{"docs":{},"p":{"2":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"(":{"1":{"0":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0070599163957268925},"web/Web.html":{"ref":"web/Web.html","tf":0.008276533592989289},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.004655493482309125},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.017045454545454544},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.009554140127388535},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.006642820643842616},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.005484460694698354},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"services/HTTPServiceFactory.html":{"ref":"services/HTTPServiceFactory.html","tf":3.583333333333333}},"s":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"j":{"docs":{},"s":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"e":{"docs":{},"n":{"docs":{},"/":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"/":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"w":{"docs":{},"i":{"docs":{},"k":{"docs":{},"i":{"docs":{},"/":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"您":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"至":{"docs":{},"此":{"docs":{},"，":{"docs":{},"您":{"docs":{},"完":{"docs":{},"成":{"docs":{},"所":{"docs":{},"有":{"docs":{},"必":{"docs":{},"须":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"8":{"4":{"4":{"7":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"。":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"端":{"docs":{},"口":{"docs":{},"号":{"docs":{},"可":{"docs":{},"以":{"docs":{},"不":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"(":{"1":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0015791918253599629},"web/Web.html":{"ref":"web/Web.html","tf":0.0034079844206426485}},"e":{"docs":{},"，":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"还":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"各":{"docs":{},"种":{"docs":{},"用":{"docs":{},"于":{"docs":{},"简":{"docs":{},"化":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},":":{"8":{"0":{"8":{"0":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"1":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"s":{"docs":{},"l":{"docs":{},"f":{"4":{"docs":{},"j":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"#":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"d":{"docs":{},"n":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"r":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"/":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"j":{"docs":{},"s":{"docs":{},"/":{"0":{"docs":{},".":{"3":{"docs":{},".":{"4":{"docs":{},"/":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"j":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"auth/Auth.html":{"ref":"auth/Auth.html","tf":0.041666666666666664}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677},"core/Core.html":{"ref":"core/Core.html","tf":0.0017649790989317231},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.002793296089385475},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.003693444136657433},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0025549310168625446}},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"i":{"docs":{},"b":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0009289363678588017},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"e":{"docs":{},"，":{"docs":{},"并":{"docs":{},"返":{"docs":{},"回":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}},"，":{"docs":{},"可":{"docs":{},"用":{"docs":{},"以":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"复":{"docs":{},"用":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}},"而":{"docs":{},"是":{"docs":{},"基":{"docs":{},"于":{"docs":{},"该":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"，":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"并":{"docs":{},"保":{"docs":{},"留":{"docs":{},"其":{"docs":{},"便":{"docs":{},"利":{"docs":{},"的":{"docs":{},"设":{"docs":{},"置":{"docs":{},"和":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"请":{"docs":{},"求":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"（":{"docs":{},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"，":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"/":{"2":{"docs":{},"的":{"docs":{},"支":{"docs":{},"持":{"docs":{},"，":{"docs":{},"流":{"docs":{},"水":{"docs":{},"线":{"docs":{},"／":{"docs":{},"管":{"docs":{},"线":{"docs":{},"的":{"docs":{},"支":{"docs":{},"持":{"docs":{},"等":{"docs":{},"。":{"docs":{},"当":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"对":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}}}}}}}}},"/":{"1":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},".":{"0":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"、":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"/":{"1":{"docs":{},".":{"1":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}}},"docs":{}}}}}}}},"1":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"升":{"docs":{},"级":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215}},"，":{"docs":{},"但":{"docs":{},"可":{"docs":{},"以":{"docs":{},"连":{"docs":{},"接":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"2":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.004273107292150488},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"规":{"docs":{},"范":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"，":{"docs":{},"当":{"docs":{},"响":{"docs":{},"应":{"docs":{},"到":{"docs":{},"达":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}},"_":{"2":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"请":{"docs":{},"求":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"方":{"docs":{},"法":{"docs":{},"用":{"docs":{},"于":{"docs":{},"非":{"docs":{},"标":{"docs":{},"准":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"当":{"docs":{},"使":{"docs":{},"用":{"docs":{},"此":{"docs":{},"方":{"docs":{},"法":{"docs":{},"时":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"通":{"docs":{},"常":{"docs":{},"包":{"docs":{},"含":{"docs":{},"我":{"docs":{},"们":{"docs":{},"需":{"docs":{},"要":{"docs":{},"读":{"docs":{},"取":{"docs":{},"的":{"docs":{},"主":{"docs":{},"体":{"docs":{},"。":{"docs":{},"如":{"docs":{},"前":{"docs":{},"所":{"docs":{},"述":{"docs":{},"，":{"docs":{},"当":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"部":{"docs":{},"达":{"docs":{},"到":{"docs":{},"时":{"docs":{},"，":{"docs":{},"请":{"docs":{},"求":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"请":{"docs":{},"求":{"docs":{},"对":{"docs":{},"象":{"docs":{},"在":{"docs":{},"此":{"docs":{},"时":{"docs":{},"没":{"docs":{},"有":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"基":{"docs":{},"本":{"docs":{},"认":{"docs":{},"证":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"础":{"docs":{},"认":{"docs":{},"证":{"docs":{},"是":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"简":{"docs":{},"单":{"docs":{},"应":{"docs":{},"用":{"docs":{},"的":{"docs":{},"简":{"docs":{},"单":{"docs":{},"认":{"docs":{},"证":{"docs":{},"手":{"docs":{},"段":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"应":{"docs":{},"用":{"docs":{},"来":{"docs":{},"是":{"docs":{},"足":{"docs":{},"够":{"docs":{},"的":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.0074487895716946}}}}}}},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.010242085661080074}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"请":{"docs":{},"求":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"(":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"\\":{"docs":{},"\"":{"docs":{},")":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"?":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}},"!":{"docs":{},"!":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}},"a":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.0037243947858473}}}},"s":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"u":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}},"、":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"、":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},":":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"允":{"docs":{},"许":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"键":{"docs":{},"包":{"docs":{},"含":{"docs":{},"多":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"：":{"docs":{},"请":{"docs":{},"求":{"docs":{},"/":{"docs":{},"响":{"docs":{},"应":{"docs":{},"头":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"b":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"m":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}},"t":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"u":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001114723641430562}},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"r":{"1":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}},"2":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}},"3":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}},"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.008565310492505354},"core/Core.html":{"ref":"core/Core.html","tf":0.0013005109150023223},"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.004638833664678595},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.028662420382165606},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}},"，":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}},"因":{"docs":{},"此":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"它":{"docs":{},"直":{"docs":{},"接":{"docs":{},"作":{"docs":{},"为":{"docs":{},"回":{"docs":{},"调":{"docs":{},"的":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}},"以":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"为":{"docs":{},"单":{"docs":{},"位":{"docs":{},"计":{"docs":{},"时":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"当":{"docs":{},"操":{"docs":{},"作":{"docs":{},"完":{"docs":{},"成":{"docs":{},"或":{"docs":{},"发":{"docs":{},"生":{"docs":{},"错":{"docs":{},"误":{"docs":{},"时":{"docs":{},"调":{"docs":{},"用":{"docs":{},"该":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"j":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0058823529411764705}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"：":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"/":{"docs":{},"处":{"docs":{},"理":{"docs":{},"，":{"docs":{},"有":{"docs":{},"些":{"docs":{},"特":{"docs":{},"定":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"未":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"，":{"docs":{},"如":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"等":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"结":{"docs":{},"果":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"从":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"读":{"docs":{},"取":{"docs":{},"项":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},"，":{"docs":{},"某":{"docs":{},"些":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"地":{"docs":{},"方":{"docs":{},"未":{"docs":{},"翻":{"docs":{},"译":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"（":{"docs":{},"事":{"docs":{},"件":{"docs":{},"）":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"t":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},">":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.006463527239150508},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.011764705882352941}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},">":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"关":{"docs":{},"于":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}},"）":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243}},"s":{"docs":{},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},":":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"k":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}},"s":{"docs":{},"h":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.01511879049676026},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.02425876010781671}},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"<":{"docs":{},">":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.00728959575878065}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"<":{"docs":{},">":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}},"开":{"docs":{},"关":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"：":{"docs":{},"该":{"docs":{},"参":{"docs":{},"数":{"docs":{},"需":{"docs":{},"要":{"docs":{},"和":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":10.065259117082533}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211}},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{},"/":{"docs":{},"/":{"docs":{},"创":{"docs":{},"建":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"对":{"docs":{},"象":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}},"（":{"docs":{},"默":{"docs":{},"认":{"docs":{},"实":{"docs":{},"现":{"docs":{},"）":{"docs":{"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353}}}}}}}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"\"":{"docs":{},")":{"docs":{},"{":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"'":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}},"docs":{}}},"docs":{}}},"docs":{},"$":{"docs":{},"{":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"}":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317}}}}}},"支":{"docs":{},"持":{"docs":{},"多":{"docs":{},"种":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"传":{"docs":{},"输":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"组":{"docs":{},"播":{"docs":{},"和":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"配":{"docs":{},"置":{"docs":{},"中":{"docs":{},"采":{"docs":{},"用":{"docs":{},"组":{"docs":{},"播":{"docs":{},"传":{"docs":{},"输":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"您":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"网":{"docs":{},"络":{"docs":{},"上":{"docs":{},"启":{"docs":{},"用":{"docs":{},"组":{"docs":{},"播":{"docs":{},"才":{"docs":{},"能":{"docs":{},"使":{"docs":{},"其":{"docs":{},"工":{"docs":{},"作":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"做":{"docs":{},"以":{"docs":{},"下":{"docs":{},"工":{"docs":{},"作":{"docs":{},"：":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}},"一":{"docs":{},"起":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"它":{"docs":{},"指":{"docs":{},"定":{"docs":{},"此":{"docs":{},"节":{"docs":{},"点":{"docs":{},"将":{"docs":{},"加":{"docs":{},"入":{"docs":{},"的":{"docs":{},"h":{"docs":{},"a":{"docs":{},"组":{"docs":{},"。":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"可":{"docs":{},"以":{"docs":{},"有":{"docs":{},"多":{"docs":{},"个":{"docs":{},"h":{"docs":{},"a":{"docs":{},"组":{"docs":{},"，":{"docs":{},"节":{"docs":{},"点":{"docs":{},"只":{"docs":{},"会":{"docs":{},"故":{"docs":{},"障":{"docs":{},"转":{"docs":{},"移":{"docs":{},"到":{"docs":{},"同":{"docs":{},"一":{"docs":{},"组":{"docs":{},"中":{"docs":{},"的":{"docs":{},"其":{"docs":{},"他":{"docs":{},"节":{"docs":{},"点":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{},"_":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"_":{"docs":{},"_":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"所":{"docs":{},"有":{"docs":{},"h":{"docs":{},"a":{"docs":{},"部":{"docs":{},"署":{"docs":{},"i":{"docs":{},"d":{"docs":{},"处":{"docs":{},"于":{"docs":{},"活":{"docs":{},"动":{"docs":{},"状":{"docs":{},"态":{"docs":{},"的":{"docs":{},"最":{"docs":{},"小":{"docs":{},"节":{"docs":{},"点":{"docs":{},"数":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"0":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"到":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"开":{"docs":{},"关":{"docs":{},"时":{"docs":{},"，":{"docs":{},"您":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"提":{"docs":{},"供":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"组":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"：":{"docs":{},"若":{"docs":{},"指":{"docs":{},"定":{"docs":{},"，":{"docs":{},"该":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"将":{"docs":{},"部":{"docs":{},"署":{"docs":{},"为":{"docs":{},"（":{"docs":{},"支":{"docs":{},"持":{"docs":{},"）":{"docs":{},"高":{"docs":{},"可":{"docs":{},"用":{"docs":{},"性":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"）":{"docs":{},"。":{"docs":{},"有":{"docs":{},"关":{"docs":{},"详":{"docs":{},"细":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{},"相":{"docs":{},"关":{"docs":{},"章":{"docs":{},"节":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"devops/MetricsUsingHawkular.html":{"ref":"devops/MetricsUsingHawkular.html","tf":3.583333333333333}}}}}}}},"l":{"docs":{},"f":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}},"（":{"docs":{},"高":{"docs":{},"可":{"docs":{},"用":{"docs":{},"或":{"docs":{},"故":{"docs":{},"障":{"docs":{},"转":{"docs":{},"移":{"docs":{},"）":{"docs":{},"时":{"docs":{},"，":{"docs":{},"请":{"docs":{},"不":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"k":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},",":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},"：":{"docs":{},"跳":{"docs":{},"数":{"docs":{},"（":{"docs":{},"一":{"docs":{},"台":{"docs":{},"路":{"docs":{},"由":{"docs":{},"器":{"docs":{},"/":{"docs":{},"主":{"docs":{},"机":{"docs":{},"到":{"docs":{},"另":{"docs":{},"外":{"docs":{},"一":{"docs":{},"台":{"docs":{},"路":{"docs":{},"由":{"docs":{},"器":{"docs":{},"/":{"docs":{},"主":{"docs":{},"机":{"docs":{},"所":{"docs":{},"经":{"docs":{},"过":{"docs":{},"的":{"docs":{},"路":{"docs":{},"由":{"docs":{},"器":{"docs":{},"的":{"docs":{},"数":{"docs":{},"量":{"docs":{},"，":{"docs":{},"经":{"docs":{},"过":{"docs":{},"路":{"docs":{},"由":{"docs":{},"转":{"docs":{},"发":{"docs":{},"次":{"docs":{},"数":{"docs":{},"越":{"docs":{},"多":{"docs":{},"，":{"docs":{},"跳":{"docs":{},"数":{"docs":{},"越":{"docs":{},"大":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0033944331296673455},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"和":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"：":{"docs":{},"若":{"docs":{},"指":{"docs":{},"定":{"docs":{},"了":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"选":{"docs":{},"项":{"docs":{},"，":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"确":{"docs":{},"定":{"docs":{},"哪":{"docs":{},"个":{"docs":{},"主":{"docs":{},"机":{"docs":{},"地":{"docs":{},"址":{"docs":{},"将":{"docs":{},"用":{"docs":{},"于":{"docs":{},"其":{"docs":{},"他":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"进":{"docs":{},"行":{"docs":{},"集":{"docs":{},"群":{"docs":{},"通":{"docs":{},"信":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"从":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"中":{"docs":{},"选":{"docs":{},"一":{"docs":{},"个":{"docs":{},"。":{"docs":{},"若":{"docs":{},"您":{"docs":{},"有":{"docs":{},"多":{"docs":{},"个":{"docs":{},"接":{"docs":{},"口":{"docs":{},"而":{"docs":{},"您":{"docs":{},"想":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"，":{"docs":{},"就":{"docs":{},"在":{"docs":{},"这":{"docs":{},"里":{"docs":{},"指":{"docs":{},"定":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"挑":{"docs":{},"选":{"docs":{},"任":{"docs":{},"何":{"docs":{},"符":{"docs":{},"合":{"docs":{},"域":{"docs":{},"名":{"docs":{},"规":{"docs":{},"则":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"x":{"docs":{},".":{"docs":{},"*":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}},"、":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"参":{"docs":{},"数":{"docs":{},"：":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}},"b":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}}}}}}},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0047522063815342835}}}}}}}}},"o":{"docs":{},"k":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.005484460694698354}},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"docs":{}}},"docs":{}}},"docs":{}},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"m":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789}}}}},"a":{"docs":{},"c":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.008086253369272238}},"s":{"docs":{},"h":{"docs":{},"a":{"2":{"5":{"6":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}},"docs":{}},"docs":{}},"3":{"8":{"4":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}},"docs":{}},"docs":{}},"5":{"1":{"2":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}},"docs":{}},"docs":{}},"docs":{}}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0063025210084033615}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}},"带":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"仪":{"docs":{},"表":{"docs":{},"板":{"docs":{},"（":{"docs":{},"d":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"）":{"docs":{},"，":{"docs":{},"用":{"docs":{},"于":{"docs":{},"显":{"docs":{},"示":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"的":{"docs":{},"当":{"docs":{},"前":{"docs":{},"状":{"docs":{},"态":{"docs":{},"。":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"模":{"docs":{},"式":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"或":{"docs":{},"组":{"docs":{},"合":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{},"本":{"docs":{},"节":{"docs":{},"介":{"docs":{},"绍":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{},"的":{"docs":{},"技":{"docs":{},"巧":{"docs":{},"。":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"2":{"5":{"6":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}},"docs":{}},"docs":{}},"3":{"8":{"4":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}},"docs":{}},"docs":{}},"5":{"1":{"2":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}},"docs":{}},"docs":{}},"docs":{}},")":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.009554140127388535}}}}}},"i":{"6":{"8":{"6":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"docs":{}},"docs":{}},"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}},"n":{"docs":{},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"o":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"r":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},"的":{"docs":{},"技":{"docs":{},"术":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}},"，":{"docs":{},"指":{"docs":{},"非":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"织":{"docs":{},"入":{"docs":{},"字":{"docs":{},"节":{"docs":{},"码":{"docs":{},")":{"docs":{},"的":{"docs":{},"效":{"docs":{},"果":{"docs":{},"。":{"docs":{},"更":{"docs":{},"多":{"docs":{},"细":{"docs":{},"节":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"字":{"docs":{},"节":{"docs":{},"码":{"docs":{},"修":{"docs":{},"改":{"docs":{},"/":{"docs":{},"增":{"docs":{},"强":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}},"j":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"d":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"/":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"/":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}},"(":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}},"t":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.009504412763068567},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.004103967168262654}},"e":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"r":{"docs":{"integration/Integration.html":{"ref":"integration/Integration.html","tf":10.5},"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"j":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0058823529411764705}},"e":{"docs":{},"组":{"docs":{},"件":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}},":":{"docs":{},"挑":{"docs":{},"选":{"docs":{},"任":{"docs":{},"何":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"网":{"docs":{},"络":{"docs":{},"接":{"docs":{},"口":{"docs":{},"名":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"接":{"docs":{},"口":{"docs":{},"：":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\\":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"已":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"校":{"docs":{},"对":{"docs":{},"完":{"docs":{},"成":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"4":{"docs":{},"j":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},")":{"docs":{},";":{"docs":{},"\"":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"。":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"b":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"中":{"docs":{},"运":{"docs":{},"行":{"docs":{},"下":{"docs":{},"边":{"docs":{},"的":{"docs":{},"片":{"docs":{},"段":{"docs":{},"来":{"docs":{},"完":{"docs":{},"成":{"docs":{},"此":{"docs":{},"操":{"docs":{},"作":{"docs":{},"：":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},")":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"f":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"i":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"y":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"i":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"并":{"docs":{},"把":{"docs":{},"这":{"docs":{},"个":{"docs":{},"文":{"docs":{},"件":{"docs":{},"打":{"docs":{},"包":{"docs":{},"到":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"包":{"docs":{},"中":{"docs":{},"，":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"文":{"docs":{},"件":{"docs":{},"中":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"标":{"docs":{},"明":{"docs":{},"第":{"docs":{},"二":{"docs":{},"步":{"docs":{},"中":{"docs":{},"所":{"docs":{},"创":{"docs":{},"建":{"docs":{},"类":{"docs":{},"的":{"docs":{},"全":{"docs":{},"限":{"docs":{},"定":{"docs":{},"名":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":10.028747433264886}},"（":{"docs":{},"预":{"docs":{},"览":{"docs":{},"版":{"docs":{},"）":{"docs":{"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353}}}}}}},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.01642710472279261}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{},"/":{"docs":{},"/":{"docs":{},"加":{"docs":{},"载":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152}}}},"docs":{}}},"docs":{}}},"docs":{}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}},")":{"docs":{},";":{"docs":{},"/":{"docs":{},"/":{"docs":{},"创":{"docs":{},"建":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}},"c":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}},"t":{"docs":{},"e":{"docs":{},"d":{"1":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"2":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"3":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.013223140495867768},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"_":{"docs":{},"s":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"y":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.03216374269005848},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.010706638115631691}},"（":{"docs":{},"自":{"docs":{},"动":{"docs":{},"引":{"docs":{},"入":{"docs":{},"）":{"docs":{},"以":{"docs":{},"及":{"docs":{},"c":{"docs":{},"r":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"a":{"docs":{},"p":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"o":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403}},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.005847953216374269}}}}}}}}}}}}}},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.011695906432748537},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.011695906432748537},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0025549310168625446},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.013711151736745886},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.005847953216374269},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.005847953216374269},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"另":{"docs":{},"外":{"docs":{},"，":{"docs":{},"将":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.005847953216374269},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"m":{"docs":{},"p":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"将":{"docs":{},"数":{"docs":{},"据":{"docs":{},"从":{"docs":{},"一":{"docs":{},"个":{"docs":{},"流":{"docs":{},"泵":{"docs":{},"到":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"流":{"docs":{},"时":{"docs":{},"，":{"docs":{},"实":{"docs":{},"现":{"docs":{},"流":{"docs":{},"量":{"docs":{},"控":{"docs":{},"制":{"docs":{},"。":{"docs":{},"更":{"docs":{},"多":{"docs":{},"关":{"docs":{},"于":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}},"j":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},".":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"l":{"docs":{},"g":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},".":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"y":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"x":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}},"r":{"docs":{},"x":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"还":{"docs":{},"有":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"w":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}},"t":{"docs":{},"：":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"x":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"负":{"docs":{},"责":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"，":{"9":{"4":{"3":{"4":{"7":{"0":{"5":{"4":{"9":{"docs":{},"@":{"docs":{},"q":{"docs":{},"q":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"负":{"docs":{},"责":{"docs":{},"校":{"docs":{},"对":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"计":{"docs":{},"划":{"docs":{},"中":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.008825526137135099},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.003693444136657433},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"e":{"docs":{},"a":{"docs":{},"，":{"docs":{},"有":{"docs":{},"两":{"docs":{},"个":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"社":{"docs":{},"区":{"docs":{},"版":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"）":{"docs":{},"和":{"docs":{},"终":{"docs":{},"极":{"docs":{},"版":{"docs":{},"（":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"）":{"docs":{},"，":{"docs":{},"后":{"docs":{},"者":{"docs":{},"需":{"docs":{},"要":{"docs":{},"付":{"docs":{},"费":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"相":{"docs":{},"比":{"docs":{},"起":{"docs":{},"前":{"docs":{},"者":{"docs":{},"而":{"docs":{},"言":{"docs":{},"，":{"docs":{},"多":{"docs":{},"了":{"docs":{},"很":{"docs":{},"多":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"选":{"docs":{},"择":{"docs":{},"创":{"docs":{},"建":{"docs":{},"新":{"docs":{},"项":{"docs":{},"目":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}},"：":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"运":{"docs":{},"行":{"docs":{},"配":{"docs":{},"置":{"docs":{},"（":{"docs":{},"应":{"docs":{},"用":{"docs":{},"）":{"docs":{},",":{"docs":{},"将":{"docs":{},"主":{"docs":{},"类":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"在":{"docs":{},"程":{"docs":{},"序":{"docs":{},"参":{"docs":{},"数":{"docs":{},"中":{"docs":{},"写":{"docs":{},"：":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"通":{"docs":{},"常":{"docs":{},"会":{"docs":{},"支":{"docs":{},"持":{"docs":{},"注":{"docs":{},"解":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}},"=":{"docs":{},"m":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"之":{"docs":{},"后":{"docs":{},"您":{"docs":{},"想":{"docs":{},"要":{"docs":{},"撤":{"docs":{},"销":{"docs":{},"它":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"：":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"i":{"docs":{},"d":{"docs":{},"，":{"docs":{},"若":{"docs":{},"未":{"docs":{},"设":{"docs":{},"置":{"docs":{},"，":{"docs":{},"则":{"docs":{},"使":{"docs":{},"用":{"docs":{},"随":{"docs":{},"机":{"docs":{},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0027155465037338763}}},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"此":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"回":{"docs":{},"调":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"可":{"docs":{},"以":{"docs":{},"获":{"docs":{},"得":{"docs":{},"保":{"docs":{},"存":{"docs":{},"后":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"参":{"docs":{},"数":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}},"而":{"docs":{},"在":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}},"。":{"docs":{},"在":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},"t":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}}}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"：":{"docs":{},"对":{"docs":{},"象":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}},"+":{"docs":{},"+":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"f":{"docs":{},"(":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},"{":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},"{":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"2":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407}}}}}}}}}}}}}}}},"docs":{}}}},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.003976143141153081}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}}}}}},".":{"docs":{},"v":{"docs":{},".":{"docs":{},"e":{"docs":{},".":{"docs":{},"h":{"docs":{},".":{"docs":{},"s":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"@":{"1":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"2":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"i":{"docs":{},"t":{"docs":{"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":5.0661764705882355}},"e":{"docs":{},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.014705882352941176}},"。":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}},"docs":{}}},"docs":{}}},"docs":{}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{},"/":{"docs":{},"/":{"docs":{},"创":{"docs":{},"建":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}},"c":{"docs":{},"f":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}}}}}}},"。":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588}}}}}}}},"l":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"s":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}},"o":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"，":{"docs":{},"其":{"docs":{},"结":{"docs":{},"果":{"docs":{},"是":{"docs":{},"失":{"docs":{},"败":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"输":{"docs":{},"出":{"docs":{},"。":{"docs":{},"失":{"docs":{},"败":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"将":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406}}}},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"，":{"docs":{},"这":{"docs":{},"与":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.014705882352941176},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.009852216748768473}},"v":{"4":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.009852216748768473}},":":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}},"6":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"，":{"docs":{},"但":{"docs":{},"路":{"docs":{},"由":{"docs":{},"表":{"docs":{},"配":{"docs":{},"置":{"docs":{},"不":{"docs":{},"正":{"docs":{},"确":{"docs":{},"，":{"docs":{},"或":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}},"docs":{}}}},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}},")":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"可":{"docs":{},"以":{"docs":{},"指":{"docs":{},"定":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.005847953216374269},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"[":{"docs":{},"]":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}},"s":{"docs":{},"，":{"docs":{},"并":{"docs":{},"不":{"docs":{},"在":{"docs":{},"需":{"docs":{},"要":{"docs":{},"它":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},".":{"docs":{},"*":{"docs":{},"\\":{"docs":{},"\\":{"docs":{},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"m":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{},"m":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{"integration/MailClient.html":{"ref":"integration/MailClient.html","tf":5.333333333333333}},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.017543859649122806},"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.007462686567164179},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.007312614259597806},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588},"services/MavenServiceFactory.html":{"ref":"services/MavenServiceFactory.html","tf":3.583333333333333}},"相":{"docs":{},"关":{"docs":{},"知":{"docs":{},"识":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"知":{"docs":{},"道":{"docs":{},"什":{"docs":{},"么":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"是":{"docs":{},"做":{"docs":{},"什":{"docs":{},"么":{"docs":{},"用":{"docs":{},"的":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"如":{"docs":{},"何":{"docs":{},"使":{"docs":{},"用":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"；":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}}}}}}}}}},"/":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}},"（":{"docs":{},"您":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036}},"p":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{},"文":{"docs":{},"件":{"docs":{},"中":{"docs":{},"）":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}},"里":{"docs":{},"）":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}},"你":{"docs":{},"的":{"docs":{},"p":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{},"文":{"docs":{},"件":{"docs":{},"里":{"docs":{},"）":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}},"(":{"docs":{},"p":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{},")":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}},"在":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},"你":{"docs":{},"的":{"docs":{},"p":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{},"中":{"docs":{},")":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"f":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}},"a":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"devops/StackManager.html":{"ref":"devops/StackManager.html","tf":5.333333333333333},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.01026694045174538},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.011029411764705883},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.008746355685131196},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"来":{"docs":{},"实":{"docs":{},"现":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"。":{"docs":{},"在":{"docs":{"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353}}}}}}}}}}}},"。":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"k":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"p":{"1":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"2":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"e":{"docs":{},"e":{"docs":{},"k":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"e":{"docs":{},"e":{"docs":{},"k":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281},"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.008614976805831677},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}},"x":{"docs":{},"y":{"docs":{},"z":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}},"s":{"docs":{},")":{"docs":{},"允":{"docs":{},"许":{"docs":{},"从":{"docs":{},"集":{"docs":{},"群":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"节":{"docs":{},"点":{"docs":{},"将":{"docs":{},"数":{"docs":{},"据":{"docs":{},"放":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"动":{"docs":{},"词":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"来":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"并":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"于":{"docs":{},"清":{"docs":{},"理":{"docs":{},"过":{"docs":{},"期":{"docs":{},"会":{"docs":{},"话":{"docs":{},"的":{"docs":{},"回":{"docs":{},"收":{"docs":{},"器":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"将":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"。":{"docs":{},"更":{"docs":{},"多":{"docs":{},"详":{"docs":{},"情":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"说":{"docs":{},"明":{"docs":{},"文":{"docs":{},"档":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}},">":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"(":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"_":{"docs":{},"s":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"_":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"：":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"重":{"docs":{},"新":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"次":{"docs":{},"数":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.004598875830352581},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.014778325123152709}}}}},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"o":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"等":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"o":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}},"系":{"docs":{},"统":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}},"e":{"docs":{},"的":{"docs":{},"知":{"docs":{},"识":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"需":{"docs":{},"要":{"docs":{},"您":{"docs":{},"对":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"有":{"docs":{},"所":{"docs":{},"了":{"docs":{},"解":{"docs":{},"，":{"docs":{},"在":{"docs":{},"此":{"docs":{},"文":{"docs":{},"档":{"docs":{},"中":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"不":{"docs":{},"会":{"docs":{},"介":{"docs":{},"绍":{"docs":{},"任":{"docs":{},"何":{"docs":{},"关":{"docs":{},"于":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.01592356687898089},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.006642820643842616},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"e":{"docs":{},".":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"…":{"docs":{},"​":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"(":{"docs":{},"…":{"docs":{},"​":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"。":{"docs":{},"消":{"docs":{},"息":{"docs":{},"编":{"docs":{},"解":{"docs":{},"码":{"docs":{},"器":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"发":{"docs":{},"送":{"docs":{},"或":{"docs":{},"发":{"docs":{},"布":{"docs":{},"消":{"docs":{},"息":{"docs":{},"时":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"中":{"docs":{},"。":{"docs":{},"在":{"docs":{},"某":{"docs":{},"些":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"发":{"docs":{},"送":{"docs":{},"者":{"docs":{},"需":{"docs":{},"要":{"docs":{},"知":{"docs":{},"道":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"何":{"docs":{},"时":{"docs":{},"收":{"docs":{},"到":{"docs":{},"消":{"docs":{},"息":{"docs":{},"并":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"之":{"docs":{},"后":{"docs":{},"再":{"docs":{},"来":{"docs":{},"设":{"docs":{},"置":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0025549310168625446}},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"(":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"（":{"docs":{},"即":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"、":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"、":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"、":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"、":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"、":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"等":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"调":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"devops/MetricsUsingDropwizard.html":{"ref":"devops/MetricsUsingDropwizard.html","tf":3.583333333333333},"devops/MetricsUsingHawkular.html":{"ref":"devops/MetricsUsingHawkular.html","tf":3.583333333333333}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"指":{"docs":{},"标":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}},"a":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0035769034236075624}},"\"":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0030659172202350538}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"i":{"docs":{},"s":{"docs":{},"m":{"docs":{},"：":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"o":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}},"。":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677},"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}},"j":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"j":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"r":{"docs":{},"b":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"n":{"docs":{},"f":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}},"r":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"j":{"docs":{},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"j":{"docs":{},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},",":{"docs":{},"a":{"docs":{},"d":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.024875621890547265}},"/":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":5.014925373134329},"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.007462686567164179}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.007462686567164179}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.004975124378109453}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.007462686567164179}},")":{"docs":{},";":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.004975124378109453}}}},",":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"y":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"e":{"docs":{},"b":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"y":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}},"，":{"docs":{},"则":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"类":{"docs":{},"命":{"docs":{},"名":{"docs":{},"为":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}},"g":{"1":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"2":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"3":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"docs":{},".":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677}}}}}}}}}}},"d":{"docs":{},"n":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"e":{"docs":{},"t":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789}},"n":{"docs":{},"x":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789}}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"p":{"docs":{},"l":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"：":{"docs":{},"多":{"docs":{},"路":{"docs":{},"复":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"_":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.009852216748768473}},"：":{"docs":{},"多":{"docs":{},"播":{"docs":{},"（":{"docs":{},"组":{"docs":{},"播":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0009289363678588017},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.0037243947858473}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"d":{"docs":{},"、":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}},"r":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"：":{"docs":{},"挂":{"docs":{},"载":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0030659172202350538},"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0033944331296673455},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"r":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"r":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"r":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0027155465037338763}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}},"，":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"同":{"docs":{},"时":{"docs":{},"提":{"docs":{},"供":{"docs":{},"：":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"位":{"docs":{},"置":{"docs":{},"信":{"docs":{},"息":{"docs":{},"、":{"docs":{},"元":{"docs":{},"数":{"docs":{},"据":{"docs":{},"以":{"docs":{},"及":{"docs":{},"服":{"docs":{},"务":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"b":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":5.0162932790224035},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":5.006802721088436},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"中":{"docs":{},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"置":{"docs":{},"下":{"docs":{},"边":{"docs":{},"几":{"docs":{},"种":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"的":{"docs":{},"值":{"docs":{},"（":{"docs":{},"参":{"docs":{},"考":{"docs":{},"下":{"docs":{},"边":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"：":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"特":{"docs":{},"性":{"docs":{},"是":{"docs":{},"先":{"docs":{},"查":{"docs":{},"询":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"字":{"docs":{},"段":{"docs":{},"中":{"docs":{},"的":{"docs":{},"值":{"docs":{},"是":{"docs":{},"否":{"docs":{},"已":{"docs":{},"经":{"docs":{},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"会":{"docs":{},"插":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"并":{"docs":{},"不":{"docs":{},"能":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"原":{"docs":{},"子":{"docs":{},"性":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"基":{"docs":{},"于":{"docs":{},"这":{"docs":{},"个":{"docs":{},"原":{"docs":{},"因":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"添":{"docs":{},"加":{"docs":{},"上":{"docs":{},"边":{"docs":{},"的":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"索":{"docs":{},"引":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"这":{"docs":{},"个":{"docs":{},"索":{"docs":{},"引":{"docs":{},"过":{"docs":{},"后":{"docs":{},"你":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"会":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"先":{"docs":{},"插":{"docs":{},"入":{"docs":{},"一":{"docs":{},"行":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"出":{"docs":{},"现":{"docs":{},"了":{"docs":{},"重":{"docs":{},"复":{"docs":{},"记":{"docs":{},"录":{"docs":{},"则":{"docs":{},"会":{"docs":{},"失":{"docs":{},"败":{"docs":{},"。":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"(":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"/":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"auth/Auth.html":{"ref":"auth/Auth.html","tf":0.041666666666666664}}}}}}}}}}}}},":":{"3":{"docs":{},".":{"2":{"docs":{},".":{"1":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}},"docs":{}}},"docs":{}}},"docs":{}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"一":{"docs":{},"个":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"（":{"docs":{},"该":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"将":{"docs":{},"从":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"、":{"docs":{},"元":{"docs":{},"数":{"docs":{},"据":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"中":{"docs":{},"获":{"docs":{},"取":{"docs":{},"）":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"通":{"docs":{},"过":{"docs":{},"下":{"docs":{},"边":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"访":{"docs":{},"问":{"docs":{},"m":{"docs":{},"x":{"docs":{},"记":{"docs":{},"录":{"docs":{},"的":{"docs":{},"优":{"docs":{},"先":{"docs":{},"级":{"docs":{},"和":{"docs":{},"名":{"docs":{},"称":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"e":{"docs":{},"s":{"docs":{},"：":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0034079844206426485}}}},"n":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"b":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"m":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"_":{"docs":{},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"_":{"docs":{},"s":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0019474196689386564}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}}}},"m":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}},"g":{"docs":{},"r":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"j":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}},".":{"docs":{},"j":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},":":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}},"_":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"错":{"docs":{},"误":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"可":{"docs":{},"发":{"docs":{},"送":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"代":{"docs":{},"码":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"docs":{}}}}}}},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"：":{"docs":{},"密":{"docs":{},"码":{"docs":{},"就":{"docs":{},"不":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"加":{"docs":{},"密":{"docs":{},"以":{"docs":{},"明":{"docs":{},"文":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"存":{"docs":{},"储":{"docs":{},"。":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0010218300046446818},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.006369426751592357}}},".":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}},"n":{"docs":{},"e":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},":":{"docs":{},"挑":{"docs":{},"选":{"docs":{},"任":{"docs":{},"何":{"docs":{},"非":{"docs":{},"回":{"docs":{},"送":{"docs":{},"地":{"docs":{},"址":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.02564102564102564},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.007153806847215125},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},":":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}},"\"":{"docs":{},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}},"未":{"docs":{},"设":{"docs":{},"置":{"docs":{},"，":{"docs":{},"将":{"docs":{},"生":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"随":{"docs":{},"机":{"docs":{},"的":{"docs":{},"i":{"docs":{},"d":{"docs":{},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{},"命":{"docs":{},"令":{"docs":{},"提":{"docs":{},"示":{"docs":{},"符":{"docs":{},"中":{"docs":{},"打":{"docs":{},"印":{"docs":{},"。":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"选":{"docs":{},"项":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"命":{"docs":{},"令":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"该":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"值":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"o":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}}}}}}},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"t":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}},"e":{"docs":{},"w":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.011333023687877381},"web/Web.html":{"ref":"web/Web.html","tf":0.008033106134371958},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.0037243947858473},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.024439918533604887},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.009575923392612859},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.008639308855291577},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.014925373134328358},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.01656726308813784},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.013477088948787063},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.009852216748768473},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.013605442176870748},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.021487603305785124},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0046168051708217915},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.01430761369443025},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.01050420168067227},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.03016453382084095},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.015355086372360844},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.012320328542094456},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.01838235294117647},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.01749271137026239},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.009852216748768473},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.021176470588235293}},"s":{"docs":{},".":{"docs":{},"u":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"s":{"docs":{},"a":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"e":{"docs":{},"u":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"_":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"?":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036}}}},"g":{"docs":{},"o":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},"是":{"docs":{},"应":{"docs":{},"用":{"docs":{},"层":{"docs":{},"协":{"docs":{},"议":{"docs":{},"协":{"docs":{},"商":{"docs":{},"的":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"，":{"docs":{},"它":{"docs":{},"被":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"/":{"2":{"docs":{},"使":{"docs":{},"用":{"docs":{},"：":{"docs":{},"在":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"握":{"docs":{},"手":{"docs":{},"期":{"docs":{},"时":{"docs":{},"，":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"给":{"docs":{},"出":{"docs":{},"其":{"docs":{},"接":{"docs":{},"受":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"协":{"docs":{},"议":{"docs":{},"列":{"docs":{},"表":{"docs":{},"，":{"docs":{},"之":{"docs":{},"后":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"所":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"协":{"docs":{},"议":{"docs":{},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{},"，":{"docs":{},"应":{"docs":{},"用":{"docs":{},"层":{"docs":{},"协":{"docs":{},"议":{"docs":{},"协":{"docs":{},"商":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.009852216748768473}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0023223409196470044}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0025081281932187644}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0013005109150023223}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"1":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"x":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.002693915466790525}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0018578727357176034}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0013005109150023223}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"1":{"2":{"3":{"4":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"4":{"3":{"2":{"1":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"x":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"、":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"t":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0009289363678588017}}},"y":{"docs":{},"不":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"于":{"docs":{},"外":{"docs":{},"部":{"docs":{},"日":{"docs":{},"志":{"docs":{},"配":{"docs":{},"置":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{},"）":{"docs":{},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"根":{"docs":{},"据":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"类":{"docs":{},"可":{"docs":{},"见":{"docs":{},"的":{"docs":{},"日":{"docs":{},"志":{"docs":{},"记":{"docs":{},"录":{"docs":{},"库":{"docs":{},"来":{"docs":{},"实":{"docs":{},"现":{"docs":{},"日":{"docs":{},"志":{"docs":{},"记":{"docs":{},"录":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"日":{"docs":{},"志":{"docs":{},"记":{"docs":{},"录":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"f":{"docs":{},"l":{"docs":{},"i":{"docs":{},"x":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}}}}}}},"x":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}},")":{"docs":{},"：":{"docs":{},"当":{"docs":{},"前":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"，":{"docs":{},"则":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},".":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"s":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"u":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.006839945280437756},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.005620848237097598}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0027155465037338763},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"\"":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}},"（":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"授":{"docs":{},"权":{"docs":{},"）":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}},"，":{"docs":{},"且":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}}}}},"m":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"x":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"r":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"p":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.008086253369272238}},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.02564102564102564}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.02046783625730994},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052}},"e":{"docs":{},"命":{"docs":{},"令":{"docs":{},"打":{"docs":{},"包":{"docs":{},"。":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}},"，":{"docs":{},"随":{"docs":{},"后":{"docs":{},"在":{"docs":{},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"的":{"docs":{},"同":{"docs":{},"级":{"docs":{},"目":{"docs":{},"录":{"docs":{},"下":{"docs":{},"会":{"docs":{},"出":{"docs":{},"现":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"目":{"docs":{},"录":{"docs":{},"，":{"docs":{},"进":{"docs":{},"入":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"会":{"docs":{},"出":{"docs":{},"现":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"0":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"1":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"=":{"docs":{},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"&":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"2":{"docs":{},"=":{"docs":{},"x":{"docs":{},"y":{"docs":{},"z":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"docs":{}}}}}}}}}}}},"2":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}},"\"":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"s":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}}},"e":{"docs":{},"t":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"d":{"docs":{},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"?":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"轻":{"docs":{},"松":{"docs":{},"解":{"docs":{},"析":{"docs":{},"由":{"docs":{},"字":{"docs":{},"节":{"docs":{},"序":{"docs":{},"列":{"docs":{},"或":{"docs":{},"固":{"docs":{},"定":{"docs":{},"尺":{"docs":{},"寸":{"docs":{},"带":{"docs":{},"分":{"docs":{},"隔":{"docs":{},"符":{"docs":{},"的":{"docs":{},"记":{"docs":{},"录":{"docs":{},"的":{"docs":{},"协":{"docs":{},"议":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"解":{"docs":{},"析":{"docs":{},"方":{"docs":{},"法":{"docs":{},"返":{"docs":{},"回":{"docs":{},"包":{"docs":{},"含":{"docs":{},"值":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"它":{"docs":{},"验":{"docs":{},"证":{"docs":{},"用":{"docs":{},"户":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"，":{"docs":{},"并":{"docs":{},"检":{"docs":{},"查":{"docs":{},"每":{"docs":{},"个":{"docs":{},"必":{"docs":{},"填":{"docs":{},"选":{"docs":{},"项":{"docs":{},"和":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"设":{"docs":{},"置":{"docs":{},"以":{"docs":{},"及":{"docs":{},"每":{"docs":{},"个":{"docs":{},"选":{"docs":{},"项":{"docs":{},"接":{"docs":{},"收":{"docs":{},"的":{"docs":{},"值":{"docs":{},"的":{"docs":{},"数":{"docs":{},"量":{"docs":{},"。":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"传":{"docs":{},"递":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"i":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.008614976805831677}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"=":{"docs":{},"\"":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"+":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},"+":{"docs":{},"\"":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},"+":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},"+":{"docs":{},"\"":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},"+":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}},"s":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}},"r":{"docs":{},"e":{"docs":{},"v":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"如":{"docs":{},"果":{"docs":{},"某":{"docs":{},"个":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"并":{"docs":{},"不":{"docs":{},"属":{"docs":{},"于":{"docs":{},"任":{"docs":{},"何":{"docs":{},"消":{"docs":{},"费":{"docs":{},"组":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"整":{"docs":{},"个":{"docs":{},"程":{"docs":{},"序":{"docs":{},"就":{"docs":{},"不":{"docs":{},"能":{"docs":{},"依":{"docs":{},"赖":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"它":{"docs":{},"是":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"此":{"docs":{},"消":{"docs":{},"费":{"docs":{},"组":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"接":{"docs":{},"纳":{"docs":{},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"可":{"docs":{},"以":{"docs":{},"实":{"docs":{},"现":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}},"所":{"docs":{},"以":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"保":{"docs":{},"证":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"被":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"分":{"docs":{},"区":{"docs":{},"（":{"docs":{},"k":{"docs":{},"a":{"docs":{},"f":{"docs":{},"k":{"docs":{},"a":{"docs":{},"中":{"docs":{},"的":{"docs":{},"设":{"docs":{},"计":{"docs":{},"）":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.004087889626980072},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.005484460694698354}},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"本":{"docs":{},"地":{"docs":{},"路":{"docs":{},"径":{"docs":{},"）":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}},"u":{"docs":{},"s":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"e":{"docs":{},"：":{"docs":{},"暂":{"docs":{},"停":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"暂":{"docs":{},"停":{"docs":{},"时":{"docs":{},"，":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"中":{"docs":{},"将":{"docs":{},"不":{"docs":{},"会":{"docs":{},"受":{"docs":{},"到":{"docs":{},"任":{"docs":{},"何":{"docs":{},"项":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"，":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0025549310168625446}},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},"：":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"o":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}},":":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.017543859649122806},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"和":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}},"插":{"docs":{},"件":{"docs":{},"的":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"f":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"的":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"前":{"docs":{},"者":{"docs":{},"用":{"docs":{},"来":{"docs":{},"将":{"docs":{},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"的":{"docs":{},"源":{"docs":{},"文":{"docs":{},"件":{"docs":{},"编":{"docs":{},"译":{"docs":{},"成":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"的":{"docs":{},"字":{"docs":{},"节":{"docs":{},"码":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"后":{"docs":{},"者":{"docs":{},"可":{"docs":{},"将":{"docs":{},"编":{"docs":{},"译":{"docs":{},"后":{"docs":{},"的":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"字":{"docs":{},"节":{"docs":{},"码":{"docs":{},"文":{"docs":{},"件":{"docs":{},"打":{"docs":{},"包":{"docs":{},"成":{"docs":{},"可":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"俗":{"docs":{},"称":{"docs":{},"f":{"docs":{},"a":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}}}},")":{"docs":{},"调":{"docs":{},"试":{"docs":{},"器":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"每":{"docs":{},"次":{"docs":{},"都":{"docs":{},"会":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"进":{"docs":{},"程":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"y":{"docs":{},"_":{"docs":{},"g":{"docs":{},"o":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{},"s":{"docs":{},"a":{"docs":{},"y":{"docs":{},"_":{"docs":{},"b":{"docs":{},"u":{"docs":{},"z":{"docs":{},"z":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"m":{"docs":{},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.007312614259597806},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},"文":{"docs":{},"件":{"docs":{},"中":{"docs":{},"）":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},")":{"docs":{},":":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0010218300046446818},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"。":{"docs":{},"当":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"：":{"docs":{},"事":{"docs":{},"件":{"docs":{},"轮":{"docs":{},"询":{"docs":{},"线":{"docs":{},"程":{"docs":{},"池":{"docs":{},"，":{"docs":{},"大":{"docs":{},"部":{"docs":{},"分":{"docs":{},"地":{"docs":{},"方":{"docs":{},"未":{"docs":{},"翻":{"docs":{},"译":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"工":{"docs":{},"作":{"docs":{},"者":{"docs":{},"线":{"docs":{},"程":{"docs":{},"池":{"docs":{},"，":{"docs":{},"大":{"docs":{},"部":{"docs":{},"分":{"docs":{},"地":{"docs":{},"方":{"docs":{},"未":{"docs":{},"翻":{"docs":{},"译":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"）":{"docs":{},"创":{"docs":{},"建":{"docs":{},"调":{"docs":{},"度":{"docs":{},"器":{"docs":{},"也":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"的":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"想":{"docs":{},"为":{"docs":{},"了":{"docs":{},"调":{"docs":{},"度":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"操":{"docs":{},"作":{"docs":{},"复":{"docs":{},"用":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"池":{"docs":{},"，":{"docs":{},"这":{"docs":{},"将":{"docs":{},"会":{"docs":{},"很":{"docs":{},"有":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"：":{"docs":{},"若":{"docs":{},"指":{"docs":{},"定":{"docs":{},"了":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"选":{"docs":{},"项":{"docs":{},"，":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"确":{"docs":{},"定":{"docs":{},"哪":{"docs":{},"个":{"docs":{},"端":{"docs":{},"口":{"docs":{},"将":{"docs":{},"用":{"docs":{},"于":{"docs":{},"与":{"docs":{},"其":{"docs":{},"他":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"进":{"docs":{},"行":{"docs":{},"集":{"docs":{},"群":{"docs":{},"通":{"docs":{},"信":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"0":{"docs":{},"—":{"docs":{},"—":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"“":{"docs":{},"选":{"docs":{},"择":{"docs":{},"一":{"docs":{},"个":{"docs":{},"空":{"docs":{},"闲":{"docs":{},"的":{"docs":{},"随":{"docs":{},"机":{"docs":{},"端":{"docs":{},"口":{"docs":{},"”":{"docs":{},"。":{"docs":{},"除":{"docs":{},"非":{"docs":{},"您":{"docs":{},"帧":{"docs":{},"需":{"docs":{},"要":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"特":{"docs":{},"定":{"docs":{},"端":{"docs":{},"口":{"docs":{},"，":{"docs":{},"您":{"docs":{},"通":{"docs":{},"常":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"指":{"docs":{},"定":{"docs":{},"此":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"：":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"数":{"docs":{},"指":{"docs":{},"定":{"docs":{},"在":{"docs":{},"文":{"docs":{},"件":{"docs":{},"中":{"docs":{},"写":{"docs":{},"入":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"的":{"docs":{},"位":{"docs":{},"置":{"docs":{},"，":{"docs":{},"若":{"docs":{},"位":{"docs":{},"置":{"docs":{},"大":{"docs":{},"于":{"docs":{},"或":{"docs":{},"等":{"docs":{},"于":{"docs":{},"文":{"docs":{},"件":{"docs":{},"大":{"docs":{},"小":{"docs":{},"，":{"docs":{},"文":{"docs":{},"件":{"docs":{},"将":{"docs":{},"被":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"以":{"docs":{},"适":{"docs":{},"应":{"docs":{},"偏":{"docs":{},"移":{"docs":{},"的":{"docs":{},"位":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"从":{"docs":{},"文":{"docs":{},"件":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"位":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922}},"g":{"docs":{},"r":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.03233830845771144}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.007462686567164179}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.007462686567164179}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.004975124378109453}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.007462686567164179}},")":{"docs":{},";":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.004975124378109453}}}},",":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}},"s":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}},"j":{"docs":{},"o":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}},"x":{"docs":{},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}}}}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}}}}},"*":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"/":{"2":{"docs":{},".":{"0":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"s":{"docs":{},"m":{"docs":{},"\\":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"：":{"docs":{},"基":{"docs":{},"本":{"docs":{},"（":{"docs":{},"描":{"docs":{},"述":{"docs":{},"类":{"docs":{},"型":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"l":{"docs":{},"：":{"docs":{},"凭":{"docs":{},"证":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403}},"两":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"后":{"docs":{},"者":{"docs":{},"是":{"docs":{},"可":{"docs":{},"执":{"docs":{},"行":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"在":{"docs":{},"有":{"docs":{},"图":{"docs":{},"形":{"docs":{},"界":{"docs":{},"面":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"中":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"双":{"docs":{},"击":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"用":{"docs":{},"以":{"docs":{},"下":{"docs":{},"命":{"docs":{},"令":{"docs":{},"：":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}},"u":{"docs":{},"c":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.00927766732935719}},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}}}}}},"e":{"docs":{},"r":{"1":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406}}}},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}},":":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"。":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"当":{"docs":{},"对":{"docs":{},"应":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.006423982869379015}}}}},"b":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}},"o":{"docs":{},"r":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},"）":{"docs":{},"会":{"docs":{},"在":{"docs":{},"编":{"docs":{},"译":{"docs":{},"期":{"docs":{},"生":{"docs":{},"成":{"docs":{},"这":{"docs":{},"些":{"docs":{},"类":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"额":{"docs":{},"外":{"docs":{},"的":{"docs":{},"步":{"docs":{},"骤":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"去":{"docs":{},"配":{"docs":{},"置":{"docs":{},"一":{"docs":{},"下":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"构":{"docs":{},"建":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}}}}}},"x":{"docs":{},"y":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"5":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}},":":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"y":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"组":{"docs":{},"件":{"docs":{},"，":{"docs":{},"请":{"docs":{},"先":{"docs":{},"加":{"docs":{},"入":{"docs":{},"以":{"docs":{},"下":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}},"）":{"docs":{},"的":{"docs":{},"目":{"docs":{},"的":{"docs":{},"。":{"docs":{},"它":{"docs":{},"允":{"docs":{},"许":{"docs":{},"你":{"docs":{},"在":{"docs":{},"e":{"docs":{},"v":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"你":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"调":{"docs":{},"用":{"docs":{},"端":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"相":{"docs":{},"当":{"docs":{},"符":{"docs":{},"合":{"docs":{},"习":{"docs":{},"惯":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"即":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"）":{"docs":{},"进":{"docs":{},"行":{"docs":{},"服":{"docs":{},"务":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"去":{"docs":{},"手":{"docs":{},"动":{"docs":{},"地":{"docs":{},"向":{"docs":{},"e":{"docs":{},"v":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"一":{"docs":{},"个":{"docs":{},"编":{"docs":{},"译":{"docs":{},"时":{"docs":{},"产":{"docs":{},"生":{"docs":{},"的":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"，":{"docs":{},"用":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}},"：":{"docs":{},"已":{"docs":{},"重":{"docs":{},"新":{"docs":{},"翻":{"docs":{},"译":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":5.003529411764706},"services/SockJSServiceProxies.html":{"ref":"services/SockJSServiceProxies.html","tf":3.583333333333333}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.008086253369272238},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.019704433497536946},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"一":{"docs":{},"些":{"docs":{},"支":{"docs":{},"持":{"docs":{},"角":{"docs":{},"色":{"docs":{},"/":{"docs":{},"权":{"docs":{},"限":{"docs":{},"的":{"docs":{},"模":{"docs":{},"型":{"docs":{},"，":{"docs":{},"另":{"docs":{},"一":{"docs":{},"些":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{},"模":{"docs":{},"型":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"完":{"docs":{},"整":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}},"则":{"docs":{},"需":{"docs":{},"要":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"实":{"docs":{},"现":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"按":{"docs":{},"照":{"docs":{},"文":{"docs":{},"档":{"docs":{},"中":{"docs":{},"的":{"docs":{},"内":{"docs":{},"容":{"docs":{},"实":{"docs":{},"施":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}},"的":{"docs":{},"认":{"docs":{},"证":{"docs":{},"示":{"docs":{},"例":{"docs":{},"实":{"docs":{},"现":{"docs":{},"代":{"docs":{},"码":{"docs":{},"：":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"：":{"docs":{},"背":{"docs":{},"压":{"docs":{},"机":{"docs":{},"制":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"，":{"docs":{},"即":{"docs":{},"判":{"docs":{},"断":{"docs":{},"函":{"docs":{},"数":{"docs":{},"）":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}},"n":{"docs":{},"g":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.021897810218978103},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.01284796573875803},"core/Core.html":{"ref":"core/Core.html","tf":0.0017649790989317231},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.006463527239150508},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.01647058823529412}},"（":{"docs":{},"或":{"docs":{},"者":{"docs":{},"有":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"s":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"n":{"docs":{},".":{"docs":{},")":{"docs":{},"：":{"docs":{},"发":{"docs":{},"布":{"docs":{},"者":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}}}}}}},"/":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}},"m":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.03409090909090909}},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"m":{"docs":{},"p":{"docs":{},"(":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}},"r":{"docs":{},"s":{"docs":{},",":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.011363636363636364}}}}}}}}}}},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"即":{"docs":{},"使":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"：":{"docs":{},"泵":{"docs":{},"（":{"docs":{},"平":{"docs":{},"滑":{"docs":{},"流":{"docs":{},"式":{"docs":{},"数":{"docs":{},"据":{"docs":{},"读":{"docs":{},"入":{"docs":{},"内":{"docs":{},"存":{"docs":{},"的":{"docs":{},"机":{"docs":{},"制":{"docs":{},"，":{"docs":{},"防":{"docs":{},"止":{"docs":{},"一":{"docs":{},"次":{"docs":{},"性":{"docs":{},"将":{"docs":{},"大":{"docs":{},"量":{"docs":{},"数":{"docs":{},"据":{"docs":{},"读":{"docs":{},"入":{"docs":{},"内":{"docs":{},"存":{"docs":{},"导":{"docs":{},"致":{"docs":{},"内":{"docs":{},"存":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612}},")":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"g":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"e":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}}}}}}}},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"i":{"docs":{},"o":{"docs":{},"d":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"：":{"docs":{},"停":{"docs":{},"止":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"后":{"docs":{},"等":{"docs":{},"待":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"（":{"docs":{},"在":{"docs":{},"启":{"docs":{},"动":{"docs":{},"用":{"docs":{},"户":{"docs":{},"命":{"docs":{},"令":{"docs":{},"之":{"docs":{},"前":{"docs":{},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"在":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"上":{"docs":{},"非":{"docs":{},"常":{"docs":{},"有":{"docs":{},"用":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"个":{"docs":{},"进":{"docs":{},"程":{"docs":{},"并":{"docs":{},"没":{"docs":{},"立":{"docs":{},"即":{"docs":{},"被":{"docs":{},"杀":{"docs":{},"死":{"docs":{},"。":{"docs":{},"时":{"docs":{},"间":{"docs":{},"以":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"为":{"docs":{},"单":{"docs":{},"位":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"2":{"0":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"2":{"docs":{},"次":{"docs":{},"重":{"docs":{},"新":{"docs":{},"部":{"docs":{},"署":{"docs":{},"之":{"docs":{},"间":{"docs":{},"等":{"docs":{},"待":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"（":{"docs":{},"以":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"为":{"docs":{},"单":{"docs":{},"位":{"docs":{},"）":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"1":{"0":{"0":{"0":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"检":{"docs":{},"查":{"docs":{},"周":{"docs":{},"期":{"docs":{},"（":{"docs":{},"以":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"为":{"docs":{},"单":{"docs":{},"位":{"docs":{},"）":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"2":{"5":{"0":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"\"":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0024342745861733205}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"g":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"s":{"docs":{},"\\":{"docs":{},"\\":{"docs":{},".":{"docs":{},".":{"docs":{},"+":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"：":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}},"许":{"docs":{},"可":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}},"/":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"模":{"docs":{},"型":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}},"s":{"docs":{},"：":{"docs":{},"权":{"docs":{},"限":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}},"b":{"docs":{},"b":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243}},"e":{"docs":{},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"0":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"docs":{}}},"docs":{}}},"docs":{}},"：":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},":":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.005471956224350205}},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}},"f":{"docs":{},"x":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281},"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603}}}},"p":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"：":{"docs":{},"管":{"docs":{},"道":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"k":{"docs":{},"c":{"docs":{},"s":{"docs":{},"＃":{"1":{"2":{"docs":{},"格":{"docs":{},"式":{"docs":{},"的":{"docs":{},"密":{"docs":{},"钥":{"docs":{},"/":{"docs":{},"证":{"docs":{},"书":{"docs":{},"（":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"e":{"docs":{},"n":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"w":{"docs":{},"i":{"docs":{},"k":{"docs":{},"i":{"docs":{},"/":{"docs":{},"p":{"docs":{},"k":{"docs":{},"c":{"docs":{},"s":{"docs":{},"_":{"1":{"2":{"docs":{},"，":{"docs":{},"通":{"docs":{},"常":{"docs":{},"为":{"docs":{},".":{"docs":{},"p":{"docs":{},"f":{"docs":{},"x":{"docs":{},"或":{"docs":{},".":{"docs":{},"p":{"1":{"2":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"名":{"docs":{},"）":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"与":{"docs":{},"j":{"docs":{},"k":{"docs":{},"s":{"docs":{},"密":{"docs":{},"钥":{"docs":{},"存":{"docs":{},"储":{"docs":{},"相":{"docs":{},"似":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"加":{"docs":{},"载":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}},"s":{"3":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}},"_":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}},"docs":{},"u":{"docs":{},"d":{"docs":{},"o":{"docs":{"./":{"ref":"./","tf":0.01282051282051282},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.009852216748768473}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"e":{"docs":{},"d":{"docs":{},"?":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0030659172202350538}}}}}}},"s":{"docs":{},"s":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"：":{"docs":{},"密":{"docs":{},"码":{"docs":{},"套":{"docs":{},"件":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"_":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}},"）":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"我":{"docs":{},"们":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"类":{"docs":{},"，":{"docs":{},"以":{"docs":{},"便":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.003976143141153081},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"(":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.003693444136657433}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"v":{"docs":{},".":{"docs":{},")":{"docs":{},"：":{"docs":{},"注":{"docs":{},"册":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}},"n":{"docs":{},".":{"docs":{},")":{"docs":{},"：":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"者":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"将":{"docs":{},"其":{"docs":{},"注":{"docs":{},"册":{"docs":{},"在":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"：":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"者":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"p":{"docs":{},"t":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"n":{"docs":{},".":{"docs":{},")":{"docs":{},"：":{"docs":{},"订":{"docs":{},"阅":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.005431093007467753},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.004103967168262654},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.004705882352941176}},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"_":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{},"a":{"docs":{},"d":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"r":{"docs":{},"a":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"r":{"docs":{},"g":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"设":{"docs":{},"置":{"docs":{},"或":{"docs":{},"清":{"docs":{},"除":{"docs":{},"s":{"docs":{},"o":{"docs":{},"_":{"docs":{},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"套":{"docs":{},"接":{"docs":{},"字":{"docs":{},"选":{"docs":{},"项":{"docs":{},"，":{"docs":{},"设":{"docs":{},"置":{"docs":{},"此":{"docs":{},"选":{"docs":{},"项":{"docs":{},"时":{"docs":{},"，":{"docs":{},"数":{"docs":{},"据":{"docs":{},"报":{"docs":{},"（":{"docs":{},"u":{"docs":{},"d":{"docs":{},"p":{"docs":{},"）":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{},"本":{"docs":{},"地":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"广":{"docs":{},"播":{"docs":{},"地":{"docs":{},"址":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"、":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"和":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"(":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"1":{"0":{"0":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}},"i":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"g":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"p":{"2":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"(":{"3":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}}}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"(":{"1":{"0":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"a":{"docs":{},"g":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"j":{"docs":{},"d":{"docs":{},"k":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"y":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"j":{"docs":{},"k":{"docs":{},"s":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"将":{"docs":{},"其":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"高":{"docs":{},"于":{"0":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"则":{"docs":{},"您":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"在":{"docs":{},"最":{"docs":{},"终":{"docs":{},"失":{"docs":{},"败":{"docs":{},"之":{"docs":{},"前":{"docs":{},"进":{"docs":{},"行":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"多":{"docs":{},"次":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"代":{"docs":{},"码":{"docs":{},"在":{"docs":{},"其":{"docs":{},"中":{"docs":{},"一":{"docs":{},"个":{"docs":{},"重":{"docs":{},"试":{"docs":{},"中":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"则":{"docs":{},"处":{"docs":{},"理":{"docs":{},"程":{"docs":{},"序":{"docs":{},"将":{"docs":{},"得":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"跳":{"docs":{},"过":{"docs":{},"剩":{"docs":{},"余":{"docs":{},"的":{"docs":{},"重":{"docs":{},"试":{"docs":{},"。":{"docs":{},"此":{"docs":{},"配":{"docs":{},"置":{"docs":{},"仅":{"docs":{},"当":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"未":{"docs":{},"生":{"docs":{},"效":{"docs":{},"时":{"docs":{},"工":{"docs":{},"作":{"docs":{},"。":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"设":{"docs":{},"置":{"docs":{},"或":{"docs":{},"清":{"docs":{},"除":{"docs":{},"i":{"docs":{},"p":{"docs":{},"_":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"套":{"docs":{},"接":{"docs":{},"字":{"docs":{},"选":{"docs":{},"项":{"docs":{},"，":{"docs":{},"设":{"docs":{},"置":{"docs":{},"此":{"docs":{},"选":{"docs":{},"项":{"docs":{},"时":{"docs":{},"，":{"docs":{},"多":{"docs":{},"播":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"也":{"docs":{},"将":{"docs":{},"在":{"docs":{},"本":{"docs":{},"地":{"docs":{},"接":{"docs":{},"口":{"docs":{},"上":{"docs":{},"接":{"docs":{},"收":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"设":{"docs":{},"置":{"docs":{},"i":{"docs":{},"p":{"docs":{},"_":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"_":{"docs":{},"t":{"docs":{},"t":{"docs":{},"l":{"docs":{},"套":{"docs":{},"接":{"docs":{},"字":{"docs":{},"选":{"docs":{},"项":{"docs":{},"。":{"docs":{},"t":{"docs":{},"t":{"docs":{},"l":{"docs":{},"表":{"docs":{},"示":{"docs":{},"“":{"docs":{},"活":{"docs":{},"动":{"docs":{},"时":{"docs":{},"间":{"docs":{},"”":{"docs":{},"，":{"docs":{},"单":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"它":{"docs":{},"指":{"docs":{},"定":{"docs":{},"允":{"docs":{},"许":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"经":{"docs":{},"过":{"docs":{},"的":{"docs":{},"i":{"docs":{},"p":{"docs":{},"跳":{"docs":{},"数":{"docs":{},"，":{"docs":{},"特":{"docs":{},"别":{"docs":{},"是":{"docs":{},"用":{"docs":{},"于":{"docs":{},"多":{"docs":{},"播":{"docs":{},"流":{"docs":{},"量":{"docs":{},"。":{"docs":{},"转":{"docs":{},"发":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"的":{"docs":{},"每":{"docs":{},"个":{"docs":{},"路":{"docs":{},"由":{"docs":{},"器":{"docs":{},"或":{"docs":{},"网":{"docs":{},"管":{"docs":{},"会":{"docs":{},"递":{"docs":{},"减":{"docs":{},"t":{"docs":{},"t":{"docs":{},"l":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"路":{"docs":{},"由":{"docs":{},"器":{"docs":{},"将":{"docs":{},"t":{"docs":{},"t":{"docs":{},"l":{"docs":{},"递":{"docs":{},"减":{"docs":{},"为":{"0":{"docs":{},"，":{"docs":{},"则":{"docs":{},"不":{"docs":{},"会":{"docs":{},"再":{"docs":{},"转":{"docs":{},"发":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"o":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0014862981885740826}}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}},"p":{"docs":{},"f":{"docs":{},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}},"f":{"docs":{},"x":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"f":{"docs":{},"x":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}}}}}}},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"1":{"2":{"3":{"4":{"docs":{},")":{"docs":{},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"、":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"设":{"docs":{},"置":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{},"接":{"docs":{},"收":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"区":{"docs":{},"大":{"docs":{},"小":{"docs":{},"（":{"docs":{},"以":{"docs":{},"字":{"docs":{},"节":{"docs":{},"为":{"docs":{},"单":{"docs":{},"位":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"s":{"docs":{},"(":{"1":{"0":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}},"docs":{}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"a":{"docs":{},"l":{"docs":{},"(":{"5":{"0":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"若":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"则":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"_":{"docs":{},"w":{"docs":{},"a":{"docs":{},"i":{"docs":{},"t":{"docs":{},"状":{"docs":{},"态":{"docs":{},"中":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"在":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"后":{"docs":{},"可":{"docs":{},"重":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"以":{"docs":{},"字":{"docs":{},"节":{"docs":{},"为":{"docs":{},"单":{"docs":{},"位":{"docs":{},"设":{"docs":{},"置":{"docs":{},"发":{"docs":{},"送":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"区":{"docs":{},"的":{"docs":{},"大":{"docs":{},"小":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0026010218300046447}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},")":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"通":{"docs":{},"常":{"docs":{},"被":{"docs":{},"用":{"docs":{},"做":{"docs":{},"结":{"docs":{},"构":{"docs":{},"化":{"docs":{},"数":{"docs":{},"据":{"docs":{},"存":{"docs":{},"储":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"。":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"本":{"docs":{},"组":{"docs":{},"件":{"docs":{},"，":{"docs":{},"您":{"docs":{},"必":{"docs":{},"须":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"运":{"docs":{},"行":{"docs":{},"中":{"docs":{},"的":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"：":{"docs":{},"与":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"设":{"docs":{},"置":{"docs":{},"写":{"docs":{},"入":{"docs":{},"队":{"docs":{},"列":{"docs":{},"被":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}},"又":{"docs":{},"称":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}},"n":{"docs":{},"d":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.006423982869379015},"core/Core.html":{"ref":"core/Core.html","tf":0.0009289363678588017},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.006369426751592357}},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"1":{"docs":{},"'":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"2":{"docs":{},"'":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"3":{"docs":{},"'":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"docs":{}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},"：":{"docs":{},"表":{"docs":{},"示":{"docs":{},"数":{"docs":{},"据":{"docs":{},"报":{"docs":{},"发":{"docs":{},"送":{"docs":{},"方":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"j":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"：":{"docs":{},"发":{"docs":{},"送":{"docs":{},"者":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"表":{"docs":{},"示":{"docs":{},"数":{"docs":{},"据":{"docs":{},"发":{"docs":{},"送":{"docs":{},"方":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"t":{"docs":{},"/":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"/":{"docs":{},"u":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"web/Web.html":{"ref":"web/Web.html","tf":0.0021908471275559884},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}}}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.04851752021563342},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.002742230347349177}},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"k":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"t":{"docs":{},"o":{"docs":{},"b":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}},"l":{"docs":{},"f":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789}}}}}},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.003994426381792847},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"integration/STOMPClient&Server.html":{"ref":"integration/STOMPClient&Server.html","tf":2.7},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.006463527239150508},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.005484460694698354},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},".":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}},"j":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"0":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"1":{"2":{"3":{"4":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}},"docs":{}},"docs":{}},"docs":{}},"8":{"0":{"8":{"0":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{},":":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"8":{"0":{"8":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}},"可":{"docs":{},"配":{"docs":{},"置":{"docs":{},"成":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"：":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"m":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"docs":{}}},"docs":{}}},"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}},"）":{"docs":{},"得":{"docs":{},"到":{"docs":{},"访":{"docs":{},"问":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"；":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"发":{"docs":{},"送":{"docs":{},"过":{"docs":{},"来":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"i":{"docs":{},"c":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":3.368591381366036},"services/Services.html":{"ref":"services/Services.html","tf":10.5},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":5.065420560747664},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":5.022352941176471},"services/SockJSServiceProxies.html":{"ref":"services/SockJSServiceProxies.html","tf":3.583333333333333},"services/MavenServiceFactory.html":{"ref":"services/MavenServiceFactory.html","tf":3.583333333333333},"services/HTTPServiceFactory.html":{"ref":"services/HTTPServiceFactory.html","tf":3.583333333333333},"PLAN.html":{"ref":"PLAN.html","tf":0.016129032258064516}},"e":{"2":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}},"docs":{},":":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},":":{"docs":{},"m":{"docs":{},"y":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"i":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}},".":{"docs":{},"d":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"e":{"docs":{},".":{"docs":{},"l":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"8":{"docs":{},"\"":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"微":{"docs":{},"服":{"docs":{},"务":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"\"":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.007153806847215125}}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.005109862033725089},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}},"那":{"docs":{},"么":{"docs":{},"他":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"描":{"docs":{},"述":{"docs":{},"符":{"docs":{},"文":{"docs":{},"件":{"docs":{},"为":{"docs":{},"：":{"docs":{},"`":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0025549310168625446}}},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0035769034236075624}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0061318344404701075}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"）":{"docs":{},"并":{"docs":{},"且":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0058823529411764705}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"e":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"：":{"docs":{},"可":{"docs":{},"观":{"docs":{},"察":{"docs":{},"序":{"docs":{},"列":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"1":{"docs":{},"p":{"docs":{},"r":{"docs":{},"n":{"docs":{},"g":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"2":{"5":{"6":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"d":{"docs":{},"s":{"docs":{},"a":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}},"docs":{}},"docs":{}},"3":{"8":{"4":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"d":{"docs":{},"s":{"docs":{},"a":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}},"docs":{}},"docs":{}},"5":{"1":{"2":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"d":{"docs":{},"s":{"docs":{},"a":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}},"docs":{}},"docs":{}},"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.02425876010781671}},"d":{"docs":{},"e":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.023391812865497075}}},"o":{"docs":{},"w":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"'":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"r":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"安":{"docs":{},"全":{"docs":{},"机":{"docs":{},"制":{"docs":{},"。":{"docs":{},"该":{"docs":{},"机":{"docs":{},"制":{"docs":{},"允":{"docs":{},"许":{"docs":{},"了":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"域":{"docs":{},"名":{"docs":{},"下":{"docs":{},"访":{"docs":{},"问":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"域":{"docs":{},"名":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"devops/Shell.html":{"ref":"devops/Shell.html","tf":10.5}},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"p":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"y":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"e":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.004705882352941176}},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.006839945280437756}}}}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}},"e":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0058823529411764705}}},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"。":{"docs":{},"参":{"docs":{},"考":{"docs":{},"上":{"docs":{},"述":{"docs":{},"的":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":5.029556650246305}},"/":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{"auth/Auth.html":{"ref":"auth/Auth.html","tf":0.041666666666666664}}}}}}}}}}}}}}},":":{"3":{"docs":{},".":{"2":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}},"docs":{}}},"docs":{}}},"docs":{}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.009852216748768473}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}},"从":{"docs":{},"一":{"docs":{},"个":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"里":{"docs":{},"获":{"docs":{},"取":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}},"的":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.014619883040935672}},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"和":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}},"，":{"docs":{},"在":{"docs":{},"有":{"docs":{},"图":{"docs":{},"形":{"docs":{},"界":{"docs":{},"面":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"中":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"双":{"docs":{},"击":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"用":{"docs":{},"以":{"docs":{},"下":{"docs":{},"命":{"docs":{},"令":{"docs":{},"：":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"'":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"c":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"访":{"docs":{},"问":{"docs":{},"s":{"docs":{},"r":{"docs":{},"v":{"docs":{},"记":{"docs":{},"录":{"docs":{},"本":{"docs":{},"身":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"信":{"docs":{},"息":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},"(":{"docs":{},")":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.005847953216374269},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677},"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"{":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"等":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"：":{"docs":{},"启":{"docs":{},"动":{"docs":{},"泵":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"d":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.010588235294117647}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}},"s":{"docs":{},"）":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}},":":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}},"）":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"状":{"docs":{},"态":{"docs":{},"下":{"docs":{},"，":{"docs":{},"允":{"docs":{},"许":{"docs":{},"下":{"docs":{},"一":{"docs":{},"次":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"的":{"docs":{},"调":{"docs":{},"用":{"docs":{},"实":{"docs":{},"际":{"docs":{},"调":{"docs":{},"用":{"docs":{},"如":{"docs":{},"果":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"将":{"docs":{},"复":{"docs":{},"位":{"docs":{},"并":{"docs":{},"返":{"docs":{},"回":{"docs":{},"到":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"状":{"docs":{},"态":{"docs":{},"，":{"docs":{},"回":{"docs":{},"归":{"docs":{},"正":{"docs":{},"常":{"docs":{},"的":{"docs":{},"模":{"docs":{},"式":{"docs":{},"；":{"docs":{},"但":{"docs":{},"是":{"docs":{},"如":{"docs":{},"果":{"docs":{},"这":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"则":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"返":{"docs":{},"回":{"docs":{},"到":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"状":{"docs":{},"态":{"docs":{},"，":{"docs":{},"直":{"docs":{},"到":{"docs":{},"下":{"docs":{},"次":{"docs":{},"半":{"docs":{},"开":{"docs":{},"状":{"docs":{},"态":{"docs":{},"。":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001672085462145843},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.012104283054003724}},"s":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"y":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}},"c":{"docs":{},"k":{"docs":{"devops/StackManager.html":{"ref":"devops/StackManager.html","tf":5.333333333333333}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},"，":{"docs":{},"就":{"docs":{},"会":{"docs":{},"下":{"docs":{},"载":{"docs":{},"此":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"及":{"docs":{},"它":{"docs":{},"的":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}},"=":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.006423982869379015},"core/Core.html":{"ref":"core/Core.html","tf":0.0025081281932187644},"web/Web.html":{"ref":"web/Web.html","tf":0.0021908471275559884},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.013577732518669382},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.016415868673050615},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.006611570247933884},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0063025210084033615},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.00823529411764706}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"/":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}},"、":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"、":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"是":{"docs":{},"不":{"docs":{},"可":{"docs":{},"变":{"docs":{},"的":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"复":{"docs":{},"制":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}}}}}}},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.006839945280437756},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":5.096590909090909}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"n":{"docs":{},".":{"docs":{},")":{"docs":{},"：":{"docs":{},"可":{"docs":{},"写":{"docs":{},"流":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}},"读":{"docs":{},"流":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}},"：":{"docs":{},"可":{"docs":{},"写":{"docs":{},"流":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"读":{"docs":{},"流":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"s":{"docs":{},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}},"docs":{}}},"docs":{}}},"docs":{}}},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"）":{"docs":{},"，":{"docs":{},"等":{"docs":{},"待":{"docs":{},"下":{"docs":{},"一":{"docs":{},"步":{"docs":{},"的":{"docs":{},"指":{"docs":{},"示":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"，":{"docs":{},"英":{"docs":{},"国":{"docs":{},"父":{"docs":{},"母":{"docs":{},"会":{"docs":{},"在":{"docs":{},"家":{"docs":{},"里":{"docs":{},"选":{"docs":{},"择":{"docs":{},"一":{"docs":{},"个":{"docs":{},"角":{"docs":{},"落":{"docs":{},"作":{"docs":{},"为":{"docs":{},"小":{"docs":{},"孩":{"docs":{},"罚":{"docs":{},"站":{"docs":{},"或":{"docs":{},"静":{"docs":{},"坐":{"docs":{},"的":{"docs":{},"地":{"docs":{},"方":{"docs":{},"，":{"docs":{},"被":{"docs":{},"称":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},".":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}}}}}},"o":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"：":{"docs":{},"停":{"docs":{},"止":{"docs":{},"泵":{"docs":{},"，":{"docs":{},"当":{"docs":{},"泵":{"docs":{},"启":{"docs":{},"动":{"docs":{},"时":{"docs":{},"它":{"docs":{},"要":{"docs":{},"处":{"docs":{},"于":{"docs":{},"停":{"docs":{},"止":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"1":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}},"2":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}},"3":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.007312614259597806}},"：":{"docs":{},"受":{"docs":{},"信":{"docs":{},"存":{"docs":{},"储":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.02425876010781671}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.02425876010781671}}}}}}},"m":{"docs":{},"p":{"docs":{"integration/STOMPClient&Server.html":{"ref":"integration/STOMPClient&Server.html","tf":2.7}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}},"将":{"docs":{},"会":{"docs":{},"使":{"docs":{},"用":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"而":{"docs":{},"非":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"来":{"docs":{},"简":{"docs":{},"化":{"docs":{},"相":{"docs":{},"关":{"docs":{},"设":{"docs":{},"置":{"docs":{},"。":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"集":{"docs":{},"成":{"docs":{},"开":{"docs":{},"发":{"docs":{},"环":{"docs":{},"境":{"docs":{},"来":{"docs":{},"简":{"docs":{},"化":{"docs":{},"开":{"docs":{},"发":{"docs":{},"流":{"docs":{},"程":{"docs":{},"；":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"）":{"docs":{},"可":{"docs":{},"以":{"docs":{},"检":{"docs":{},"查":{"docs":{},"它":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"的":{"docs":{},"失":{"docs":{},"败":{"docs":{},"状":{"docs":{},"态":{"docs":{},"的":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"包":{"docs":{},"含":{"docs":{},"的":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"对":{"docs":{},"象":{"docs":{},"是":{"docs":{},"否":{"docs":{},"为":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"是":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"继":{"docs":{},"续":{"docs":{},"检":{"docs":{},"查":{"docs":{},"内":{"docs":{},"部":{"docs":{},"的":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"错":{"docs":{},"误":{"docs":{},"状":{"docs":{},"态":{"docs":{},"码":{"docs":{},"。":{"docs":{},"调":{"docs":{},"用":{"docs":{},"端":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"些":{"docs":{},"信":{"docs":{},"息":{"docs":{},"来":{"docs":{},"将":{"docs":{},"业":{"docs":{},"务":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"错":{"docs":{},"误":{"docs":{},"与":{"docs":{},"系":{"docs":{},"统":{"docs":{},"错":{"docs":{},"误":{"docs":{},"（":{"docs":{},"如":{"docs":{},"服":{"docs":{},"务":{"docs":{},"没":{"docs":{},"有":{"docs":{},"被":{"docs":{},"注":{"docs":{},"册":{"docs":{},"到":{"docs":{},"e":{"docs":{},"v":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"a":{"docs":{},"l":{"docs":{},"g":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.016172506738544475}}}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00558659217877095},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.00554016620498615}},"e":{"docs":{},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}}}}},"x":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},">":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.002793296089385475}},"，":{"docs":{},"故":{"docs":{},"单":{"docs":{},"个":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"z":{"docs":{},"e":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},":":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}},"t":{"docs":{},"e":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"a":{"docs":{},"l":{"docs":{},":":{"docs":{},"挑":{"docs":{},"选":{"docs":{},"一":{"docs":{},"个":{"docs":{},"本":{"docs":{},"地":{"docs":{},"（":{"docs":{},"非":{"docs":{},"路":{"docs":{},"由":{"docs":{},"）":{"docs":{},"的":{"docs":{},"i":{"docs":{},"p":{"docs":{},"地":{"docs":{},"址":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"从":{"1":{"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},"或":{"1":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},"地":{"docs":{},"址":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"y":{"docs":{},"h":{"docs":{},"负":{"docs":{},"责":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"，":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"z":{"docs":{},"h":{"docs":{},"a":{"docs":{},"o":{"docs":{},"、":{"docs":{},"k":{"docs":{},"k":{"docs":{},"k":{"docs":{},"o":{"docs":{},"k":{"docs":{},"o":{"docs":{},"、":{"docs":{},"g":{"docs":{},"y":{"docs":{},"、":{"docs":{},"h":{"docs":{},"x":{"docs":{},"l":{"docs":{},"、":{"docs":{},"t":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{},"、":{"docs":{},"漓":{"docs":{},"江":{"docs":{},"校":{"docs":{},"对":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.008175779253960144}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}}}}}}},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}},"）":{"docs":{},"等":{"docs":{},"等":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"使":{"docs":{},"用":{"docs":{},"手":{"docs":{},"册":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"u":{"docs":{},"d":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"c":{"docs":{},"k":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},".":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001672085462145843},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.004073319755600814},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.003693444136657433},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}},".":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"\"":{"2":{"3":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"1":{"2":{"3":{"4":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"\"":{"2":{"3":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"\"":{"2":{"3":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"被":{"docs":{},"关":{"docs":{},"闭":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"这":{"docs":{},"边":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"，":{"docs":{},"则":{"docs":{},"不":{"docs":{},"会":{"docs":{},"给":{"docs":{},"我":{"docs":{},"们":{"docs":{},"任":{"docs":{},"何":{"docs":{},"加":{"docs":{},"密":{"docs":{},"的":{"docs":{},"机":{"docs":{},"会":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"：":{"docs":{},"套":{"docs":{},"接":{"docs":{},"字":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"（":{"docs":{},"有":{"docs":{},"些":{"docs":{},"地":{"docs":{},"方":{"docs":{},"未":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"，":{"docs":{},"直":{"docs":{},"接":{"docs":{},"用":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"i":{"docs":{},"d":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}},"p":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"m":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"s":{"docs":{},"，":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}},"（":{"docs":{},"s":{"docs":{},"o":{"docs":{},"_":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"）":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"4":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"5":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}},"docs":{}},"j":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.007059396299902629},"services/SockJSServiceProxies.html":{"ref":"services/SockJSServiceProxies.html","tf":3.583333333333333}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"m":{"docs":{},"y":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.004381694255111977}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"b":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922}}}},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"j":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"b":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"(":{"2":{"0":{"0":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"j":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{},":":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"m":{"docs":{},"e":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},".":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0010218300046446818},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0064794816414686825}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"_":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.02235294117647059}},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"y":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}},".":{"docs":{},"b":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"e":{"docs":{},"b":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"y":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}}}}}}}}},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}},"，":{"docs":{},"则":{"docs":{},"代":{"docs":{},"理":{"docs":{},"名":{"docs":{},"就":{"docs":{},"是":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},"/":{"docs":{},"线":{"docs":{},"程":{"docs":{},"安":{"docs":{},"全":{"docs":{},"的":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"之":{"docs":{},"间":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"是":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"/":{"docs":{},"不":{"docs":{},"可":{"docs":{},"改":{"docs":{},"变":{"docs":{},"的":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.006611570247933884}},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.006398537477148081}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"a":{"docs":{},"k":{"docs":{},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"种":{"docs":{},"可":{"docs":{},"插":{"docs":{},"拔":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{},"后":{"docs":{},"端":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"机":{"docs":{},"制":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"增":{"docs":{},"加":{"docs":{},"对":{"docs":{},"新":{"docs":{},"格":{"docs":{},"式":{"docs":{},"的":{"docs":{},"支":{"docs":{},"持":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"（":{"docs":{},"读":{"docs":{},"取":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"位":{"docs":{},"置":{"docs":{},"）":{"docs":{},"的":{"docs":{},"支":{"docs":{},"持":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.009852216748768473}},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"h":{"docs":{},"i":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"e":{"docs":{},"b":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"n":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407}}}}},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"d":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406}}}}}},"p":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"u":{"docs":{},"l":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"c":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"n":{"docs":{},"d":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0015791918253599629}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}},"i":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"u":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"g":{"docs":{},"o":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.006369426751592357}}}},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}}}}}}},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.002415234556432884},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.012104283054003724},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"m":{"docs":{},"o":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}},"r":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}}}},"e":{"docs":{},"k":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.012104283054003724}}}}}}},"a":{"docs":{},"v":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}},"p":{"docs":{},"t":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"l":{"docs":{},"d":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612}},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"i":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}},"t":{"docs":{},"l":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}},"o":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"p":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}},"u":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.025}}},"p":{"docs":{},"d":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"o":{"docs":{},".":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"=":{"docs":{},"\"":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"2":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}},"docs":{},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.008565310492505354}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}}}}},"i":{"docs":{},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"h":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0009289363678588017}}}}}}}},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"p":{"docs":{},".":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"o":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}},"w":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"v":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{},"$":{"docs":{},"(":{"docs":{},"o":{"docs":{},"c":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"n":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":5.031847133757962}},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}},".":{"docs":{},"a":{"docs":{},"w":{"docs":{},"a":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"v":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}},"l":{"docs":{},"a":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.008310249307479225}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}}}},"。":{"docs":{},"r":{"docs":{},"x":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"1":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"2":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"docs":{}}}}}}}}}}}}},"k":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"f":{"4":{"docs":{},"j":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}},"启":{"docs":{},"动":{"docs":{},"警":{"docs":{},"告":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"。":{"docs":{},"详":{"docs":{},"见":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"docs":{}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"s":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"/":{"docs":{},"t":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"s":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"，":{"docs":{},"该":{"docs":{},"值":{"docs":{},"设":{"docs":{},"置":{"docs":{},"成":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"将":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"/":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"将":{"docs":{},"启":{"docs":{},"用":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"/":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"，":{"docs":{},"实":{"docs":{},"际":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"/":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"（":{"docs":{},"如":{"docs":{},"受":{"docs":{},"信":{"docs":{},"、":{"docs":{},"密":{"docs":{},"钥":{"docs":{},"/":{"docs":{},"证":{"docs":{},"书":{"docs":{},"、":{"docs":{},"密":{"docs":{},"码":{"docs":{},"、":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"每":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"引":{"docs":{},"擎":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"q":{"docs":{},"l":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":5.019151846785226},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.007352941176470588},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.007462686567164179}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.004103967168262654}},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"传":{"docs":{},"给":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"时":{"docs":{},"，":{"docs":{},"不":{"docs":{},"会":{"docs":{},"经":{"docs":{},"过":{"docs":{},"任":{"docs":{},"何":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{},"操":{"docs":{},"作":{"docs":{},"结":{"docs":{},"束":{"docs":{},"时":{"docs":{},"将":{"docs":{},"调":{"docs":{},"用":{"docs":{},"回":{"docs":{},"调":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.01282051282051282},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"）":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"读":{"docs":{},"取":{"docs":{},"响":{"docs":{},"应":{"docs":{},"尾":{"docs":{},"，":{"docs":{},"尾":{"docs":{},"数":{"docs":{},"据":{"docs":{},"也":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}},"u":{"docs":{},"e":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0027155465037338763},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}},"则":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"将":{"docs":{},"信":{"docs":{},"任":{"docs":{},"所":{"docs":{},"有":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"证":{"docs":{},"书":{"docs":{},"。":{"docs":{},"连":{"docs":{},"接":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"会":{"docs":{},"被":{"docs":{},"加":{"docs":{},"密":{"docs":{},"，":{"docs":{},"但":{"docs":{},"这":{"docs":{},"种":{"docs":{},"模":{"docs":{},"式":{"docs":{},"很":{"docs":{},"容":{"docs":{},"易":{"docs":{},"受":{"docs":{},"到":{"docs":{},"中":{"docs":{},"间":{"docs":{},"人":{"docs":{},"攻":{"docs":{},"击":{"docs":{},"。":{"docs":{},"即":{"docs":{},"您":{"docs":{},"无":{"docs":{},"法":{"docs":{},"确":{"docs":{},"定":{"docs":{},"您":{"docs":{},"正":{"docs":{},"连":{"docs":{},"接":{"docs":{},"到":{"docs":{},"谁":{"docs":{},"，":{"docs":{},"请":{"docs":{},"谨":{"docs":{},"慎":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"没":{"docs":{},"有":{"docs":{},"查":{"docs":{},"询":{"docs":{},"到":{"docs":{},"要":{"docs":{},"更":{"docs":{},"新":{"docs":{},"的":{"docs":{},"文":{"docs":{},"档":{"docs":{},"时":{"docs":{},"，":{"docs":{},"新":{"docs":{},"增":{"docs":{},"该":{"docs":{},"文":{"docs":{},"档":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}},"更":{"docs":{},"新":{"docs":{},"多":{"docs":{},"个":{"docs":{},"文":{"docs":{},"档":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"让":{"docs":{},"解":{"docs":{},"析":{"docs":{},"器":{"docs":{},"使":{"docs":{},"用":{"docs":{},"轮":{"docs":{},"询":{"docs":{},"选":{"docs":{},"择":{"docs":{},"。":{"docs":{},"它":{"docs":{},"会":{"docs":{},"在":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"之":{"docs":{},"间":{"docs":{},"传":{"docs":{},"播":{"docs":{},"查":{"docs":{},"询":{"docs":{},"负":{"docs":{},"载":{"docs":{},"，":{"docs":{},"并":{"docs":{},"避":{"docs":{},"免":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"查":{"docs":{},"找":{"docs":{},"都":{"docs":{},"找":{"docs":{},"到":{"docs":{},"列":{"docs":{},"表":{"docs":{},"中":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"您":{"docs":{},"的":{"docs":{},"每":{"docs":{},"个":{"docs":{},"操":{"docs":{},"作":{"docs":{},"都":{"docs":{},"将":{"docs":{},"在":{"docs":{},"单":{"docs":{},"独":{"docs":{},"的":{"docs":{},"事":{"docs":{},"务":{"docs":{},"中":{"docs":{},"有":{"docs":{},"效":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}},"完":{"docs":{},"成":{"docs":{},"后":{"docs":{},"，":{"docs":{},"执":{"docs":{},"行":{"docs":{},"命":{"docs":{},"令":{"docs":{},"：":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}},"）":{"docs":{},"。":{"docs":{},"此":{"docs":{},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"决":{"docs":{},"定":{"docs":{},"是":{"docs":{},"否":{"docs":{},"在":{"docs":{},"初":{"docs":{},"次":{"docs":{},"获":{"docs":{},"取":{"docs":{},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{},"时":{"docs":{},"对":{"docs":{},"其":{"docs":{},"进":{"docs":{},"行":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"在":{"docs":{},"后":{"docs":{},"面":{"docs":{},"不":{"docs":{},"会":{"docs":{},"重":{"docs":{},"新":{"docs":{},"加":{"docs":{},"载":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"a":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413}}}}}}}}}}}},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"@":{"1":{"6":{"3":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"，":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{},"y":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"x":{"docs":{},"i":{"docs":{},"a":{"docs":{},"@":{"docs":{},"q":{"docs":{},"q":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"负":{"docs":{},"责":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"和":{"docs":{},"校":{"docs":{},"对":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"testing/Testing.html":{"ref":"testing/Testing.html","tf":10.5},"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}}}}}}},"d":{"docs":{},"b":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},".":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"x":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"/":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922}},";":{"docs":{},"q":{"docs":{},"=":{"0":{"docs":{},".":{"8":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"docs":{}}},"docs":{}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"这":{"docs":{},"也":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"，":{"docs":{},"但":{"docs":{},"会":{"docs":{},"更":{"docs":{},"倾":{"docs":{},"向":{"docs":{},"于":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"因":{"docs":{},"为":{"docs":{},"其":{"docs":{},"具":{"docs":{},"有":{"docs":{},"更":{"docs":{},"高":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"它":{"docs":{},"需":{"docs":{},"要":{"docs":{},"提":{"docs":{},"供":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243}},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922}},"a":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"根":{"docs":{},"据":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"：":{"docs":{},"这":{"docs":{},"是":{"docs":{},"用":{"docs":{},"来":{"docs":{},"决":{"docs":{},"定":{"docs":{},"实":{"docs":{},"际":{"docs":{},"的":{"docs":{},"查":{"docs":{},"找":{"docs":{},"使":{"docs":{},"用":{"docs":{},"当":{"docs":{},"通":{"docs":{},"过":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"i":{"docs":{},"d":{"docs":{},"来":{"docs":{},"查":{"docs":{},"找":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"户":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"是":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"docs":{},"{":{"0":{"docs":{},"}":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"=":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},",":{"docs":{},"d":{"docs":{},"c":{"docs":{},"=":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"d":{"docs":{},"c":{"docs":{},"=":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0024342745861733205},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.004087889626980072}},"\"":{"docs":{},",":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"core/Core.html":{"ref":"core/Core.html","tf":0.0009289363678588017},"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.002793296089385475}}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"=":{"docs":{},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"和":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"可":{"docs":{},"以":{"docs":{},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"将":{"docs":{},"转":{"docs":{},"换":{"docs":{},"为":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243}}},"s":{"docs":{},"）":{"docs":{},"的":{"docs":{},"路":{"docs":{},"由":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"：":{"docs":{},"互":{"docs":{},"联":{"docs":{},"网":{"docs":{},"媒":{"docs":{},"体":{"docs":{},"类":{"docs":{},"型":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"很":{"docs":{},"容":{"docs":{},"易":{"docs":{},"地":{"docs":{},"使":{"docs":{},"用":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"提":{"docs":{},"供":{"docs":{},"不":{"docs":{},"同":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},":":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}}}}}}},"/":{"docs":{},"m":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"s":{"docs":{},"k":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"b":{"docs":{},"l":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}}}},"h":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"n":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215}},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"e":{"docs":{},"d":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"：":{"docs":{},"内":{"docs":{},"核":{"docs":{},"线":{"docs":{},"程":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}},"o":{"docs":{},"w":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}},"i":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"e":{"docs":{},"s":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}},"y":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"f":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}},"：":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},":":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0014862981885740826},"eventbusbridge/TCPEventbusBridge.html":{"ref":"eventbusbridge/TCPEventbusBridge.html","tf":3.583333333333333},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.009852216748768473}},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}}}}}},"s":{"3":{"docs":{},"i":{"docs":{},"p":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}},"docs":{}},"v":{"docs":{},"m":{"docs":{},"i":{"docs":{},"p":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}},"m":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},":":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}},"）":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}},"r":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}},"i":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"：":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"定":{"docs":{},"时":{"docs":{},"器":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},")":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"=":{"docs":{},"\"":{"docs":{},"+":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"+":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"=":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"s":{"docs":{},"v":{"1":{"docs":{},".":{"2":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}},"docs":{}},"（":{"docs":{},"传":{"docs":{},"输":{"docs":{},"层":{"docs":{},"安":{"docs":{},"全":{"docs":{},"性":{"docs":{},"协":{"docs":{},"议":{"docs":{},"）":{"docs":{},"。":{"docs":{},"早":{"docs":{},"期":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"被":{"docs":{},"称":{"docs":{},"为":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"o":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}},"展":{"docs":{},"示":{"docs":{},"了":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"w":{"docs":{},"t":{"docs":{},"的":{"docs":{},"验":{"docs":{},"证":{"docs":{},"和":{"docs":{},"授":{"docs":{},"权":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"并":{"docs":{},"解":{"docs":{},"释":{"docs":{},"了":{"docs":{},"如":{"docs":{},"何":{"docs":{},"通":{"docs":{},"过":{"docs":{},"传":{"docs":{},"入":{"docs":{},"到":{"docs":{},"授":{"docs":{},"权":{"docs":{},"的":{"docs":{},"许":{"docs":{},"可":{"docs":{},"字":{"docs":{},"符":{"docs":{},"映":{"docs":{},"射":{"docs":{},"到":{"docs":{},"j":{"docs":{},"w":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"中":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"。":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.021487603305785124}},"或":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"还":{"docs":{},"会":{"docs":{},"在":{"docs":{},"认":{"docs":{},"证":{"docs":{},"信":{"docs":{},"息":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"的":{"docs":{},"认":{"docs":{},"证":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{},"过":{"docs":{},"程":{"docs":{},"中":{"docs":{},"，":{"docs":{},"认":{"docs":{},"证":{"docs":{},"结":{"docs":{},"果":{"docs":{},"被":{"docs":{},"传":{"docs":{},"给":{"docs":{},"结":{"docs":{},"果":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"中":{"docs":{},"的":{"docs":{},"用":{"docs":{},"户":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"对":{"docs":{},"象":{"docs":{},"里":{"docs":{},"，":{"docs":{},"异":{"docs":{},"步":{"docs":{},"调":{"docs":{},"用":{"docs":{},"结":{"docs":{},"果":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"户":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"表":{"docs":{},"述":{"docs":{},"了":{"docs":{},"已":{"docs":{},"经":{"docs":{},"认":{"docs":{},"证":{"docs":{},"过":{"docs":{},"的":{"docs":{},"用":{"docs":{},"户":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"这":{"docs":{},"些":{"docs":{},"用":{"docs":{},"户":{"docs":{},"允":{"docs":{},"许":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"合":{"docs":{},"法":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}},"令":{"docs":{},"牌":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}}}}},"s":{"docs":{},"实":{"docs":{},"现":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"。":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"r":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}},"v":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}}}}}}}},"】":{"docs":{},"）":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}},"）":{"docs":{},"和":{"docs":{},"刷":{"docs":{},"新":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}},"，":{"docs":{},"对":{"docs":{},"安":{"docs":{},"全":{"docs":{},"性":{"docs":{},"要":{"docs":{},"求":{"docs":{},"高":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"/":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"/":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"k":{"docs":{},"u":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"中":{"docs":{},"的":{"docs":{},"内":{"docs":{},"容":{"docs":{},"）":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{},"，":{"docs":{},"参":{"docs":{},"数":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.003693444136657433}}},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}},"l":{"docs":{},"k":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407}},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0033944331296673455}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.015904572564612324}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},"+":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}}}}},"=":{"docs":{},"\"":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"+":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},"+":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{},"+":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.013253810470510271}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406}}}},"+":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"1":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}},"2":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}},"3":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}},"docs":{}}}}}}}}}}}}},"、":{"docs":{},"目":{"docs":{},"的":{"docs":{},"分":{"docs":{},"区":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}},"e":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"可":{"docs":{},"以":{"docs":{},"启":{"docs":{},"用":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"o":{"docs":{},"，":{"docs":{},"校":{"docs":{},"对":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}},"、":{"docs":{},"宋":{"docs":{},"子":{"docs":{},"豪":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}},"v":{"3":{"docs":{},"）":{"docs":{},"中":{"docs":{},"导":{"docs":{},"入":{"docs":{},"服":{"docs":{},"务":{"docs":{},"到":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"组":{"docs":{},"件":{"docs":{},"中":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}},".":{"docs":{},"x":{"docs":{"./":{"ref":"./","tf":0.05128205128205128},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.006423982869379015},"core/Core.html":{"ref":"core/Core.html","tf":0.010868555503947979},"web/Web.html":{"ref":"web/Web.html","tf":0.016066212268743916},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.0037243947858473},"data/Data.html":{"ref":"data/Data.html","tf":0.3333333333333333},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0047522063815342835},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.07107843137254902},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.006839945280437756},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.023758099352051837},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.02736318407960199},"integration/Integration.html":{"ref":"integration/Integration.html","tf":0.5},"integration/MailClient.html":{"ref":"integration/MailClient.html","tf":0.3333333333333333},"integration/STOMPClient&Server.html":{"ref":"integration/STOMPClient&Server.html","tf":0.2},"integration/JCAAdaptor.html":{"ref":"integration/JCAAdaptor.html","tf":0.3333333333333333},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0066269052352551355},"eventbusbridge/CamelBridge.html":{"ref":"eventbusbridge/CamelBridge.html","tf":0.3333333333333333},"eventbusbridge/TCPEventbusBridge.html":{"ref":"eventbusbridge/TCPEventbusBridge.html","tf":0.25},"auth/Auth.html":{"ref":"auth/Auth.html","tf":0.041666666666666664},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.016666666666666666},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942},"reactive/Reactive.html":{"ref":"reactive/Reactive.html","tf":0.5},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":5.022160664819944},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.0625},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":5.038216560509555},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":3.3363992505535682},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":3.352240896358543},"microservices/Config.html":{"ref":"microservices/Config.html","tf":5.012797074954296},"devops/Devops.html":{"ref":"devops/Devops.html","tf":0.5},"devops/MetricsUsingDropwizard.html":{"ref":"devops/MetricsUsingDropwizard.html","tf":0.25},"devops/MetricsUsingHawkular.html":{"ref":"devops/MetricsUsingHawkular.html","tf":0.25},"devops/Shell.html":{"ref":"devops/Shell.html","tf":0.5},"devops/Docker.html":{"ref":"devops/Docker.html","tf":0.5},"devops/StackManager.html":{"ref":"devops/StackManager.html","tf":0.3333333333333333},"testing/Testing.html":{"ref":"testing/Testing.html","tf":0.5},"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.14705882352941177},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.036468330134357005},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.022587268993839837},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.03676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.026239067055393587},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.014778325123152709},"services/Services.html":{"ref":"services/Services.html","tf":0.5},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.028037383177570093},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294},"services/SockJSServiceProxies.html":{"ref":"services/SockJSServiceProxies.html","tf":0.25},"services/MavenServiceFactory.html":{"ref":"services/MavenServiceFactory.html","tf":0.25},"services/HTTPServiceFactory.html":{"ref":"services/HTTPServiceFactory.html","tf":0.25},"cloud/Cloud.html":{"ref":"cloud/Cloud.html","tf":0.5},"cloud/OpenShiftCartridge.html":{"ref":"cloud/OpenShiftCartridge.html","tf":0.3333333333333333},"cloud/OpenShiftUsingDIYCartridge.html":{"ref":"cloud/OpenShiftUsingDIYCartridge.html","tf":0.2},"PLAN.html":{"ref":"PLAN.html","tf":0.20967741935483872}},"中":{"docs":{},"国":{"docs":{},"用":{"docs":{},"户":{"docs":{},"社":{"docs":{},"区":{"docs":{},"默":{"docs":{},"认":{"docs":{},"获":{"docs":{},"得":{"docs":{},"所":{"docs":{},"有":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"内":{"docs":{},"容":{"docs":{},"的":{"docs":{},"发":{"docs":{},"布":{"docs":{},"权":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"它":{"docs":{},"针":{"docs":{},"对":{"docs":{},"任":{"docs":{},"何":{"docs":{},"兼":{"docs":{},"容":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"的":{"docs":{},"关":{"docs":{},"系":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"执":{"docs":{},"行":{"docs":{},"认":{"docs":{},"证":{"docs":{},"和":{"docs":{},"授":{"docs":{},"权":{"docs":{},"。":{"docs":{},"若":{"docs":{},"要":{"docs":{},"在":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"项":{"docs":{},"目":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"，":{"docs":{},"则":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"构":{"docs":{},"建":{"docs":{},"描":{"docs":{},"述":{"docs":{},"信":{"docs":{},"息":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"节":{"docs":{},"点":{"docs":{},"中":{"docs":{},"添":{"docs":{},"加":{"docs":{},"如":{"docs":{},"下":{"docs":{},"信":{"docs":{},"息":{"docs":{},"：":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"让":{"docs":{},"你":{"docs":{},"使":{"docs":{},"用":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"针":{"docs":{},"对":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"执":{"docs":{},"行":{"docs":{},"认":{"docs":{},"证":{"docs":{},"和":{"docs":{},"授":{"docs":{},"权":{"docs":{},"。":{"docs":{},"若":{"docs":{},"要":{"docs":{},"在":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"项":{"docs":{},"目":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"，":{"docs":{},"则":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"构":{"docs":{},"建":{"docs":{},"描":{"docs":{},"述":{"docs":{},"信":{"docs":{},"息":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"节":{"docs":{},"点":{"docs":{},"中":{"docs":{},"添":{"docs":{},"加":{"docs":{},"如":{"docs":{},"下":{"docs":{},"信":{"docs":{},"息":{"docs":{},"：":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"角":{"docs":{},"色":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"值":{"docs":{},"可":{"docs":{},"通":{"docs":{},"过":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"进":{"docs":{},"行":{"docs":{},"更":{"docs":{},"改":{"docs":{},"。":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{},"支":{"docs":{},"持":{"docs":{},"下":{"docs":{},"边":{"docs":{},"三":{"docs":{},"种":{"docs":{},"流":{"docs":{},"程":{"docs":{},"：":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}},"docs":{}}}}}}}},"的":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"内":{"docs":{},"部":{"docs":{},"是":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"/":{"docs":{},"原":{"docs":{},"子":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"内":{"docs":{},"部":{"docs":{},"是":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"工":{"docs":{},"作":{"docs":{},"方":{"docs":{},"式":{"docs":{},"有":{"docs":{},"所":{"docs":{},"不":{"docs":{},"同":{"docs":{},"。":{"docs":{},"每":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"标":{"docs":{},"准":{"docs":{},"配":{"docs":{},"置":{"docs":{},"（":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"组":{"docs":{},"件":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"标":{"docs":{},"准":{"docs":{},"的":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"若":{"docs":{},"要":{"docs":{},"在":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"项":{"docs":{},"目":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"，":{"docs":{},"则":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"构":{"docs":{},"建":{"docs":{},"描":{"docs":{},"述":{"docs":{},"信":{"docs":{},"息":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"节":{"docs":{},"点":{"docs":{},"中":{"docs":{},"添":{"docs":{},"加":{"docs":{},"如":{"docs":{},"下":{"docs":{},"信":{"docs":{},"息":{"docs":{},"：":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},"线":{"docs":{},"程":{"docs":{},"模":{"docs":{},"型":{"docs":{},"保":{"docs":{},"证":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"内":{"docs":{},"部":{"docs":{},"代":{"docs":{},"码":{"docs":{},"线":{"docs":{},"程":{"docs":{},"安":{"docs":{},"全":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"要":{"docs":{},"求":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"之":{"docs":{},"间":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"是":{"docs":{},"不":{"docs":{},"可":{"docs":{},"变":{"docs":{},"的":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"此":{"docs":{},"方":{"docs":{},"法":{"docs":{},"保":{"docs":{},"证":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"之":{"docs":{},"间":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"也":{"docs":{},"是":{"docs":{},"线":{"docs":{},"程":{"docs":{},"安":{"docs":{},"全":{"docs":{},"的":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"进":{"docs":{},"一":{"docs":{},"步":{"docs":{},"保":{"docs":{},"证":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"内":{"docs":{},"部":{"docs":{},"整":{"docs":{},"体":{"docs":{},"是":{"docs":{},"线":{"docs":{},"程":{"docs":{},"安":{"docs":{},"全":{"docs":{},"的":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"将":{"docs":{},"开":{"docs":{},"发":{"docs":{},"人":{"docs":{},"员":{"docs":{},"从":{"docs":{},"繁":{"docs":{},"琐":{"docs":{},"的":{"docs":{},"，":{"docs":{},"容":{"docs":{},"易":{"docs":{},"错":{"docs":{},"的":{"docs":{},"各":{"docs":{},"种":{"docs":{},"多":{"docs":{},"线":{"docs":{},"程":{"docs":{},"并":{"docs":{},"发":{"docs":{},"问":{"docs":{},"题":{"docs":{},"中":{"docs":{},"解":{"docs":{},"脱":{"docs":{},"出":{"docs":{},"来":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"会":{"docs":{},"尽":{"docs":{},"它":{"docs":{},"最":{"docs":{},"大":{"docs":{},"努":{"docs":{},"力":{"docs":{},"去":{"docs":{},"传":{"docs":{},"递":{"docs":{},"消":{"docs":{},"息":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"不":{"docs":{},"会":{"docs":{},"主":{"docs":{},"动":{"docs":{},"丢":{"docs":{},"弃":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"称":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"内":{"docs":{},"置":{"docs":{},"的":{"docs":{},"日":{"docs":{},"志":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"进":{"docs":{},"行":{"docs":{},"记":{"docs":{},"录":{"docs":{},"日":{"docs":{},"志":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"实":{"docs":{},"现":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"d":{"docs":{},"k":{"docs":{},"（":{"docs":{},"j":{"docs":{},"u":{"docs":{},"l":{"docs":{},"）":{"docs":{},"日":{"docs":{},"志":{"docs":{},"，":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"额":{"docs":{},"外":{"docs":{},"的":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"项":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"地":{"docs":{},"址":{"docs":{},"解":{"docs":{},"析":{"docs":{},"器":{"docs":{},"将":{"docs":{},"主":{"docs":{},"机":{"docs":{},"名":{"docs":{},"解":{"docs":{},"析":{"docs":{},"为":{"docs":{},"i":{"docs":{},"p":{"docs":{},"地":{"docs":{},"址":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"内":{"docs":{},"置":{"docs":{},"的":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"解":{"docs":{},"析":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"很":{"docs":{},"容":{"docs":{},"易":{"docs":{},"编":{"docs":{},"写":{"docs":{},"非":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"的":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"支":{"docs":{},"持":{"docs":{},"高":{"docs":{},"可":{"docs":{},"用":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"，":{"docs":{},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"行":{"docs":{},"版":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"轻":{"docs":{},"松":{"docs":{},"被":{"docs":{},"替":{"docs":{},"换":{"docs":{},"成":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"可":{"docs":{},"替":{"docs":{},"换":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"这":{"docs":{},"里":{"docs":{},"有":{"docs":{},"一":{"docs":{},"点":{"docs":{},"魔":{"docs":{},"法":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"将":{"docs":{},"按":{"docs":{},"照":{"docs":{},"特":{"docs":{},"定":{"docs":{},"发":{"docs":{},"送":{"docs":{},"者":{"docs":{},"发":{"docs":{},"送":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"来":{"docs":{},"传":{"docs":{},"递":{"docs":{},"消":{"docs":{},"息":{"docs":{},"给":{"docs":{},"特":{"docs":{},"定":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"异":{"docs":{},"步":{"docs":{},"文":{"docs":{},"件":{"docs":{},"访":{"docs":{},"问":{"docs":{},"的":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"，":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"操":{"docs":{},"作":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"上":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"户":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"实":{"docs":{},"现":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"创":{"docs":{},"建":{"docs":{},"这":{"docs":{},"个":{"docs":{},"类":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"对":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"用":{"docs":{},"户":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"对":{"docs":{},"象":{"docs":{},"提":{"docs":{},"供":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"实":{"docs":{},"现":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"你":{"docs":{},"在":{"docs":{},"实":{"docs":{},"现":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"自":{"docs":{},"己":{"docs":{},"处":{"docs":{},"理":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"问":{"docs":{},"题":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"有":{"docs":{},"多":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"于":{"docs":{},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{},"读":{"docs":{},"取":{"docs":{},"和":{"docs":{},"写":{"docs":{},"入":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"本":{"docs":{},"身":{"docs":{},"只":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"库":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"使":{"docs":{},"用":{"docs":{},"任":{"docs":{},"何":{"docs":{},"日":{"docs":{},"志":{"docs":{},"库":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"来":{"docs":{},"记":{"docs":{},"录":{"docs":{},"日":{"docs":{},"志":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"还":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"种":{"docs":{},"更":{"docs":{},"方":{"docs":{},"便":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"指":{"docs":{},"定":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"无":{"docs":{},"需":{"docs":{},"设":{"docs":{},"置":{"docs":{},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"您":{"docs":{},"只":{"docs":{},"需":{"docs":{},"在":{"docs":{},"您":{"docs":{},"的":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{},"提":{"docs":{},"供":{"docs":{},"名":{"docs":{},"为":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"而":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"对":{"docs":{},"应":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}},"为":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"认":{"docs":{},"证":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"。":{"docs":{},"我":{"docs":{},"们":{"docs":{},"还":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"开":{"docs":{},"箱":{"docs":{},"即":{"docs":{},"用":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{"auth/Auth.html":{"ref":"auth/Auth.html","tf":0.041666666666666664}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"实":{"docs":{},"现":{"docs":{},"中":{"docs":{},"的":{"docs":{},"密":{"docs":{},"码":{"docs":{},"在":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"框":{"docs":{},"架":{"docs":{},"还":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"现":{"docs":{},"成":{"docs":{},"的":{"docs":{},"后":{"docs":{},"端":{"docs":{},"存":{"docs":{},"储":{"docs":{},"机":{"docs":{},"制":{"docs":{},"支":{"docs":{},"持":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"接":{"docs":{},"口":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"一":{"docs":{},"个":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.006423982869379015},"core/Core.html":{"ref":"core/Core.html","tf":0.010496980956804458},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0027155465037338763},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0196078431372549},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.012437810945273632},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.003976143141153081},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"e":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"最":{"docs":{},"后":{"docs":{},"修":{"docs":{},"改":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"为":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"修":{"docs":{},"改":{"docs":{},"后":{"docs":{},"的":{"docs":{},"p":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"象":{"docs":{},"则":{"docs":{},"会":{"docs":{},"被":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"线":{"docs":{},"程":{"docs":{},"所":{"docs":{},"共":{"docs":{},"享":{"docs":{},"，":{"docs":{},"会":{"docs":{},"依":{"docs":{},"次":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"访":{"docs":{},"问":{"docs":{},"，":{"docs":{},"但":{"docs":{},"不":{"docs":{},"会":{"docs":{},"并":{"docs":{},"发":{"docs":{},"同":{"docs":{},"时":{"docs":{},"访":{"docs":{},"问":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},":":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"对":{"docs":{},"应":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"的":{"docs":{},"自":{"docs":{},"动":{"docs":{},"清":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"调":{"docs":{},"用":{"docs":{},"：":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}},"则":{"docs":{},"没":{"docs":{},"有":{"docs":{},"此":{"docs":{},"限":{"docs":{},"制":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"开":{"docs":{},"发":{"docs":{},"者":{"docs":{},"手":{"docs":{},"工":{"docs":{},"处":{"docs":{},"理":{"docs":{},"并":{"docs":{},"发":{"docs":{},"冲":{"docs":{},"突":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"并":{"docs":{},"不":{"docs":{},"推":{"docs":{},"荐":{"docs":{},"这":{"docs":{},"类":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"内":{"docs":{},"部":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"都":{"docs":{},"只":{"docs":{},"会":{"docs":{},"由":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"线":{"docs":{},"程":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"由":{"docs":{},"此":{"docs":{},"保":{"docs":{},"证":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"内":{"docs":{},"部":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"安":{"docs":{},"全":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"放":{"docs":{},"心":{"docs":{},"地":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"内":{"docs":{},"部":{"docs":{},"声":{"docs":{},"明":{"docs":{},"各":{"docs":{},"种":{"docs":{},"线":{"docs":{},"程":{"docs":{},"不":{"docs":{},"安":{"docs":{},"全":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"分":{"docs":{},"享":{"docs":{},"他":{"docs":{},"们":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"内":{"docs":{},"部":{"docs":{},"环":{"docs":{},"境":{"docs":{},"全":{"docs":{},"部":{"docs":{},"都":{"docs":{},"是":{"docs":{},"线":{"docs":{},"程":{"docs":{},"安":{"docs":{},"全":{"docs":{},"的":{"docs":{},"，":{"docs":{},"不":{"docs":{},"会":{"docs":{},"出":{"docs":{},"现":{"docs":{},"多":{"docs":{},"个":{"docs":{},"线":{"docs":{},"程":{"docs":{},"同":{"docs":{},"时":{"docs":{},"访":{"docs":{},"问":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"内":{"docs":{},"部":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"非":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}},"也":{"docs":{},"可":{"docs":{},"用":{"docs":{},"于":{"docs":{},"其":{"docs":{},"他":{"docs":{},"目":{"docs":{},"的":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"加":{"docs":{},"载":{"docs":{},"服":{"docs":{},"务":{"docs":{},"、":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"从":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"中":{"docs":{},"获":{"docs":{},"取":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"等":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"仅":{"docs":{},"需":{"docs":{},"要":{"docs":{},"追":{"docs":{},"加":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"以":{"docs":{},"下":{"docs":{},"是":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"命":{"docs":{},"令":{"docs":{},"的":{"docs":{},"几":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"但":{"docs":{},"是":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"由":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"同":{"docs":{},"时":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"并":{"docs":{},"让":{"docs":{},"它":{"docs":{},"们":{"docs":{},"彼":{"docs":{},"此":{"docs":{},"在":{"docs":{},"网":{"docs":{},"络":{"docs":{},"上":{"docs":{},"的":{"docs":{},"其":{"docs":{},"他":{"docs":{},"任":{"docs":{},"何":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"集":{"docs":{},"群":{"docs":{},"在":{"docs":{},"一":{"docs":{},"起":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"当":{"docs":{},"父":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"在":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"其":{"docs":{},"部":{"docs":{},"署":{"docs":{},"方":{"docs":{},"法":{"docs":{},"和":{"docs":{},"其":{"docs":{},"他":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"j":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001114723641430562}},"a":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"s":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}},"）":{"docs":{},"时":{"docs":{},"，":{"docs":{},"迁":{"docs":{},"移":{"docs":{},"才":{"docs":{},"是":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"现":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"r":{"docs":{},"b":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"需":{"docs":{},"要":{"docs":{},"你":{"docs":{},"的":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"中":{"docs":{},"确":{"docs":{},"保":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215}},"为":{"docs":{},"此":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"下":{"docs":{},"载":{"docs":{},"并":{"docs":{},"安":{"docs":{},"装":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"启":{"docs":{},"用":{"docs":{},"高":{"docs":{},"可":{"docs":{},"用":{"docs":{},"方":{"docs":{},"式":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"）":{"docs":{},"部":{"docs":{},"署":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"下":{"docs":{},"，":{"docs":{},"当":{"docs":{},"其":{"docs":{},"中":{"docs":{},"一":{"docs":{},"个":{"docs":{},"部":{"docs":{},"署":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"名":{"docs":{},"称":{"docs":{},"到":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"映":{"docs":{},"射":{"docs":{},"规":{"docs":{},"则":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"并":{"docs":{},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"些":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"要":{"docs":{},"运":{"docs":{},"行":{"docs":{},"的":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"撤":{"docs":{},"销":{"docs":{},"时":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"实":{"docs":{},"例":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"部":{"docs":{},"署":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"部":{"docs":{},"署":{"docs":{},"时":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"模":{"docs":{},"型":{"docs":{},"，":{"docs":{},"避":{"docs":{},"免":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"（":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"完":{"docs":{},"全":{"docs":{},"限":{"docs":{},"定":{"docs":{},"类":{"docs":{},"名":{"docs":{},"或":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"文":{"docs":{},"件":{"docs":{},"名":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"这":{"docs":{},"是":{"docs":{},"最":{"docs":{},"常":{"docs":{},"用":{"docs":{},"的":{"docs":{},"一":{"docs":{},"类":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"类":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"工":{"docs":{},"厂":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"动":{"docs":{},"态":{"docs":{},"的":{"docs":{},"从":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"中":{"docs":{},"加":{"docs":{},"载":{"docs":{},"服":{"docs":{},"务":{"docs":{},"：":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.03216374269005848},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"core/Core.html":{"ref":"core/Core.html","tf":0.008824895494658615},"web/Web.html":{"ref":"web/Web.html","tf":0.0021908471275559884},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.007462686567164179},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.003693444136657433},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.009554140127388535},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0025549310168625446},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.013711151736745886},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.02495201535508637},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.024640657084188913},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.03308823529411765},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.029154518950437316},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.029556650246305417},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.018691588785046728},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.004705882352941176}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"8":{"0":{"8":{"0":{"docs":{},",":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.008403361344537815}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"1":{"docs":{},"s":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"8":{"0":{"8":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"2":{"docs":{},"n":{"docs":{},"d":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"8":{"0":{"8":{"1":{"docs":{},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.006423982869379015}},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"2":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"docs":{}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"5":{"3":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0013005109150023223}}}},"docs":{}},"docs":{}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0019507663725034836}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0014862981885740826}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"=":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"c":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.005847953216374269},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}}},",":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},".":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"m":{"docs":{},"y":{"docs":{},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"r":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"e":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"自":{"docs":{},"己":{"docs":{},"配":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{},"（":{"docs":{},"查":{"docs":{},"看":{"docs":{},"服":{"docs":{},"务":{"docs":{},"使":{"docs":{},"用":{"docs":{},"章":{"docs":{},"节":{"docs":{},"）":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.005847953216374269},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677}},"\"":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677}}}}}}}}}}}}}}},"2":{"docs":{},"\"":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.006423982869379015}}}}},"3":{"docs":{},"\"":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"docs":{},"\"":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},"\"":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.008565310492505354}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{},"f":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"(":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.009554140127388535}}}}}}}}}}}},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"j":{"docs":{},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"j":{"docs":{},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{},"i":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"l":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}},"r":{"docs":{},"l":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}},"p":{"docs":{},"f":{"docs":{},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"(":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"(":{"1":{"0":{"0":{"0":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"1":{"0":{"0":{"0":{"0":{"docs":{},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"1":{"0":{"0":{"0":{"docs":{},")":{"docs":{},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"1":{"0":{"0":{"0":{"docs":{},")":{"docs":{},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"(":{"docs":{},"v":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317}}}}}}}}}}}}}}}}}},"z":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.008746355685131196}}}}}}}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}},"b":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"y":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"你":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"类":{"docs":{},"名":{"docs":{},"是":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"(":{"4":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"m":{"docs":{},"g":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"/":{"docs":{},"/":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"设":{"docs":{},"置":{"docs":{},"到":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"启":{"docs":{},"动":{"docs":{},"参":{"docs":{},"数":{"docs":{},"中":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}},"/":{"docs":{},"/":{"docs":{},"设":{"docs":{},"置":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"实":{"docs":{},"现":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"对":{"docs":{},"象":{"docs":{},"有":{"docs":{},"很":{"docs":{},"多":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"集":{"docs":{},"群":{"docs":{},"、":{"docs":{},"高":{"docs":{},"可":{"docs":{},"用":{"docs":{},"、":{"docs":{},"池":{"docs":{},"大":{"docs":{},"小":{"docs":{},"等":{"docs":{},"。":{"docs":{},"在":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"中":{"docs":{},"描":{"docs":{},"述":{"docs":{},"了":{"docs":{},"所":{"docs":{},"有":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"细":{"docs":{},"节":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"工":{"docs":{},"具":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"、":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"和":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"命":{"docs":{},"令":{"docs":{},"，":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"命":{"docs":{},"令":{"docs":{},"支":{"docs":{},"持":{"docs":{},"几":{"docs":{},"个":{"docs":{},"选":{"docs":{},"项":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}},";":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}}}},",":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.01050420168067227},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.00823529411764706}}}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},":":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.017543859649122806},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.006423982869379015},"core/Core.html":{"ref":"core/Core.html","tf":0.0009289363678588017},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.006463527239150508},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.01411764705882353}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"a":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}},"u":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.005471956224350205},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.012958963282937365},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"e":{"docs":{},"\"":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0064794816414686825}},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.002793296089385475},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0030659172202350538}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},".":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"r":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"。":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"存":{"docs":{},"储":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"、":{"docs":{},"哈":{"docs":{},"希":{"docs":{},"(":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"、":{"docs":{},"列":{"docs":{},"表":{"docs":{},"、":{"docs":{},"无":{"docs":{},"序":{"docs":{},"集":{"docs":{},"合":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{},"和":{"docs":{},"有":{"docs":{},"序":{"docs":{},"集":{"docs":{},"合":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"这":{"docs":{},"样":{"docs":{},"：":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"]":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}},"i":{"docs":{},"d":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.016172506738544475},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},".":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603}},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"(":{"2":{"5":{"5":{"docs":{},")":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}}}},"docs":{}},"docs":{}},"3":{"6":{"docs":{},")":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}},"docs":{}},"docs":{}}}}}}}},"i":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}},"w":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}},"p":{"docs":{},"n":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.007677543186180422},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.014705882352941176},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.009852216748768473}},"软":{"docs":{},"件":{"docs":{},"通":{"docs":{},"常":{"docs":{},"通":{"docs":{},"过":{"docs":{},"创":{"docs":{},"建":{"docs":{},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{},"多":{"docs":{},"播":{"docs":{},"虚":{"docs":{},"拟":{"docs":{},"网":{"docs":{},"络":{"docs":{},"接":{"docs":{},"口":{"docs":{},"来":{"docs":{},"进":{"docs":{},"行":{"docs":{},"工":{"docs":{},"作":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"上":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}},"使":{"docs":{},"用":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"确":{"docs":{},"保":{"docs":{},"会":{"docs":{},"话":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"在":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"之":{"docs":{},"前":{"docs":{},"被":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"用":{"docs":{},"于":{"docs":{},"处":{"docs":{},"理":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"述":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"描":{"docs":{},"述":{"docs":{},"了":{"docs":{},"这":{"docs":{},"样":{"docs":{},"一":{"docs":{},"个":{"docs":{},"流":{"docs":{},"程":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}},"下":{"docs":{},"文":{"docs":{},"环":{"docs":{},"境":{"docs":{},"之":{"docs":{},"间":{"docs":{},"共":{"docs":{},"享":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"可":{"docs":{},"能":{"docs":{},"导":{"docs":{},"致":{"docs":{},"不":{"docs":{},"可":{"docs":{},"预":{"docs":{},"知":{"docs":{},"的":{"docs":{},"意":{"docs":{},"外":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{},"保":{"docs":{},"持":{"docs":{},"活":{"docs":{},"动":{"docs":{},"连":{"docs":{},"接":{"docs":{},"将":{"docs":{},"在":{"docs":{},"打":{"docs":{},"开":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"环":{"docs":{},"境":{"docs":{},"调":{"docs":{},"用":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"后":{"docs":{},"续":{"docs":{},"请":{"docs":{},"求":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"相":{"docs":{},"同":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"环":{"docs":{},"境":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"据":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"传":{"docs":{},"对":{"docs":{},"象":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"可":{"docs":{},"能":{"docs":{},"很":{"docs":{},"大":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"不":{"docs":{},"会":{"docs":{},"在":{"docs":{},"单":{"docs":{},"个":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"区":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"整":{"docs":{},"个":{"docs":{},"上":{"docs":{},"传":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"样":{"docs":{},"会":{"docs":{},"导":{"docs":{},"致":{"docs":{},"内":{"docs":{},"存":{"docs":{},"耗":{"docs":{},"尽":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"，":{"docs":{},"上":{"docs":{},"传":{"docs":{},"数":{"docs":{},"据":{"docs":{},"是":{"docs":{},"以":{"docs":{},"块":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"被":{"docs":{},"接":{"docs":{},"收":{"docs":{},"的":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"送":{"docs":{},"消":{"docs":{},"息":{"docs":{},"来":{"docs":{},"相":{"docs":{},"互":{"docs":{},"通":{"docs":{},"信":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"可":{"docs":{},"包":{"docs":{},"含":{"docs":{},"头":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{},"这":{"docs":{},"可":{"docs":{},"通":{"docs":{},"过":{"docs":{},"在":{"docs":{},"发":{"docs":{},"送":{"docs":{},"或":{"docs":{},"发":{"docs":{},"布":{"docs":{},"时":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"普":{"docs":{},"通":{"docs":{},"代":{"docs":{},"码":{"docs":{},"都":{"docs":{},"会":{"docs":{},"在":{"docs":{},"此":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"总":{"docs":{},"是":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"是":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"的":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"了":{"docs":{},"才":{"docs":{},"会":{"docs":{},"继":{"docs":{},"续":{"docs":{},"执":{"docs":{},"行":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"即":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"注":{"docs":{},"册":{"docs":{},"过":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"用":{"docs":{},"于":{"docs":{},"访":{"docs":{},"问":{"docs":{},"和":{"docs":{},"删":{"docs":{},"除":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{},"但":{"docs":{},"我":{"docs":{},"们":{"docs":{},"并":{"docs":{},"不":{"docs":{},"希":{"docs":{},"望":{"docs":{},"恶":{"docs":{},"意":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"能":{"docs":{},"够":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"来":{"docs":{},"操":{"docs":{},"作":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"中":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{},"并":{"docs":{},"且":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"也":{"docs":{},"不":{"docs":{},"希":{"docs":{},"望":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"能":{"docs":{},"够":{"docs":{},"监":{"docs":{},"听":{"docs":{},"所":{"docs":{},"有":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"话":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"的":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"，":{"docs":{},"可":{"docs":{},"调":{"docs":{},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"地":{"docs":{},"址":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"绑":{"docs":{},"定":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"当":{"docs":{},"一":{"docs":{},"个":{"docs":{},"操":{"docs":{},"作":{"docs":{},"失":{"docs":{},"败":{"docs":{},"（":{"docs":{},"其":{"docs":{},"中":{"docs":{},"的":{"docs":{},"某":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"边":{"docs":{},"代":{"docs":{},"码":{"docs":{},"段":{"docs":{},"描":{"docs":{},"述":{"docs":{},"了":{"docs":{},"如":{"docs":{},"何":{"docs":{},"在":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"所":{"docs":{},"有":{"docs":{},"操":{"docs":{},"作":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"都":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"异":{"docs":{},"步":{"docs":{},"调":{"docs":{},"用":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"面":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"例":{"docs":{},"子":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"问":{"docs":{},"题":{"docs":{},"：":{"docs":{},"如":{"docs":{},"果":{"docs":{},"从":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"读":{"docs":{},"取":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"速":{"docs":{},"度":{"docs":{},"比":{"docs":{},"写":{"docs":{},"回":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"的":{"docs":{},"速":{"docs":{},"度":{"docs":{},"快":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"它":{"docs":{},"将":{"docs":{},"在":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"的":{"docs":{},"写":{"docs":{},"队":{"docs":{},"列":{"docs":{},"中":{"docs":{},"不":{"docs":{},"断":{"docs":{},"堆":{"docs":{},"积":{"docs":{},"，":{"docs":{},"最":{"docs":{},"终":{"docs":{},"耗":{"docs":{},"尽":{"docs":{},"内":{"docs":{},"存":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"若":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"另":{"docs":{},"一":{"docs":{},"端":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"读":{"docs":{},"取":{"docs":{},"速":{"docs":{},"度":{"docs":{},"不":{"docs":{},"够":{"docs":{},"快":{"docs":{},"，":{"docs":{},"无":{"docs":{},"法":{"docs":{},"快":{"docs":{},"速":{"docs":{},"地":{"docs":{},"向":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"端":{"docs":{},"回":{"docs":{},"压":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"，":{"docs":{},"在":{"docs":{},"回":{"docs":{},"应":{"docs":{},"返":{"docs":{},"回":{"docs":{},"前":{"docs":{},"，":{"docs":{},"f":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"挂":{"docs":{},"载":{"docs":{},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"创":{"docs":{},"建":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"启":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"寻":{"docs":{},"找":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"添":{"docs":{},"加":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"接":{"docs":{},"收":{"docs":{},"或":{"docs":{},"者":{"docs":{},"发":{"docs":{},"送":{"docs":{},"超":{"docs":{},"时":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"流":{"docs":{},"行":{"docs":{},"的":{"docs":{},"库":{"docs":{},"，":{"docs":{},"用":{"docs":{},"于":{"docs":{},"组":{"docs":{},"合":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"、":{"docs":{},"使":{"docs":{},"用":{"docs":{},"可":{"docs":{},"观":{"docs":{},"察":{"docs":{},"序":{"docs":{},"列":{"docs":{},"的":{"docs":{},"、":{"docs":{},"基":{"docs":{},"于":{"docs":{},"事":{"docs":{},"件":{"docs":{},"的":{"docs":{},"程":{"docs":{},"序":{"docs":{},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}},"进":{"docs":{},"行":{"docs":{},"非":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"的":{"docs":{},"带":{"docs":{},"背":{"docs":{},"压":{"docs":{},"机":{"docs":{},"制":{"docs":{},"的":{"docs":{},"异":{"docs":{},"步":{"docs":{},"流":{"docs":{},"处":{"docs":{},"理":{"docs":{},"，":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}},"中":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},"国":{"docs":{},"用":{"docs":{},"户":{"docs":{},"组":{"docs":{},"发":{"docs":{},"动":{"docs":{},"社":{"docs":{},"区":{"docs":{},"内":{"docs":{},"的":{"docs":{},"志":{"docs":{},"愿":{"docs":{},"者":{"docs":{},"翻":{"docs":{},"译":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}}}},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"概":{"docs":{},"念":{"docs":{},"和":{"docs":{},"特":{"docs":{},"性":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"会":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"内":{"docs":{},"置":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"作":{"docs":{},"为":{"docs":{},"主":{"docs":{},"类":{"docs":{},"，":{"docs":{},"由":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},"启":{"docs":{},"动":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"它":{"docs":{},"之":{"docs":{},"前":{"docs":{},"测":{"docs":{},"试":{"docs":{},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"们":{"docs":{},"究":{"docs":{},"竟":{"docs":{},"需":{"docs":{},"要":{"docs":{},"耗":{"docs":{},"费":{"docs":{},"多":{"docs":{},"长":{"docs":{},"时":{"docs":{},"间":{"docs":{},"，":{"docs":{},"以":{"docs":{},"避":{"docs":{},"免":{"docs":{},"打":{"docs":{},"破":{"docs":{},"黄":{"docs":{},"金":{"docs":{},"法":{"docs":{},"则":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"或":{"docs":{},"者":{"docs":{},"嵌":{"docs":{},"入":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"，":{"docs":{},"当":{"docs":{},"这":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"的":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}},"加":{"docs":{},"载":{"docs":{},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"一":{"docs":{},"个":{"docs":{},"文":{"docs":{},"件":{"docs":{},"为":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}},"包":{"docs":{},"含":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"了":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"的":{"docs":{},"这":{"docs":{},"一":{"docs":{},"分":{"docs":{},"片":{"docs":{},"（":{"docs":{},"部":{"docs":{},"分":{"docs":{},"）":{"docs":{},"内":{"docs":{},"容":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"送":{"docs":{},"任":{"docs":{},"何":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"你":{"docs":{},"为":{"docs":{},"这":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"类":{"docs":{},"型":{"docs":{},"注":{"docs":{},"册":{"docs":{},"一":{"docs":{},"个":{"docs":{},"编":{"docs":{},"解":{"docs":{},"码":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"意":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"为":{"docs":{},"您":{"docs":{},"想":{"docs":{},"要":{"docs":{},"发":{"docs":{},"送":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"布":{"docs":{},"者":{"docs":{},"和":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"者":{"docs":{},"的":{"docs":{},"角":{"docs":{},"色":{"docs":{},"；":{"docs":{},"这":{"docs":{},"使":{"docs":{},"得":{"docs":{},"我":{"docs":{},"们":{"docs":{},"能":{"docs":{},"够":{"docs":{},"以":{"docs":{},"对":{"docs":{},"待":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}}}}},"启":{"docs":{},"动":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"处":{"docs":{},"理":{"docs":{},"的":{"docs":{},"非":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"完":{"docs":{},"成":{"docs":{},"此":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"你":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"其":{"docs":{},"它":{"docs":{},"位":{"docs":{},"置":{"docs":{},"完":{"docs":{},"成":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"根":{"docs":{},"路":{"docs":{},"径":{"docs":{},"是":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}},"并":{"docs":{},"行":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"开":{"docs":{},"始":{"docs":{},"写":{"docs":{},"入":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"位":{"docs":{},"置":{"docs":{},"。":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"异":{"docs":{},"步":{"docs":{},"执":{"docs":{},"行":{"docs":{},"代":{"docs":{},"码":{"docs":{},"了":{"docs":{},"。":{"docs":{},"换":{"docs":{},"句":{"docs":{},"话":{"docs":{},"说":{"docs":{},"，":{"docs":{},"您":{"docs":{},"提":{"docs":{},"交":{"docs":{},"的":{"docs":{},"任":{"docs":{},"务":{"docs":{},"将":{"docs":{},"会":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"不":{"docs":{},"能":{"docs":{},"直":{"docs":{},"接":{"docs":{},"让":{"docs":{},"线":{"docs":{},"程":{"docs":{},"休":{"docs":{},"眠":{"docs":{},"以":{"docs":{},"引":{"docs":{},"入":{"docs":{},"延":{"docs":{},"迟":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"会":{"docs":{},"阻":{"docs":{},"塞":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"它":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"超":{"docs":{},"时":{"docs":{},"时":{"docs":{},"间":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"时":{"docs":{},"间":{"docs":{},"之":{"docs":{},"内":{"docs":{},"没":{"docs":{},"有":{"docs":{},"收":{"docs":{},"到":{"docs":{},"应":{"docs":{},"答":{"docs":{},"，":{"docs":{},"则":{"docs":{},"会":{"docs":{},"以":{"docs":{},"失":{"docs":{},"败":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"调":{"docs":{},"用":{"docs":{},"应":{"docs":{},"答":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"超":{"docs":{},"时":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"i":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"；":{"docs":{},"如":{"docs":{},"果":{"docs":{},"没":{"docs":{},"有":{"docs":{},"指":{"docs":{},"定":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{},"后":{"docs":{},"端":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"但":{"docs":{},"建":{"docs":{},"议":{"docs":{},"您":{"docs":{},"将":{"docs":{},"代":{"docs":{},"码":{"docs":{},"编":{"docs":{},"写":{"docs":{},"成":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"并":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"的":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"（":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"作":{"docs":{},"为":{"docs":{},"您":{"docs":{},"的":{"docs":{},"主":{"docs":{},"类":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"在":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"中":{"docs":{},"运":{"docs":{},"行":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"主":{"docs":{},"类":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"指":{"docs":{},"定":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"如":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"些":{"docs":{},"查":{"docs":{},"询":{"docs":{},"要":{"docs":{},"求":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"撤":{"docs":{},"销":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"则":{"docs":{},"同":{"docs":{},"样":{"docs":{},"会":{"docs":{},"花":{"docs":{},"费":{"docs":{},"一":{"docs":{},"些":{"docs":{},"时":{"docs":{},"间":{"docs":{},"在":{"docs":{},"节":{"docs":{},"点":{"docs":{},"中":{"docs":{},"传":{"docs":{},"播":{"docs":{},"。":{"docs":{},"若":{"docs":{},"您":{"docs":{},"想":{"docs":{},"在":{"docs":{},"完":{"docs":{},"成":{"docs":{},"后":{"docs":{},"收":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"u":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"注":{"docs":{},"册":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0009289363678588017},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"一":{"docs":{},"个":{"docs":{},"通":{"docs":{},"用":{"docs":{},"模":{"docs":{},"式":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"请":{"docs":{},"适":{"docs":{},"应":{"docs":{},"这":{"docs":{},"种":{"docs":{},"代":{"docs":{},"码":{"docs":{},"风":{"docs":{},"格":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"偏":{"docs":{},"移":{"docs":{},"量":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"全":{"docs":{},"部":{"docs":{},"或":{"docs":{},"部":{"docs":{},"分":{"docs":{},"发":{"docs":{},"生":{"docs":{},"故":{"docs":{},"障":{"docs":{},"时":{"docs":{},"，":{"docs":{},"则":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"丢":{"docs":{},"失":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"字":{"docs":{},"符":{"docs":{},"会":{"docs":{},"以":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"操":{"docs":{},"作":{"docs":{},"同":{"docs":{},"时":{"docs":{},"运":{"docs":{},"行":{"docs":{},"。":{"docs":{},"当":{"docs":{},"组":{"docs":{},"合":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"操":{"docs":{},"作":{"docs":{},"完":{"docs":{},"成":{"docs":{},"时":{"docs":{},"，":{"docs":{},"该":{"docs":{},"方":{"docs":{},"法":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"并":{"docs":{},"传":{"docs":{},"入":{"docs":{},"了":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"时":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"某":{"docs":{},"个":{"docs":{},"线":{"docs":{},"程":{"docs":{},"来":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"状":{"docs":{},"态":{"docs":{},"不":{"docs":{},"会":{"docs":{},"在":{"docs":{},"响":{"docs":{},"应":{"docs":{},"中":{"docs":{},"描":{"docs":{},"述":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"线":{"docs":{},"程":{"docs":{},"上":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"可":{"docs":{},"以":{"docs":{},"由":{"docs":{},"多":{"docs":{},"个":{"docs":{},"线":{"docs":{},"程":{"docs":{},"同":{"docs":{},"时":{"docs":{},"执":{"docs":{},"行":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"因":{"docs":{},"此":{"docs":{},"需":{"docs":{},"要":{"docs":{},"开":{"docs":{},"发":{"docs":{},"者":{"docs":{},"自":{"docs":{},"己":{"docs":{},"确":{"docs":{},"保":{"docs":{},"线":{"docs":{},"程":{"docs":{},"安":{"docs":{},"全":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"绝":{"docs":{},"对":{"docs":{},"不":{"docs":{},"会":{"docs":{},"被":{"docs":{},"多":{"docs":{},"个":{"docs":{},"线":{"docs":{},"程":{"docs":{},"同":{"docs":{},"时":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"自":{"docs":{},"动":{"docs":{},"清":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"资":{"docs":{},"源":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"写":{"docs":{},"入":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"做":{"docs":{},"法":{"docs":{},"是":{"docs":{},"非":{"docs":{},"常":{"docs":{},"高":{"docs":{},"效":{"docs":{},"的":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"内":{"docs":{},"核":{"docs":{},"直":{"docs":{},"接":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"常":{"docs":{},"做":{"docs":{},"法":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"部":{"docs":{},"分":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"：":{"docs":{},"仅":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"和":{"docs":{},"异":{"docs":{},"常":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"该":{"docs":{},"协":{"docs":{},"议":{"docs":{},"并":{"docs":{},"不":{"docs":{},"提":{"docs":{},"供":{"docs":{},"其":{"docs":{},"他":{"docs":{},"操":{"docs":{},"作":{"docs":{},"的":{"docs":{},"语":{"docs":{},"义":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"哪":{"docs":{},"个":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"是":{"docs":{},"命":{"docs":{},"令":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"也":{"docs":{},"就":{"docs":{},"必":{"docs":{},"须":{"docs":{},"把":{"docs":{},"命":{"docs":{},"令":{"docs":{},"名":{"docs":{},"称":{"docs":{},"单":{"docs":{},"独":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"表":{"docs":{},"）":{"docs":{},"中":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"或":{"docs":{},"多":{"docs":{},"个":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{},"其":{"docs":{},"中":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}},"进":{"docs":{},"行":{"docs":{},"保":{"docs":{},"存":{"docs":{},"、":{"docs":{},"获":{"docs":{},"取":{"docs":{},"、":{"docs":{},"搜":{"docs":{},"索":{"docs":{},"和":{"docs":{},"删":{"docs":{},"除":{"docs":{},"。":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}},"集":{"docs":{},"合":{"docs":{},"概":{"docs":{},"念":{"docs":{},"对":{"docs":{},"应":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"消":{"docs":{},"息":{"docs":{},"是":{"docs":{},"按":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"持":{"docs":{},"久":{"docs":{},"化":{"docs":{},"在":{"docs":{},"磁":{"docs":{},"盘":{"docs":{},"上":{"docs":{},"的":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"导":{"docs":{},"入":{"docs":{},"到":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"组":{"docs":{},"件":{"docs":{},"中":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"保":{"docs":{},"持":{"docs":{},"一":{"docs":{},"致":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}},"日":{"docs":{},"志":{"docs":{},"框":{"docs":{},"架":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}},"最":{"docs":{},"新":{"docs":{},"特":{"docs":{},"性":{"docs":{},"。":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}},"直":{"docs":{},"接":{"docs":{},"调":{"docs":{},"用":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"会":{"docs":{},"阻":{"docs":{},"止":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"自":{"docs":{},"动":{"docs":{},"清":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"除":{"docs":{},"定":{"docs":{},"时":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"关":{"docs":{},"闭":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}},"定":{"docs":{},"义":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"英":{"docs":{},"对":{"docs":{},"照":{"docs":{},"表":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"文":{"docs":{},"对":{"docs":{},"照":{"docs":{},"表":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"获":{"docs":{},"取":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"单":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"让":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"本":{"docs":{},"地":{"docs":{},"和":{"docs":{},"分":{"docs":{},"布":{"docs":{},"式":{"docs":{},"组":{"docs":{},"件":{"docs":{},"中":{"docs":{},"分":{"docs":{},"发":{"docs":{},"你":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"得":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"被":{"docs":{},"多":{"docs":{},"个":{"docs":{},"线":{"docs":{},"程":{"docs":{},"同":{"docs":{},"时":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"但":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"不":{"docs":{},"同":{"docs":{},"时":{"docs":{},"间":{"docs":{},"由":{"docs":{},"不":{"docs":{},"同":{"docs":{},"线":{"docs":{},"程":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"解":{"docs":{},"析":{"docs":{},"读":{"docs":{},"取":{"docs":{},"的":{"docs":{},"，":{"docs":{},"若":{"docs":{},"您":{"docs":{},"已":{"docs":{},"经":{"docs":{},"将":{"docs":{},"表":{"docs":{},"单":{"docs":{},"属":{"docs":{},"性":{"docs":{},"存":{"docs":{},"放":{"docs":{},"在":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"中":{"docs":{},"发":{"docs":{},"送":{"docs":{},"出":{"docs":{},"去":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"该":{"docs":{},"请":{"docs":{},"求":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"了":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"实":{"docs":{},"际":{"docs":{},"的":{"docs":{},"会":{"docs":{},"话":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"多":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{},"需":{"docs":{},"要":{"docs":{},"注":{"docs":{},"意":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"h":{"docs":{},"m":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}},"m":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"n":{"docs":{},"x":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}},"访":{"docs":{},"问":{"docs":{},"环":{"docs":{},"境":{"docs":{},"变":{"docs":{},"量":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"读":{"docs":{},"取":{"docs":{},"或":{"docs":{},"追":{"docs":{},"加":{"docs":{},"/":{"docs":{},"设":{"docs":{},"置":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"数":{"docs":{},"据":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"，":{"docs":{},"它":{"docs":{},"存":{"docs":{},"在":{"docs":{},"各":{"docs":{},"种":{"docs":{},"不":{"docs":{},"同":{"docs":{},"数":{"docs":{},"据":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"从":{"docs":{},"哪":{"docs":{},"里":{"docs":{},"获":{"docs":{},"取":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"（":{"docs":{},"获":{"docs":{},"取":{"docs":{},"位":{"docs":{},"置":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"必":{"docs":{},"须":{"docs":{},"设":{"docs":{},"置":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"一":{"docs":{},"批":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"自":{"docs":{},"动":{"docs":{},"执":{"docs":{},"行":{"docs":{},"提":{"docs":{},"交":{"docs":{},"偏":{"docs":{},"移":{"docs":{},"量":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}},"写":{"docs":{},"流":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"处":{"docs":{},"理":{"docs":{},"任":{"docs":{},"意":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"了":{"docs":{},"多":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"函":{"docs":{},"数":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"它":{"docs":{},"们":{"docs":{},"之":{"docs":{},"间":{"docs":{},"共":{"docs":{},"享":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"（":{"docs":{},"或":{"docs":{},"构":{"docs":{},"建":{"docs":{},"工":{"docs":{},"具":{"docs":{},"的":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"中":{"docs":{},"）":{"docs":{},"包":{"docs":{},"含":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"之":{"docs":{},"间":{"docs":{},"安":{"docs":{},"全":{"docs":{},"共":{"docs":{},"享":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"，":{"docs":{},"写":{"docs":{},"调":{"docs":{},"用":{"docs":{},"是":{"docs":{},"立":{"docs":{},"即":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"，":{"docs":{},"而":{"docs":{},"写":{"docs":{},"操":{"docs":{},"作":{"docs":{},"的":{"docs":{},"实":{"docs":{},"际":{"docs":{},"是":{"docs":{},"在":{"docs":{},"内":{"docs":{},"部":{"docs":{},"队":{"docs":{},"列":{"docs":{},"中":{"docs":{},"排":{"docs":{},"队":{"docs":{},"写":{"docs":{},"入":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"并":{"docs":{},"从":{"docs":{},"任":{"docs":{},"何":{"docs":{},"其":{"docs":{},"他":{"docs":{},"节":{"docs":{},"点":{"docs":{},"读":{"docs":{},"取":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"且":{"docs":{},"是":{"docs":{},"有":{"docs":{},"序":{"docs":{},"的":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}},"想":{"docs":{},"要":{"docs":{},"延":{"docs":{},"迟":{"docs":{},"之":{"docs":{},"后":{"docs":{},"执":{"docs":{},"行":{"docs":{},"或":{"docs":{},"定":{"docs":{},"期":{"docs":{},"执":{"docs":{},"行":{"docs":{},"操":{"docs":{},"作":{"docs":{},"很":{"docs":{},"常":{"docs":{},"见":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"文":{"docs":{},"件":{"docs":{},"或":{"docs":{},"其":{"docs":{},"他":{"docs":{},"文":{"docs":{},"件":{"docs":{},"）":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"把":{"docs":{},"文":{"docs":{},"件":{"docs":{},"复":{"docs":{},"制":{"docs":{},"到":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"目":{"docs":{},"录":{"docs":{},"。":{"docs":{},"背":{"docs":{},"后":{"docs":{},"原":{"docs":{},"因":{"docs":{},"很":{"docs":{},"简":{"docs":{},"单":{"docs":{},"：":{"docs":{},"从":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"可":{"docs":{},"用":{"docs":{},"于":{"docs":{},"各":{"docs":{},"种":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"化":{"docs":{},"与":{"docs":{},"高":{"docs":{},"可":{"docs":{},"用":{"docs":{},"均":{"docs":{},"是":{"docs":{},"开":{"docs":{},"箱":{"docs":{},"即":{"docs":{},"用":{"docs":{},"的":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353}}}}}}}}}}}}}}}}}}}}}}},"该":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"z":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}},"可":{"docs":{},"以":{"docs":{},"按":{"docs":{},"照":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"负":{"docs":{},"责":{"docs":{},"处":{"docs":{},"理":{"docs":{},"最":{"docs":{},"新":{"docs":{},"读":{"docs":{},"取":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"偏":{"docs":{},"移":{"docs":{},"量":{"docs":{},"（":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"）":{"docs":{},"。":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"些":{"docs":{},"操":{"docs":{},"作":{"docs":{},"通":{"docs":{},"常":{"docs":{},"会":{"docs":{},"有":{"docs":{},"接":{"docs":{},"受":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}},"用":{"docs":{},"来":{"docs":{},"跟":{"docs":{},"踪":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"情":{"docs":{},"况":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}},"采":{"docs":{},"用":{"docs":{"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"将":{"docs":{},"自":{"docs":{},"动":{"docs":{},"检":{"docs":{},"测":{"docs":{},"到":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"其":{"docs":{},"作":{"docs":{},"为":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"。":{"docs":{},"需":{"docs":{},"要":{"docs":{},"注":{"docs":{},"意":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"要":{"docs":{},"确":{"docs":{},"保":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"构":{"docs":{},"建":{"docs":{},"工":{"docs":{},"具":{"docs":{},"可":{"docs":{},"以":{"docs":{},"轻":{"docs":{},"松":{"docs":{},"引":{"docs":{},"入":{"docs":{},"：":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}},"找":{"docs":{},"到":{"docs":{},"，":{"docs":{},"简":{"docs":{},"单":{"docs":{},"来":{"docs":{},"说":{"docs":{},"您":{"docs":{},"会":{"docs":{},"像":{"docs":{},"这":{"docs":{},"样":{"docs":{},"使":{"docs":{},"用":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"插":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"查":{"docs":{},"找":{"docs":{},"文":{"docs":{},"件":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"标":{"docs":{},"准":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"第":{"docs":{},"一":{"docs":{},"次":{"docs":{},"找":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"资":{"docs":{},"源":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"将":{"docs":{},"它":{"docs":{},"提":{"docs":{},"取":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"磁":{"docs":{},"盘":{"docs":{},"的":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"目":{"docs":{},"录":{"docs":{},"中":{"docs":{},"以":{"docs":{},"避":{"docs":{},"免":{"docs":{},"每":{"docs":{},"一":{"docs":{},"次":{"docs":{},"都":{"docs":{},"重":{"docs":{},"新":{"docs":{},"提":{"docs":{},"取":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},"然":{"docs":{},"后":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"类":{"docs":{},"型":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}},"举":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"置":{"docs":{},"以":{"docs":{},"下":{"docs":{},"参":{"docs":{},"数":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"有":{"docs":{},"用":{"docs":{},"到":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}},"了":{"docs":{},"解":{"docs":{},"如":{"docs":{},"何":{"docs":{},"去":{"docs":{},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}},"心":{"docs":{},"库":{"docs":{},"下":{"docs":{},"载":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"写":{"docs":{},"入":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"它":{"docs":{},"是":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"反":{"docs":{},"映":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"背":{"docs":{},"压":{"docs":{},"机":{"docs":{},"制":{"docs":{},"传":{"docs":{},"播":{"docs":{},"方":{"docs":{},"面":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"（":{"docs":{},"在":{"docs":{},"请":{"docs":{},"求":{"docs":{},"更":{"docs":{},"多":{"docs":{},"数":{"docs":{},"据":{"docs":{},"项":{"docs":{},"时":{"docs":{},"）":{"docs":{},"。":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}}}}}}},"导":{"docs":{},"入":{"docs":{},"服":{"docs":{},"务":{"docs":{},"到":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"推":{"docs":{},"断":{"docs":{},"出":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"；":{"docs":{},"如":{"docs":{},"果":{"docs":{},"没":{"docs":{},"有":{"docs":{},"设":{"docs":{},"置":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"移":{"docs":{},"除":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"移":{"docs":{},"除":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}},"内":{"docs":{},"嵌":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}},"安":{"docs":{},"装":{"docs":{},"包":{"docs":{},"中":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}},"没":{"docs":{},"有":{"docs":{},"其":{"docs":{},"它":{"docs":{},"的":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}},"添":{"docs":{},"加":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"一":{"docs":{},"个":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"想":{"docs":{},"在":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}},"节":{"docs":{},"点":{"docs":{},"中":{"docs":{},"的":{"docs":{},"通":{"docs":{},"信":{"docs":{},"是":{"docs":{},"直":{"docs":{},"接":{"docs":{},"由":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"中":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}},"已":{"docs":{},"经":{"docs":{},"通":{"docs":{},"过":{"docs":{},"注":{"docs":{},"释":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"，":{"docs":{},"详":{"docs":{},"细":{"docs":{},"说":{"docs":{},"明":{"docs":{},"每":{"docs":{},"个":{"docs":{},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"的":{"docs":{},"作":{"docs":{},"用":{"docs":{},"。":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"为":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},"主":{"docs":{},"版":{"docs":{},"本":{"docs":{},"分":{"docs":{},"支":{"docs":{},"，":{"docs":{},"主":{"docs":{},"要":{"docs":{},"进":{"docs":{},"行":{"docs":{},"里":{"docs":{},"程":{"docs":{},"碑":{"docs":{},"式":{"docs":{},"的":{"docs":{},"发":{"docs":{},"布":{"docs":{},"；":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}}}}}}}}}},"开":{"docs":{},"发":{"docs":{},"分":{"docs":{},"支":{"docs":{},"，":{"docs":{},"日":{"docs":{},"常":{"docs":{},"的":{"docs":{},"提":{"docs":{},"交":{"docs":{},"都":{"docs":{},"在":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}},"了":{"docs":{},"在":{"docs":{},"短":{"docs":{},"时":{"docs":{},"间":{"docs":{},"内":{"docs":{},"完":{"docs":{},"成":{"docs":{},"调":{"docs":{},"度":{"docs":{},"循":{"docs":{},"环":{"docs":{},"，":{"docs":{},"就":{"docs":{},"需":{"docs":{},"要":{"docs":{},"用":{"docs":{},"户":{"docs":{},"正":{"docs":{},"确":{"docs":{},"估":{"docs":{},"算":{"docs":{},"出":{"docs":{},"，":{"docs":{},"哪":{"docs":{},"些":{"docs":{},"程":{"docs":{},"序":{"docs":{},"代":{"docs":{},"码":{"docs":{},"会":{"docs":{},"相":{"docs":{},"对":{"docs":{},"长":{"docs":{},"时":{"docs":{},"间":{"docs":{},"地":{"docs":{},"占":{"docs":{},"用":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"线":{"docs":{},"程":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"时":{"docs":{},"间":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"将":{"docs":{},"该":{"docs":{},"部":{"docs":{},"分":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"交":{"docs":{},"由":{"docs":{},"其":{"docs":{},"它":{"docs":{},"线":{"docs":{},"程":{"docs":{},"去":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{},"值":{"docs":{},"得":{"docs":{},"注":{"docs":{},"意":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"所":{"docs":{},"说":{"docs":{},"的":{"docs":{},"其":{"docs":{},"它":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"内":{"docs":{},"核":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"也":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"用":{"docs":{},"户":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"用":{"docs":{},"户":{"docs":{},"线":{"docs":{},"程":{"docs":{},"中":{"docs":{},"包":{"docs":{},"括":{"docs":{},"了":{"docs":{},"其":{"docs":{},"它":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"其":{"docs":{},"它":{"docs":{},"进":{"docs":{},"程":{"docs":{},"中":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"是":{"docs":{},"我":{"docs":{},"们":{"docs":{},"用":{"docs":{},"户":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"利":{"docs":{},"用":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"核":{"docs":{},"，":{"docs":{},"您":{"docs":{},"将":{"docs":{},"需":{"docs":{},"要":{"docs":{},"部":{"docs":{},"署":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"以":{"docs":{},"编":{"docs":{},"程":{"docs":{},"方":{"docs":{},"式":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"更":{"docs":{},"多":{"docs":{},"（":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"）":{"docs":{},"实":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"解":{"docs":{},"决":{"docs":{},"后":{"docs":{},"边":{"docs":{},"一":{"docs":{},"个":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"也":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"调":{"docs":{},"整":{"docs":{},"原":{"docs":{},"始":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"j":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"进":{"docs":{},"行":{"docs":{},"调":{"docs":{},"试":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"记":{"docs":{},"录":{"docs":{},"网":{"docs":{},"络":{"docs":{},"活":{"docs":{},"动":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"记":{"docs":{},"录":{"docs":{},"网":{"docs":{},"络":{"docs":{},"活":{"docs":{},"动":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"（":{"docs":{},"能":{"docs":{},"）":{"docs":{},"工":{"docs":{},"作":{"docs":{},"，":{"docs":{},"配":{"docs":{},"置":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"时":{"docs":{},"，":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"升":{"docs":{},"性":{"docs":{},"能":{"docs":{},"，":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}},"清":{"docs":{},"空":{"docs":{},"内":{"docs":{},"部":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"，":{"docs":{},"则":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}},"避":{"docs":{},"免":{"docs":{},"在":{"docs":{},"\"":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},"集":{"docs":{},"合":{"docs":{},"中":{"docs":{},"出":{"docs":{},"现":{"docs":{},"重":{"docs":{},"复":{"docs":{},"的":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"，":{"docs":{},"应":{"docs":{},"该":{"docs":{},"在":{"docs":{},"\"":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},"集":{"docs":{},"合":{"docs":{},"中":{"docs":{},"给":{"docs":{},"\"":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"添":{"docs":{},"加":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"索":{"docs":{},"引":{"docs":{},"（":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{},"在":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}},"使":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},"这":{"docs":{},"个":{"docs":{},"特":{"docs":{},"性":{"docs":{},"正":{"docs":{},"常":{"docs":{},"工":{"docs":{},"作":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"启":{"docs":{},"动":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}},"用":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.006398537477148081}},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"我":{"docs":{},"们":{"docs":{},"需":{"docs":{},"要":{"docs":{},"以":{"docs":{},"下":{"docs":{},"的":{"docs":{},"步":{"docs":{},"骤":{"docs":{},"：":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"访":{"docs":{},"问":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"一":{"docs":{},"致":{"docs":{},"，":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"都":{"docs":{},"必":{"docs":{},"须":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"以":{"docs":{},"下":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"格":{"docs":{},"式":{"docs":{},"。":{"docs":{},"格":{"docs":{},"式":{"docs":{},"非":{"docs":{},"常":{"docs":{},"简":{"docs":{},"单":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"从":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}},"确":{"docs":{},"保":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}},"依":{"docs":{},"赖":{"docs":{},"，":{"docs":{},"在":{"docs":{},"项":{"docs":{},"目":{"docs":{},"中":{"docs":{},"直":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"响":{"docs":{},"应":{"docs":{},"设":{"docs":{},"置":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"当":{"docs":{},"前":{"docs":{},"请":{"docs":{},"求":{"docs":{},"推":{"docs":{},"送":{"docs":{},"资":{"docs":{},"源":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"此":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"其":{"docs":{},"中":{"docs":{},"一":{"docs":{},"个":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"如":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"应":{"docs":{},"该":{"docs":{},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"下":{"docs":{},"载":{"docs":{},"并":{"docs":{},"安":{"docs":{},"装":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"使":{"docs":{},"用":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"获":{"docs":{},"取":{"docs":{},"一":{"docs":{},"个":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"对":{"docs":{},"象":{"docs":{},"以":{"docs":{},"记":{"docs":{},"录":{"docs":{},"日":{"docs":{},"志":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"配":{"docs":{},"置":{"docs":{},"哪":{"docs":{},"些":{"docs":{},"消":{"docs":{},"息":{"docs":{},"允":{"docs":{},"许":{"docs":{},"通":{"docs":{},"过":{"docs":{},"是":{"docs":{},"很":{"docs":{},"容":{"docs":{},"易":{"docs":{},"的":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"若":{"docs":{},"干":{"docs":{},"流":{"docs":{},"行":{"docs":{},"的":{"docs":{},"模":{"docs":{},"板":{"docs":{},"引":{"docs":{},"擎":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"开":{"docs":{},"箱":{"docs":{},"即":{"docs":{},"用":{"docs":{},"的":{"docs":{},"支":{"docs":{},"持":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"提":{"docs":{},"供":{"docs":{},"生":{"docs":{},"成":{"docs":{},"动":{"docs":{},"态":{"docs":{},"页":{"docs":{},"面":{"docs":{},"的":{"docs":{},"能":{"docs":{},"力":{"docs":{},"。":{"docs":{},"您":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"很":{"docs":{},"容":{"docs":{},"易":{"docs":{},"地":{"docs":{},"添":{"docs":{},"加":{"docs":{},"您":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"避":{"docs":{},"免":{"docs":{},"歧":{"docs":{},"义":{"docs":{},"，":{"docs":{},"实":{"docs":{},"现":{"docs":{},"类":{"docs":{},"需":{"docs":{},"要":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"以":{"docs":{},"下":{"docs":{},"规":{"docs":{},"则":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"可":{"docs":{},"参":{"docs":{},"考":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}},"让":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"信":{"docs":{},"息":{"docs":{},"易":{"docs":{},"于":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}},"包":{"docs":{},"名":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"服":{"docs":{},"务":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}},"主":{"docs":{},"要":{"docs":{},"分":{"docs":{},"为":{"docs":{},"两":{"docs":{},"个":{"docs":{},"分":{"docs":{},"支":{"docs":{},"，":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}},"针":{"docs":{},"对":{"docs":{},"轮":{"docs":{},"询":{"docs":{},"方":{"docs":{},"式":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"机":{"docs":{},"名":{"docs":{},"使":{"docs":{},"用":{"docs":{},"以":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"解":{"docs":{},"析":{"docs":{},"为":{"docs":{},"i":{"docs":{},"p":{"docs":{},"地":{"docs":{},"址":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"解":{"docs":{},"析":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"映":{"docs":{},"射":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"介":{"docs":{},"绍":{"docs":{"./":{"ref":"./","tf":10}}}},"使":{"docs":{},"用":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.0014862981885740826},"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.008403361344537815},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.008226691042047532},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.011661807580174927},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}},"本":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"进":{"docs":{},"行":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"工":{"docs":{},"作":{"docs":{},"的":{"docs":{},"协":{"docs":{},"作":{"docs":{},"。":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}}}}},"组":{"docs":{},"合":{"docs":{},"来":{"docs":{},"实":{"docs":{},"现":{"docs":{},"链":{"docs":{},"式":{"docs":{},"调":{"docs":{},"用":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"结":{"docs":{},"束":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"引":{"docs":{},"擎":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"读":{"docs":{},"取":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"中":{"docs":{},"的":{"docs":{},"查":{"docs":{},"询":{"docs":{},"部":{"docs":{},"分":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"设":{"docs":{},"置":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"i":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"隐":{"docs":{},"藏":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"d":{"docs":{},"设":{"docs":{},"置":{"docs":{},"接":{"docs":{},"收":{"docs":{},"多":{"docs":{},"个":{"docs":{},"值":{"docs":{},"—":{"docs":{},"—":{"docs":{},"只":{"docs":{},"有":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"多":{"docs":{},"值":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"设":{"docs":{},"置":{"docs":{},"必":{"docs":{},"填":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"h":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"创":{"docs":{},"建":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"指":{"docs":{},"定":{"docs":{},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"不":{"docs":{},"严":{"docs":{},"格":{"docs":{},"的":{"docs":{},"轮":{"docs":{},"询":{"docs":{},"算":{"docs":{},"法":{"docs":{},"来":{"docs":{},"选":{"docs":{},"择":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"同":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"稍":{"docs":{},"有":{"docs":{},"不":{"docs":{},"一":{"docs":{},"样":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"日":{"docs":{},"志":{"docs":{},"框":{"docs":{},"架":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}},"失":{"docs":{},"败":{"docs":{},"码":{"docs":{},"拒":{"docs":{},"绝":{"docs":{},"并":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"这":{"docs":{},"个":{"docs":{},"连":{"docs":{},"接":{"docs":{},"，":{"docs":{},"这":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"长":{"docs":{},"连":{"docs":{},"接":{"docs":{},"最":{"docs":{},"好":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"忽":{"docs":{},"略":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"，":{"docs":{},"若":{"docs":{},"体":{"docs":{},"很":{"docs":{},"小":{"docs":{},"，":{"docs":{},"这":{"docs":{},"是":{"docs":{},"适":{"docs":{},"用":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"紧":{"docs":{},"跟":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"冒":{"docs":{},"号":{"docs":{},"，":{"docs":{},"它":{"docs":{},"用":{"docs":{},"于":{"docs":{},"查":{"docs":{},"找":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"，":{"docs":{},"参":{"docs":{},"考":{"docs":{},"例":{"docs":{},"子":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"默":{"docs":{},"认":{"docs":{},"选":{"docs":{},"项":{"docs":{},"创":{"docs":{},"建":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}},"无":{"docs":{},"符":{"docs":{},"号":{"docs":{},"数":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"注":{"docs":{},"解":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"流":{"docs":{},"式":{"docs":{},"响":{"docs":{},"应":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"请":{"docs":{},"求":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"读":{"docs":{},"取":{"docs":{},"配":{"docs":{},"置":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"说":{"docs":{},"明":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"运":{"docs":{},"行":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"y":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"静":{"docs":{},"态":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"如":{"docs":{},"基":{"docs":{},"础":{"docs":{},"类":{"docs":{},"型":{"docs":{},"和":{"docs":{},"枚":{"docs":{},"举":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"或":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"方":{"docs":{},"法":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"高":{"docs":{},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"默":{"docs":{},"认":{"docs":{},"设":{"docs":{},"置":{"docs":{},"运":{"docs":{},"行":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"：":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"共":{"docs":{},"享":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"会":{"docs":{},"话":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"东":{"docs":{},"西":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"配":{"docs":{},"置":{"docs":{},"参":{"docs":{},"数":{"docs":{},"不":{"docs":{},"一":{"docs":{},"样":{"docs":{},"：":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"涉":{"docs":{},"及":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"发":{"docs":{},"挥":{"docs":{},"出":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"将":{"docs":{},"不":{"docs":{},"会":{"docs":{},"产":{"docs":{},"生":{"docs":{},"服":{"docs":{},"务":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"此":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"添":{"docs":{},"加":{"docs":{},"下":{"docs":{},"列":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"通":{"docs":{},"常":{"docs":{},"需":{"docs":{},"要":{"docs":{},"配":{"docs":{},"置":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}},"事":{"docs":{},"务":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"一":{"docs":{},"个":{"docs":{},"预":{"docs":{},"先":{"docs":{},"创":{"docs":{},"建":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}},"完":{"docs":{},"后":{"docs":{},"，":{"docs":{},"不":{"docs":{},"要":{"docs":{},"忘":{"docs":{},"记":{"docs":{},"释":{"docs":{},"放":{"docs":{},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},"执":{"docs":{},"行":{"docs":{},"代":{"docs":{},"码":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}},"v":{"docs":{},"p":{"docs":{},"n":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}},"公":{"docs":{},"共":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}},"其":{"docs":{},"他":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}},"已":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"有":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"网":{"docs":{},"络":{"docs":{},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{},"当":{"docs":{},"通":{"docs":{},"过":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"模":{"docs":{},"式":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"置":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}}}}}},"，":{"docs":{},"在":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"中":{"docs":{},"将":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}}}}}},"错":{"docs":{},"误":{"docs":{},"的":{"docs":{},"网":{"docs":{},"络":{"docs":{},"接":{"docs":{},"口":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"进":{"docs":{},"行":{"docs":{},"服":{"docs":{},"务":{"docs":{},"调":{"docs":{},"用":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}},"你":{"docs":{},"能":{"docs":{},"以":{"docs":{},"同":{"docs":{},"步":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"从":{"docs":{},"这":{"docs":{},"种":{"docs":{},"流":{"docs":{},"中":{"docs":{},"接":{"docs":{},"收":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}},"其":{"docs":{},"可":{"docs":{},"用":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}},"具":{"docs":{},"体":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}},"见":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"计":{"docs":{},"划":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}},"详":{"docs":{},"细":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}},"有":{"docs":{},"单":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"或":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"附":{"docs":{},"加":{"docs":{},"值":{"docs":{},"的":{"docs":{},"短":{"docs":{},"选":{"docs":{},"项":{"docs":{},"（":{"docs":{},"即":{"docs":{},"g":{"docs":{},"c":{"docs":{},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"会":{"docs":{},"话":{"docs":{},"处":{"docs":{},"理":{"docs":{},"机":{"docs":{},"制":{"docs":{},"。":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"分":{"docs":{},"支":{"docs":{},"上":{"docs":{},"边":{"docs":{},"。":{"docs":{},"基":{"docs":{},"本":{"docs":{},"两":{"docs":{},"个":{"docs":{},"分":{"docs":{},"支":{"docs":{},"足":{"docs":{},"够":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"但":{"docs":{},"可":{"docs":{},"以":{"docs":{},"根":{"docs":{},"据":{"docs":{},"每":{"docs":{},"个":{"docs":{},"人":{"docs":{},"的":{"docs":{},"喜":{"docs":{},"好":{"docs":{},"创":{"docs":{},"建":{"docs":{},"个":{"docs":{},"人":{"docs":{},"分":{"docs":{},"支":{"docs":{},"，":{"docs":{},"不":{"docs":{},"做":{"docs":{},"约":{"docs":{},"束":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}},"块":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"传":{"docs":{},"输":{"docs":{},"编":{"docs":{},"码":{"docs":{},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"则":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"担":{"docs":{},"心":{"docs":{},"这":{"docs":{},"点":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"模":{"docs":{},"式":{"docs":{},"，":{"docs":{},"则":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"，":{"docs":{},"则":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"写":{"docs":{},"入":{"docs":{},"请":{"docs":{},"求":{"docs":{},"之":{"docs":{},"前":{"docs":{},"设":{"docs":{},"置":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"那":{"docs":{},"么":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"写":{"docs":{},"入":{"docs":{},"响":{"docs":{},"应":{"docs":{},"之":{"docs":{},"前":{"docs":{},"设":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"布":{"docs":{},"式":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"的":{"docs":{},"支":{"docs":{},"持":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"计":{"docs":{},"数":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}},"锁":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}},"钟":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"隔":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"区":{"docs":{},"偏":{"docs":{},"移":{"docs":{},"量":{"docs":{},"定":{"docs":{},"位":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"配":{"docs":{},"给":{"docs":{},"组":{"docs":{},"内":{"docs":{},"其":{"docs":{},"它":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"继":{"docs":{},"续":{"docs":{},"去":{"docs":{},"消":{"docs":{},"费":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}},"别":{"docs":{},"是":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}},"协":{"docs":{},"作":{"docs":{"./":{"ref":"./","tf":0.02564102564102564}}},"议":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"之":{"docs":{},"上":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"版":{"docs":{},"本":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"显":{"docs":{},"式":{"docs":{},"添":{"docs":{},"加":{"docs":{},"启":{"docs":{},"用":{"docs":{},"协":{"docs":{},"议":{"docs":{},"进":{"docs":{},"行":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"在":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"或":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"中":{"docs":{},"指":{"docs":{},"定":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"达":{"docs":{},"成":{"docs":{},"一":{"docs":{},"致":{"docs":{},"，":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"或":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"决":{"docs":{},"定":{"docs":{},"了":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"安":{"docs":{},"全":{"docs":{},"路":{"docs":{},"由":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"简":{"docs":{},"化":{"docs":{},"了":{"docs":{},"获":{"docs":{},"取":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"语":{"docs":{},"义":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"至":{"docs":{},"于":{"docs":{},"崩":{"docs":{},"溃":{"docs":{},"并":{"docs":{},"断":{"docs":{},"开":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"依":{"docs":{},"赖":{"docs":{},"：":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}},"命":{"docs":{},"令":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.01511879049676026}},"行":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"工":{"docs":{},"具":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{},"另":{"docs":{},"外":{"docs":{},"，":{"docs":{},"它":{"docs":{},"支":{"docs":{},"持":{"docs":{},"多":{"docs":{},"语":{"docs":{},"言":{"docs":{},"（":{"docs":{},"可":{"docs":{},"用":{"docs":{},"于":{"docs":{},"任":{"docs":{},"何":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"语":{"docs":{},"言":{"docs":{},"）":{"docs":{},"，":{"docs":{},"并":{"docs":{},"可":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"更":{"docs":{},"普":{"docs":{},"遍":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"用":{"docs":{},"于":{"docs":{},"在":{"docs":{},"终":{"docs":{},"端":{"docs":{},"中":{"docs":{},"与":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"执":{"docs":{},"行":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}},"实":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"它":{"docs":{},"可":{"docs":{},"执":{"docs":{},"行":{"docs":{},"一":{"docs":{},"组":{"docs":{},"命":{"docs":{},"令":{"docs":{},"，":{"docs":{},"如":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"、":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"接":{"docs":{},"口":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"启":{"docs":{},"动":{"docs":{},"，":{"docs":{},"要":{"docs":{},"确":{"docs":{},"保":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"但":{"docs":{},"是":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"设":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}},"不":{"docs":{},"同":{"docs":{},"之":{"docs":{},"处":{"docs":{},"在":{"docs":{},"于":{"docs":{},"，":{"docs":{},"z":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"最":{"docs":{},"终":{"docs":{},"会":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"，":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"，":{"docs":{},"即":{"docs":{},"便":{"docs":{},"是":{"docs":{},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"样":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"：":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"了":{"docs":{},"，":{"docs":{},"这":{"docs":{},"儿":{"docs":{},"是":{"docs":{},"一":{"docs":{},"些":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"：":{"1":{"4":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}},"docs":{}}},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0064794816414686825}}}}}},"使":{"docs":{},"用":{"docs":{},"单":{"docs":{},"个":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"或":{"docs":{},"者":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"数":{"docs":{},"组":{"docs":{},"来":{"docs":{},"作":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"也":{"docs":{},"是":{"docs":{},"单":{"docs":{},"个":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"或":{"docs":{},"者":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{},"不":{"docs":{},"过":{"docs":{},"在":{"docs":{},"处":{"docs":{},"理":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"十":{"docs":{},"分":{"docs":{},"特":{"docs":{},"殊":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"返":{"docs":{},"回":{"docs":{},"任":{"docs":{},"意":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"套":{"docs":{},"十":{"docs":{},"分":{"docs":{},"简":{"docs":{},"洁":{"docs":{},"的":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"将":{"docs":{},"被":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"给":{"docs":{},"定":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}},"必":{"docs":{},"须":{"docs":{},"当":{"docs":{},"且":{"docs":{},"仅":{"docs":{},"当":{"docs":{},"所":{"docs":{},"有":{"docs":{},"给":{"docs":{},"定":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}},"来":{"docs":{},"检":{"docs":{},"索":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"和":{"docs":{"./":{"ref":"./","tf":0.01282051282051282},"core/Core.html":{"ref":"core/Core.html","tf":0.0037157454714352067},"web/Web.html":{"ref":"web/Web.html","tf":0.0024342745861733205},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.01511879049676026},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.007462686567164179},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.004638833664678595},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}},"其":{"docs":{},"他":{"docs":{},"一":{"docs":{},"些":{"docs":{},"语":{"docs":{},"言":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"发":{"docs":{},"布":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"一":{"docs":{},"个":{"docs":{},"消":{"docs":{},"息":{"docs":{},"源":{"docs":{},"服":{"docs":{},"务":{"docs":{},"包":{"docs":{},"含":{"docs":{},"两":{"docs":{},"个":{"docs":{},"步":{"docs":{},"骤":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"一":{"docs":{},"致":{"docs":{},"，":{"docs":{},"这":{"docs":{},"种":{"docs":{},"操":{"docs":{},"作":{"docs":{},"随":{"docs":{},"着":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"级":{"docs":{},"别":{"docs":{},"的":{"docs":{},"增":{"docs":{},"长":{"docs":{},"会":{"docs":{},"变":{"docs":{},"得":{"docs":{},"更":{"docs":{},"加":{"docs":{},"倾":{"docs":{},"向":{"docs":{},"于":{"docs":{},"c":{"docs":{},"p":{"docs":{},"u":{"docs":{},"密":{"docs":{},"集":{"docs":{},"型":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"当":{"docs":{},"前":{"docs":{},"线":{"docs":{},"程":{"docs":{},"关":{"docs":{},"联":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"它":{"docs":{},"直":{"docs":{},"接":{"docs":{},"重":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"配":{"docs":{},"置":{"docs":{},"相":{"docs":{},"同":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"通":{"docs":{},"过":{"docs":{},"以":{"docs":{},"下":{"docs":{},"几":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"配":{"docs":{},"置":{"docs":{},"受":{"docs":{},"信":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"许":{"docs":{},"多":{"docs":{},"其":{"docs":{},"他":{"docs":{},"文":{"docs":{},"件":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{},"我":{"docs":{},"们":{"docs":{},"不":{"docs":{},"会":{"docs":{},"在":{"docs":{},"这":{"docs":{},"里":{"docs":{},"列":{"docs":{},"出":{"docs":{},"所":{"docs":{},"有":{"docs":{},"内":{"docs":{},"容":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"选":{"docs":{},"项":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"参":{"docs":{},"数":{"docs":{},"不":{"docs":{},"具":{"docs":{},"有":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"集":{"docs":{},"群":{"docs":{},"端":{"docs":{},"口":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"上":{"docs":{},"文":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"构":{"docs":{},"成":{"docs":{},"。":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"由":{"docs":{},"字":{"docs":{},"母":{"docs":{},"、":{"docs":{},"数":{"docs":{},"字":{"docs":{},"和":{"docs":{},"下":{"docs":{},"划":{"docs":{},"线":{"docs":{},"构":{"docs":{},"成":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"处":{"docs":{},"理":{"docs":{},"请":{"docs":{},"求":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"置":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"处":{"docs":{},"理":{"docs":{},"路":{"docs":{},"由":{"docs":{},"过":{"docs":{},"程":{"docs":{},"中":{"docs":{},"的":{"docs":{},"失":{"docs":{},"败":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001207617278216442},"web/Web.html":{"ref":"web/Web.html","tf":0.002677702044790652},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269},"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"中":{"docs":{},"国":{"docs":{},"越":{"docs":{},"来":{"docs":{},"越":{"docs":{},"受":{"docs":{},"到":{"docs":{},"关":{"docs":{},"注":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"人":{"docs":{},"数":{"docs":{},"也":{"docs":{},"越":{"docs":{},"来":{"docs":{},"越":{"docs":{},"多":{"docs":{},"，":{"docs":{},"但":{"docs":{},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{},"中":{"docs":{},"文":{"docs":{},"文":{"docs":{},"档":{"docs":{},"却":{"docs":{},"寥":{"docs":{},"寥":{"docs":{},"可":{"docs":{},"数":{"docs":{},"，":{"docs":{},"在":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"背":{"docs":{},"景":{"docs":{},"下":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"线":{"docs":{},"地":{"docs":{},"址":{"docs":{},"：":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},".":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"最":{"docs":{},"新":{"docs":{},"的":{"docs":{},"版":{"docs":{},"本":{"docs":{},"中":{"docs":{},"(":{"3":{"docs":{},".":{"4":{"docs":{},".":{"0":{"docs":{},"+":{"docs":{},")":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"里":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"任":{"docs":{},"意":{"docs":{},"一":{"docs":{},"个":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}},"中":{"docs":{},"，":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"第":{"docs":{},"一":{"docs":{},"件":{"docs":{},"事":{"docs":{},"是":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"一":{"docs":{},"点":{"docs":{},"上":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"问":{"docs":{},"自":{"docs":{},"己":{"docs":{},"：":{"docs":{},"如":{"docs":{},"何":{"docs":{},"让":{"docs":{},"多":{"docs":{},"台":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"主":{"docs":{},"机":{"docs":{},"和":{"docs":{},"端":{"docs":{},"口":{"docs":{},"上":{"docs":{},"侦":{"docs":{},"听":{"docs":{},"？":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"部":{"docs":{},"署":{"docs":{},"一":{"docs":{},"个":{"docs":{},"以":{"docs":{},"上":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"时":{"docs":{},"真":{"docs":{},"的":{"docs":{},"不":{"docs":{},"会":{"docs":{},"遇":{"docs":{},"到":{"docs":{},"端":{"docs":{},"口":{"docs":{},"冲":{"docs":{},"突":{"docs":{},"吗":{"docs":{},"？":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"里":{"docs":{},"处":{"docs":{},"理":{"docs":{},"传":{"docs":{},"入":{"docs":{},"连":{"docs":{},"接":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"请":{"docs":{},"求":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"的":{"docs":{},"目":{"docs":{},"标":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"。":{"docs":{},"当":{"docs":{},"写":{"docs":{},"队":{"docs":{},"列":{"docs":{},"准":{"docs":{},"备":{"docs":{},"好":{"docs":{},"接":{"docs":{},"收":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"时":{"docs":{},"，":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"事":{"docs":{},"件":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"将":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"恢":{"docs":{},"复":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"的":{"docs":{},"状":{"docs":{},"态":{"docs":{},"，":{"docs":{},"允":{"docs":{},"许":{"docs":{},"读":{"docs":{},"取":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"会":{"docs":{},"重":{"docs":{},"新":{"docs":{},"发":{"docs":{},"送":{"docs":{},"这":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"和":{"docs":{},"密":{"docs":{},"码":{"docs":{},"以":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"可":{"docs":{},"以":{"docs":{},"同":{"docs":{},"时":{"docs":{},"提":{"docs":{},"供":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},"不":{"docs":{},"是":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}},"认":{"docs":{},"证":{"docs":{},"方":{"docs":{},"式":{"docs":{},"下":{"docs":{},"，":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"定":{"docs":{},"义":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"和":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"和":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"x":{"docs":{},"上":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"能":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"下":{"docs":{},"边":{"docs":{},"的":{"docs":{},"框":{"docs":{},"架":{"docs":{},"属":{"docs":{},"性":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"：":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"p":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"c":{"docs":{},"c":{"docs":{},"l":{"docs":{},"=":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"用":{"docs":{},"户":{"docs":{},"数":{"docs":{},"据":{"docs":{},"报":{"docs":{},"协":{"docs":{},"议":{"docs":{},"（":{"docs":{},"u":{"docs":{},"d":{"docs":{},"p":{"docs":{},"）":{"docs":{},"就":{"docs":{},"是":{"docs":{},"小":{"docs":{},"菜":{"docs":{},"一":{"docs":{},"碟":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"完":{"docs":{},"美":{"docs":{},"的":{"docs":{},"世":{"docs":{},"界":{"docs":{},"中":{"docs":{},"，":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"战":{"docs":{},"争":{"docs":{},"和":{"docs":{},"饥":{"docs":{},"饿":{"docs":{},"，":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"都":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"异":{"docs":{},"步":{"docs":{},"方":{"docs":{},"式":{"docs":{},"编":{"docs":{},"写":{"docs":{},"，":{"docs":{},"兔":{"docs":{},"兔":{"docs":{},"和":{"docs":{},"小":{"docs":{},"羊":{"docs":{},"羔":{"docs":{},"将":{"docs":{},"会":{"docs":{},"在":{"docs":{},"阳":{"docs":{},"光":{"docs":{},"明":{"docs":{},"媚":{"docs":{},"的":{"docs":{},"绿":{"docs":{},"色":{"docs":{},"草":{"docs":{},"地":{"docs":{},"上":{"docs":{},"手":{"docs":{},"牵":{"docs":{},"手":{"docs":{},"地":{"docs":{},"跳":{"docs":{},"舞":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"标":{"docs":{},"准":{"docs":{},"的":{"docs":{},"反":{"docs":{},"应":{"docs":{},"器":{"docs":{},"实":{"docs":{},"现":{"docs":{},"中":{"docs":{},"，":{"docs":{},"有":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"单":{"docs":{},"一":{"docs":{},"的":{"docs":{},"报":{"docs":{},"名":{"docs":{},"场":{"docs":{},"景":{"docs":{},"中":{"docs":{},"，":{"docs":{},"你":{"docs":{},"想":{"docs":{},"要":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"隔":{"docs":{},"离":{"docs":{},"的":{"docs":{},"认":{"docs":{},"证":{"docs":{},"服":{"docs":{},"务":{"docs":{},"用":{"docs":{},"可":{"docs":{},"被":{"docs":{},"信":{"docs":{},"任":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"发":{"docs":{},"送":{"docs":{},"用":{"docs":{},"户":{"docs":{},"信":{"docs":{},"息":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"些":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"运":{"docs":{},"行":{"docs":{},"环":{"docs":{},"境":{"docs":{},"中":{"docs":{},"，":{"docs":{},"无":{"docs":{},"法":{"docs":{},"开":{"docs":{},"启":{"docs":{},"组":{"docs":{},"播":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"配":{"docs":{},"置":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"上":{"docs":{},"述":{"docs":{},"所":{"docs":{},"有":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"当":{"docs":{},"您":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"在":{"docs":{},"等":{"docs":{},"待":{"docs":{},"处":{"docs":{},"理":{"docs":{},"结":{"docs":{},"果":{"docs":{},"时":{"docs":{},"它":{"docs":{},"不":{"docs":{},"能":{"docs":{},"做":{"docs":{},"任":{"docs":{},"何":{"docs":{},"事":{"docs":{},"，":{"docs":{},"此":{"docs":{},"时":{"docs":{},"这":{"docs":{},"些":{"docs":{},"线":{"docs":{},"程":{"docs":{},"并":{"docs":{},"无":{"docs":{},"实":{"docs":{},"际":{"docs":{},"用":{"docs":{},"处":{"docs":{},"。":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"使":{"docs":{},"用":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"处":{"docs":{},"理":{"docs":{},"大":{"docs":{},"量":{"docs":{},"并":{"docs":{},"发":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"大":{"docs":{},"量":{"docs":{},"线":{"docs":{},"程":{"docs":{},"来":{"docs":{},"防":{"docs":{},"止":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"逐":{"docs":{},"步":{"docs":{},"停":{"docs":{},"止":{"docs":{},"运":{"docs":{},"转":{"docs":{},"。":{"docs":{},"所":{"docs":{},"需":{"docs":{},"的":{"docs":{},"内":{"docs":{},"存":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"栈":{"docs":{},"）":{"docs":{},"和":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"切":{"docs":{},"换":{"docs":{},"都":{"docs":{},"是":{"docs":{},"线":{"docs":{},"程":{"docs":{},"的":{"docs":{},"开":{"docs":{},"销":{"docs":{},"。":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"，":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"对":{"docs":{},"于":{"docs":{},"现":{"docs":{},"代":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"所":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"并":{"docs":{},"发":{"docs":{},"级":{"docs":{},"别":{"docs":{},"来":{"docs":{},"说":{"docs":{},"是":{"docs":{},"难":{"docs":{},"于":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"个":{"docs":{},"包":{"docs":{},"含":{"docs":{},"如":{"docs":{},"下":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"1":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"docs":{}}}}}},"如":{"docs":{},"果":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"一":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"路":{"docs":{},"径":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"值":{"docs":{},"应":{"docs":{},"该":{"docs":{},"与":{"docs":{},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"名":{"docs":{},"称":{"docs":{},"相":{"docs":{},"对":{"docs":{},"应":{"docs":{},"，":{"docs":{},"而":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"中":{"docs":{},"每":{"docs":{},"个":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"里":{"docs":{},"，":{"docs":{},"响":{"docs":{},"应":{"docs":{},"中":{"docs":{},"会":{"docs":{},"包":{"docs":{},"含":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"必":{"docs":{},"须":{"docs":{},"被":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"以":{"docs":{},"前":{"docs":{},"的":{"docs":{},"版":{"docs":{},"本":{"docs":{},"中":{"docs":{},"，":{"docs":{},"只":{"docs":{},"能":{"docs":{},"通":{"docs":{},"过":{"docs":{},"操":{"docs":{},"作":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"下":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"所":{"docs":{},"有":{"docs":{},"路":{"docs":{},"径":{"docs":{},"以":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"保":{"docs":{},"存":{"docs":{},"时":{"docs":{},"会":{"docs":{},"增":{"docs":{},"量":{"docs":{},"编":{"docs":{},"译":{"docs":{},"您":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"重":{"docs":{},"部":{"docs":{},"署":{"docs":{},"工":{"docs":{},"作":{"docs":{},"会":{"docs":{},"顺":{"docs":{},"利":{"docs":{},"进":{"docs":{},"行":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"出":{"docs":{},"现":{"docs":{},"错":{"docs":{},"误":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"通":{"docs":{},"知":{"docs":{},"中":{"docs":{},"将":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"，":{"docs":{},"该":{"docs":{},"异":{"docs":{},"常":{"docs":{},"会":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"说":{"docs":{},"明":{"docs":{},"为":{"docs":{},"何":{"docs":{},"失":{"docs":{},"败":{"docs":{},"的":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"。":{"docs":{},"此":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"可":{"docs":{},"用":{"docs":{},"于":{"docs":{},"更":{"docs":{},"详":{"docs":{},"细":{"docs":{},"检":{"docs":{},"查":{"docs":{},"原":{"docs":{},"因":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"分":{"docs":{},"块":{"docs":{},"模":{"docs":{},"式":{"docs":{},"下":{"docs":{},"，":{"docs":{},"您":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"响":{"docs":{},"应":{"docs":{},"的":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"每":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"单":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{},"中":{"docs":{},"写":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"并":{"docs":{},"结":{"docs":{},"束":{"docs":{},"请":{"docs":{},"求":{"docs":{},"（":{"docs":{},"直":{"docs":{},"接":{"docs":{},"发":{"docs":{},"送":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"环":{"docs":{},"境":{"docs":{},"中":{"docs":{},"（":{"docs":{},"如":{"docs":{},"：":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"台":{"docs":{},"计":{"docs":{},"算":{"docs":{},"机":{"docs":{},"上":{"docs":{},"运":{"docs":{},"行":{"docs":{},"两":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"启":{"docs":{},"动":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"时":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}},"多":{"docs":{},"数":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"使":{"docs":{},"用":{"docs":{},"被":{"docs":{},"称":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"个":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}},"容":{"docs":{},"器":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"您":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"配":{"docs":{},"置":{"docs":{},"公":{"docs":{},"共":{"docs":{},"主":{"docs":{},"机":{"docs":{},"和":{"docs":{},"端":{"docs":{},"口":{"docs":{},"号":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"应":{"docs":{},"答":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"中":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"开":{"docs":{},"发":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"方":{"docs":{},"便":{"docs":{},"在":{"docs":{},"文":{"docs":{},"件":{"docs":{},"更":{"docs":{},"改":{"docs":{},"时":{"docs":{},"实":{"docs":{},"时":{"docs":{},"重":{"docs":{},"新":{"docs":{},"部":{"docs":{},"署":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"循":{"docs":{},"环":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"长":{"docs":{},"时":{"docs":{},"间":{"docs":{},"逗":{"docs":{},"留":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"撤":{"docs":{},"销":{"docs":{},"时":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"文":{"docs":{},"件":{"docs":{},"已":{"docs":{},"满":{"docs":{},"时":{"docs":{},"会":{"docs":{},"暂":{"docs":{},"停":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"当":{"docs":{},"写":{"docs":{},"队":{"docs":{},"列":{"docs":{},"处":{"docs":{},"理":{"docs":{},"完":{"docs":{},"成":{"docs":{},"时":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"需":{"docs":{},"要":{"docs":{},"取":{"docs":{},"消":{"docs":{},"暂":{"docs":{},"停":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"启":{"docs":{},"用":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"/":{"docs":{},"t":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"处":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"（":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"端":{"docs":{},"）":{"docs":{},"注":{"docs":{},"册":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{},"单":{"docs":{},"机":{"docs":{},"模":{"docs":{},"式":{"docs":{},"下":{"docs":{},"这":{"docs":{},"就":{"docs":{},"足":{"docs":{},"够":{"docs":{},"了":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"器":{"docs":{},"上":{"docs":{},"创":{"docs":{},"建":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"消":{"docs":{},"费":{"docs":{},"端":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"手":{"docs":{},"动":{"docs":{},"获":{"docs":{},"取":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}},"第":{"docs":{},"一":{"docs":{},"步":{"docs":{},"要":{"docs":{},"做":{"docs":{},"的":{"docs":{},"事":{"docs":{},"情":{"docs":{},"就":{"docs":{},"是":{"docs":{},"查":{"docs":{},"找":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"查":{"docs":{},"找":{"docs":{},"并":{"docs":{},"获":{"docs":{},"取":{"docs":{},"一":{"docs":{},"条":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"获":{"docs":{},"取":{"docs":{},"一":{"docs":{},"批":{"docs":{},"满":{"docs":{},"足":{"docs":{},"条":{"docs":{},"件":{"docs":{},"的":{"docs":{},"记":{"docs":{},"录":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"是":{"docs":{},"获":{"docs":{},"取":{"docs":{},"一":{"docs":{},"条":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"第":{"docs":{},"一":{"docs":{},"条":{"docs":{},"满":{"docs":{},"足":{"docs":{},"条":{"docs":{},"件":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"和":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"有":{"docs":{},"限":{"docs":{},"制":{"docs":{},"的":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"使":{"docs":{},"得":{"docs":{},"转":{"docs":{},"化":{"docs":{},"为":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"某":{"docs":{},"些":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"（":{"docs":{},"例":{"docs":{},"：":{"docs":{},"若":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"很":{"docs":{},"小":{"docs":{},"）":{"docs":{},"，":{"docs":{},"您":{"docs":{},"将":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"这":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"聚":{"docs":{},"合":{"docs":{},"到":{"docs":{},"内":{"docs":{},"存":{"docs":{},"中":{"docs":{},"，":{"docs":{},"以":{"docs":{},"便":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"按":{"docs":{},"照":{"docs":{},"下":{"docs":{},"边":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"进":{"docs":{},"行":{"docs":{},"聚":{"docs":{},"合":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"特":{"docs":{},"殊":{"docs":{},"的":{"docs":{},"运":{"docs":{},"行":{"docs":{},"环":{"docs":{},"境":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"无":{"docs":{},"法":{"docs":{},"使":{"docs":{},"用":{"docs":{},"组":{"docs":{},"播":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"应":{"docs":{},"该":{"docs":{},"配":{"docs":{},"置":{"docs":{},"其":{"docs":{},"他":{"docs":{},"网":{"docs":{},"络":{"docs":{},"传":{"docs":{},"输":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"在":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"在":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}}}}}}}}}}},"多":{"docs":{},"播":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"应":{"docs":{},"该":{"docs":{},"配":{"docs":{},"置":{"docs":{},"其":{"docs":{},"他":{"docs":{},"网":{"docs":{},"络":{"docs":{},"传":{"docs":{},"输":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"在":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"终":{"docs":{},"端":{"docs":{},"运":{"docs":{},"行":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"三":{"docs":{},"个":{"docs":{},"控":{"docs":{},"制":{"docs":{},"台":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"启":{"docs":{},"动":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"二":{"docs":{},"个":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"终":{"docs":{},"端":{"docs":{},"中":{"docs":{},"，":{"docs":{},"让":{"docs":{},"我":{"docs":{},"们":{"docs":{},"使":{"docs":{},"用":{"docs":{},"相":{"docs":{},"同":{"docs":{},"组":{"docs":{},"运":{"docs":{},"行":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"种":{"docs":{},"写":{"docs":{},"法":{"docs":{},"中":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"释":{"docs":{},"放":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}},"编":{"docs":{},"写":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"被":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"时":{"docs":{},"就":{"docs":{},"不":{"docs":{},"能":{"docs":{},"做":{"docs":{},"任":{"docs":{},"何":{"docs":{},"事":{"docs":{},"情":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"/":{"docs":{},"响":{"docs":{},"应":{"docs":{},"期":{"docs":{},"间":{"docs":{},"随":{"docs":{},"时":{"docs":{},"支":{"docs":{},"持":{"docs":{},"流":{"docs":{},"重":{"docs":{},"置":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}},"中":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"的":{"docs":{},"生":{"docs":{},"命":{"docs":{},"周":{"docs":{},"期":{"docs":{},"中":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"路":{"docs":{},"由":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"中":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"预":{"docs":{},"填":{"docs":{},"充":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"单":{"docs":{},"元":{"docs":{},"/":{"docs":{},"集":{"docs":{},"成":{"docs":{},"测":{"docs":{},"试":{"docs":{},"或":{"docs":{},"是":{"docs":{},"运":{"docs":{},"行":{"docs":{},"开":{"docs":{},"发":{"docs":{},"版":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"时":{"docs":{},"都":{"docs":{},"经":{"docs":{},"常":{"docs":{},"需":{"docs":{},"要":{"docs":{},"自":{"docs":{},"签":{"docs":{},"名":{"docs":{},"证":{"docs":{},"书":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"部":{"docs":{},"署":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"都":{"docs":{},"会":{"docs":{},"被":{"docs":{},"分":{"docs":{},"配":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"中":{"docs":{},"告":{"docs":{},"诉":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"监":{"docs":{},"听":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"主":{"docs":{},"机":{"docs":{},"和":{"docs":{},"端":{"docs":{},"口":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"文":{"docs":{},"件":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"下":{"docs":{},"的":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"所":{"docs":{},"有":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"里":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"拒":{"docs":{},"绝":{"docs":{},"掉":{"docs":{},"了":{"docs":{},"所":{"docs":{},"有":{"docs":{},"经":{"docs":{},"过":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"并":{"docs":{},"且":{"docs":{},"包":{"docs":{},"含":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"会":{"docs":{},"被":{"docs":{},"路":{"docs":{},"径":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},"完":{"docs":{},"服":{"docs":{},"务":{"docs":{},"后":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"释":{"docs":{},"放":{"docs":{},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"才":{"docs":{},"能":{"docs":{},"清":{"docs":{},"理":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"和":{"docs":{},"更":{"docs":{},"新":{"docs":{},"服":{"docs":{},"务":{"docs":{},"使":{"docs":{},"用":{"docs":{},"状":{"docs":{},"态":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"匹":{"docs":{},"配":{"docs":{},"时":{"docs":{},"会":{"docs":{},"被":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"完":{"docs":{},"成":{"docs":{},"后":{"docs":{},"会":{"docs":{},"话":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"回":{"docs":{},"写":{"docs":{},"到":{"docs":{},"存":{"docs":{},"储":{"docs":{},"中":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"域":{"docs":{},"名":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"处":{"docs":{},"理":{"docs":{},"这":{"docs":{},"个":{"docs":{},"错":{"docs":{},"误":{"docs":{},"时":{"docs":{},"，":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}},"大":{"docs":{},"数":{"docs":{},"据":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"时":{"docs":{},"，":{"docs":{},"不":{"docs":{},"建":{"docs":{},"议":{"docs":{},"使":{"docs":{},"用":{"docs":{},"上":{"docs":{},"面":{"docs":{},"提":{"docs":{},"到":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"数":{"docs":{},"据":{"docs":{},"流":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"流":{"docs":{},"式":{"docs":{},"数":{"docs":{},"据":{"docs":{},"方":{"docs":{},"面":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"通":{"docs":{},"过":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"您":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"中":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"应":{"docs":{},"用":{"docs":{},"中":{"docs":{},"处":{"docs":{},"理":{"docs":{},"认":{"docs":{},"证":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"消":{"docs":{},"费":{"docs":{},"时":{"docs":{},"用":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"认":{"docs":{},"证":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"时":{"docs":{},"可":{"docs":{},"以":{"docs":{},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"访":{"docs":{},"问":{"docs":{},"资":{"docs":{},"源":{"docs":{},"时":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"权":{"docs":{},"限":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"连":{"docs":{},"接":{"docs":{},"打":{"docs":{},"开":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"什":{"docs":{},"么":{"docs":{},"也":{"docs":{},"做":{"docs":{},"不":{"docs":{},"了":{"docs":{},"。":{"docs":{},"当":{"docs":{},"它":{"docs":{},"打":{"docs":{},"开":{"docs":{},"后":{"docs":{},"，":{"docs":{},"会":{"docs":{},"回":{"docs":{},"调":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}},"顺":{"docs":{},"序":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"，":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"y":{"docs":{},"以":{"docs":{},"及":{"docs":{},"k":{"docs":{},"o":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"语":{"docs":{},"言":{"docs":{},"中":{"docs":{},"，":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"可":{"docs":{},"被":{"docs":{},"解":{"docs":{},"码":{"docs":{},"映":{"docs":{},"射":{"docs":{},"成":{"docs":{},"p":{"docs":{},"o":{"docs":{},"j":{"docs":{},"o":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"亦":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}},"大":{"docs":{},"部":{"docs":{},"分":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"会":{"docs":{},"希":{"docs":{},"望":{"docs":{},"在":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"对":{"docs":{},"象":{"docs":{},"之":{"docs":{},"间":{"docs":{},"共":{"docs":{},"享":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"。":{"docs":{},"但":{"docs":{},"有":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"却":{"docs":{},"恰":{"docs":{},"恰":{"docs":{},"相":{"docs":{},"反":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"之":{"docs":{},"间":{"docs":{},"共":{"docs":{},"享":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"。":{"docs":{},"但":{"docs":{},"有":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"却":{"docs":{},"恰":{"docs":{},"恰":{"docs":{},"相":{"docs":{},"反":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"完":{"docs":{},"成":{"docs":{},"后":{"docs":{},"就":{"docs":{},"会":{"docs":{},"开":{"docs":{},"始":{"docs":{},"发":{"docs":{},"射":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{},"更":{"docs":{},"进":{"docs":{},"一":{"docs":{},"步":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"请":{"docs":{},"查":{"docs":{},"阅":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}},"常":{"docs":{},"规":{"docs":{},"应":{"docs":{},"用":{"docs":{},"中":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}},"打":{"docs":{},"包":{"docs":{},"成":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},"表":{"docs":{},"中":{"docs":{},"插":{"docs":{},"入":{"docs":{},"新":{"docs":{},"数":{"docs":{},"据":{"docs":{},"时":{"docs":{},"，":{"docs":{},"您":{"docs":{},"也":{"docs":{},"许":{"docs":{},"希":{"docs":{},"望":{"docs":{},"获":{"docs":{},"得":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"的":{"docs":{},"自":{"docs":{},"增":{"docs":{},"长":{"docs":{},"i":{"docs":{},"d":{"docs":{},"。":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"决":{"docs":{},"定":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"w":{"docs":{},"t":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"重":{"docs":{},"点":{"docs":{},"注":{"docs":{},"意":{"docs":{},"的":{"docs":{},"是":{"docs":{},"j":{"docs":{},"w":{"docs":{},"t":{"docs":{},"并":{"docs":{},"不":{"docs":{},"加":{"docs":{},"密":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"，":{"docs":{},"它":{"docs":{},"仅":{"docs":{},"对":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"签":{"docs":{},"名":{"docs":{},"。":{"docs":{},"你":{"docs":{},"不":{"docs":{},"应":{"docs":{},"该":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"w":{"docs":{},"t":{"docs":{},"发":{"docs":{},"送":{"docs":{},"任":{"docs":{},"何":{"docs":{},"私":{"docs":{},"密":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"相":{"docs":{},"反":{"docs":{},"你":{"docs":{},"应":{"docs":{},"该":{"docs":{},"发":{"docs":{},"送":{"docs":{},"是":{"docs":{},"不":{"docs":{},"是":{"docs":{},"私":{"docs":{},"密":{"docs":{},"的":{"docs":{},"但":{"docs":{},"要":{"docs":{},"被":{"docs":{},"验":{"docs":{},"证":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{},"举":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"w":{"docs":{},"t":{"docs":{},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"个":{"docs":{},"签":{"docs":{},"名":{"docs":{},"过":{"docs":{},"的":{"docs":{},"用":{"docs":{},"户":{"docs":{},"i":{"docs":{},"d":{"docs":{},"来":{"docs":{},"表":{"docs":{},"明":{"docs":{},"这":{"docs":{},"个":{"docs":{},"用":{"docs":{},"户":{"docs":{},"已":{"docs":{},"经":{"docs":{},"登":{"docs":{},"录":{"docs":{},"了":{"docs":{},"的":{"docs":{},"做":{"docs":{},"法":{"docs":{},"非":{"docs":{},"常":{"docs":{},"对":{"docs":{},"的":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"户":{"docs":{},"的":{"docs":{},"密":{"docs":{},"码":{"docs":{},"的":{"docs":{},"做":{"docs":{},"法":{"docs":{},"是":{"docs":{},"非":{"docs":{},"常":{"docs":{},"非":{"docs":{},"常":{"docs":{},"错":{"docs":{},"误":{"docs":{},"的":{"docs":{},"。":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"验":{"docs":{},"证":{"docs":{},"的":{"docs":{},"终":{"docs":{},"点":{"docs":{},"上":{"docs":{},"，":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"你":{"docs":{},"通":{"docs":{},"过":{"docs":{},"它":{"docs":{},"的":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"/":{"docs":{},"密":{"docs":{},"码":{"docs":{},"验":{"docs":{},"证":{"docs":{},"了":{"docs":{},"用":{"docs":{},"户":{"docs":{},"的":{"docs":{},"i":{"docs":{},"d":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"构":{"docs":{},"造":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},")":{"docs":{},"发":{"docs":{},"生":{"docs":{},"时":{"docs":{},"，":{"docs":{},"作":{"docs":{},"为":{"docs":{},"异":{"docs":{},"步":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"建":{"docs":{},"工":{"docs":{},"具":{"docs":{},"中":{"docs":{},"添":{"docs":{},"加":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"即":{"docs":{},"可":{"docs":{},"：":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}},"另":{"docs":{},"外":{"docs":{},"的":{"docs":{},"发":{"docs":{},"布":{"docs":{},"者":{"docs":{},"上":{"docs":{},"注":{"docs":{},"册":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"者":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}},"可":{"docs":{},"写":{"docs":{},"流":{"docs":{},"上":{"docs":{},"注":{"docs":{},"册":{"docs":{},"另":{"docs":{},"外":{"docs":{},"的":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"者":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}},"手":{"docs":{},"动":{"docs":{},"处":{"docs":{},"理":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}},"此":{"docs":{},"，":{"docs":{},"通":{"docs":{},"往":{"docs":{},"自":{"docs":{},"由":{"docs":{},"之":{"docs":{},"路":{"docs":{},"的":{"docs":{},"功":{"docs":{},"臣":{"docs":{},"乃":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}},"绝":{"docs":{},"大":{"docs":{},"多":{"docs":{},"数":{"docs":{},"地":{"docs":{},"方":{"docs":{},"使":{"docs":{},"用":{"docs":{},"回":{"docs":{},"调":{"docs":{},"(":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"它":{"docs":{},"也":{"docs":{},"支":{"docs":{},"持":{"docs":{},"r":{"docs":{},"x":{"docs":{},")":{"docs":{},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}},"前":{"docs":{},"面":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"，":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"是":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"你":{"docs":{},"期":{"docs":{},"望":{"docs":{},"获":{"docs":{},"得":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"语":{"docs":{},"言":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"可":{"docs":{},"以":{"docs":{},"直":{"docs":{},"接":{"docs":{},"用":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"而":{"docs":{},"其":{"docs":{},"他":{"docs":{},"语":{"docs":{},"言":{"docs":{},"中":{"docs":{},"，":{"docs":{},"你":{"docs":{},"必":{"docs":{},"须":{"docs":{},"传":{"docs":{},"递":{"docs":{},"对":{"docs":{},"象":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"事":{"docs":{},"件":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"中":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}},"后":{"docs":{},"续":{"docs":{},"章":{"docs":{},"节":{"docs":{},"会":{"docs":{},"将":{"docs":{},"更":{"docs":{},"加":{"docs":{},"详":{"docs":{},"细":{"docs":{},"的":{"docs":{},"重":{"docs":{},"载":{"docs":{},"规":{"docs":{},"则":{"docs":{},"和":{"docs":{},"其":{"docs":{},"他":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"一":{"docs":{},"展":{"docs":{},"现":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"每":{"docs":{},"一":{"docs":{},"次":{"docs":{},"重":{"docs":{},"新":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"间":{"docs":{},"隔":{"docs":{},"（":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}},"当":{"docs":{},"前":{"docs":{},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}},"排":{"docs":{},"除":{"docs":{},"故":{"docs":{},"障":{"docs":{},"时":{"docs":{},"，":{"docs":{},"开":{"docs":{},"启":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"j":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},"日":{"docs":{},"志":{"docs":{},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"给":{"docs":{},"予":{"docs":{},"很":{"docs":{},"大":{"docs":{},"的":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"。":{"docs":{},"在":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"组":{"docs":{},"件":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}},"安":{"docs":{},"装":{"docs":{"./":{"ref":"./","tf":0.02564102564102564}}},"全":{"docs":{},"注":{"docs":{},"意":{"docs":{},"事":{"docs":{},"项":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"说":{"docs":{},"明":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"的":{"docs":{},"桥":{"docs":{},"接":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"官":{"docs":{},"方":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.01282051282051282},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}},"中":{"docs":{},"文":{"docs":{},"翻":{"docs":{},"译":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}},"的":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}},"翻":{"docs":{},"译":{"docs":{},"工":{"docs":{},"作":{"docs":{},"计":{"docs":{},"划":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}},"网":{"docs":{},"站":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"归":{"docs":{},"属":{"docs":{},"与":{"docs":{},"发":{"docs":{},"布":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}},"当":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281},"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"前":{"docs":{},"文":{"docs":{},"档":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"对":{"docs":{},"应":{"docs":{},"版":{"docs":{},"本":{"docs":{},"：":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}}}},"只":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}},"的":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}},"进":{"docs":{},"度":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"被":{"docs":{},"设":{"docs":{},"置":{"docs":{},"时":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"该":{"docs":{},"选":{"docs":{},"项":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"启":{"docs":{},"用":{"docs":{},"h":{"docs":{},"a":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"，":{"docs":{},"若":{"docs":{},"一":{"docs":{},"个":{"docs":{},"运":{"docs":{},"行":{"docs":{},"了":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"找":{"docs":{},"不":{"docs":{},"到":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"上":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"从":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{},"解":{"docs":{},"析":{"docs":{},"该":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"路":{"docs":{},"径":{"docs":{},"不":{"docs":{},"以":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"消":{"docs":{},"息":{"docs":{},"达":{"docs":{},"到":{"docs":{},"您":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"该":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"以":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"抛":{"docs":{},"出":{"docs":{},"异":{"docs":{},"常":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"通":{"docs":{},"过":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"到":{"docs":{},"达":{"docs":{},"时":{"docs":{},"，":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"令":{"docs":{},"牌":{"docs":{},"过":{"docs":{},"期":{"docs":{},"后":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"刷":{"docs":{},"新":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"，":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"访":{"docs":{},"问":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"类":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"，":{"docs":{},"它":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"很":{"docs":{},"多":{"docs":{},"实":{"docs":{},"用":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"过":{"docs":{},"期":{"docs":{},"过":{"docs":{},"后":{"docs":{},"对":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"进":{"docs":{},"行":{"docs":{},"刷":{"docs":{},"新":{"docs":{},"。":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"从":{"docs":{},"报":{"docs":{},"文":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{},"到":{"docs":{},"响":{"docs":{},"应":{"docs":{},"头":{"docs":{},"时":{"docs":{},"，":{"docs":{},"响":{"docs":{},"应":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"就":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"收":{"docs":{},"到":{"docs":{},"的":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"高":{"docs":{},"可":{"docs":{},"用":{"docs":{},"功":{"docs":{},"能":{"docs":{},"时":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"能":{"docs":{},"需":{"docs":{},"要":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"实":{"docs":{},"例":{"docs":{},"时":{"docs":{},"，":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"选":{"docs":{},"择":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"h":{"docs":{},"a":{"docs":{},"组":{"docs":{},"。":{"docs":{},"h":{"docs":{},"a":{"docs":{},"组":{"docs":{},"表":{"docs":{},"示":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"的":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"节":{"docs":{},"点":{"docs":{},"组":{"docs":{},"。":{"docs":{},"只":{"docs":{},"有":{"docs":{},"具":{"docs":{},"有":{"docs":{},"相":{"docs":{},"同":{"docs":{},"h":{"docs":{},"a":{"docs":{},"组":{"docs":{},"的":{"docs":{},"节":{"docs":{},"点":{"docs":{},"能":{"docs":{},"执":{"docs":{},"行":{"docs":{},"故":{"docs":{},"障":{"docs":{},"转":{"docs":{},"移":{"docs":{},"。":{"docs":{},"若":{"docs":{},"不":{"docs":{},"指":{"docs":{},"定":{"docs":{},"h":{"docs":{},"a":{"docs":{},"组":{"docs":{},"，":{"docs":{},"则":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"组":{"docs":{},"_":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"_":{"docs":{},"_":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"传":{"docs":{},"统":{"docs":{},"的":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"做":{"docs":{},"以":{"docs":{},"下":{"docs":{},"操":{"docs":{},"作":{"docs":{},"时":{"docs":{},"，":{"docs":{},"调":{"docs":{},"用":{"docs":{},"线":{"docs":{},"程":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"被":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"字":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"许":{"docs":{},"多":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"名":{"docs":{},"称":{"docs":{},"部":{"docs":{},"署":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"通":{"docs":{},"过":{"docs":{},"名":{"docs":{},"称":{"docs":{},"来":{"docs":{},"选":{"docs":{},"择":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"于":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"搜":{"docs":{},"索":{"docs":{},"域":{"docs":{},"列":{"docs":{},"表":{"docs":{},"时":{"docs":{},"，":{"docs":{},"点":{"docs":{},"数":{"docs":{},"的":{"docs":{},"阈":{"docs":{},"值":{"docs":{},"为":{"1":{"docs":{},"，":{"docs":{},"或":{"docs":{},"从":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"x":{"docs":{},"上":{"docs":{},"的":{"docs":{},"/":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"加":{"docs":{},"载":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}},"隔":{"docs":{},"离":{"docs":{},"组":{"docs":{},"时":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"这":{"docs":{},"种":{"docs":{},"实":{"docs":{},"现":{"docs":{},"作":{"docs":{},"为":{"docs":{},"认":{"docs":{},"证":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"认":{"docs":{},"证":{"docs":{},"信":{"docs":{},"息":{"docs":{},"里":{"docs":{},"获":{"docs":{},"取":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"和":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"：":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"过":{"docs":{},"滤":{"docs":{},"器":{"docs":{},"，":{"docs":{},"设":{"docs":{},"置":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"属":{"docs":{},"性":{"docs":{},"为":{"docs":{},"你":{"docs":{},"想":{"docs":{},"要":{"docs":{},"的":{"docs":{},"值":{"docs":{},"（":{"docs":{},"或":{"docs":{},"者":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"过":{"docs":{},"滤":{"docs":{},"器":{"docs":{},"，":{"docs":{},"将":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"完":{"docs":{},"后":{"docs":{},"，":{"docs":{},"释":{"docs":{},"放":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"如":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}},"描":{"docs":{},"述":{"docs":{},"符":{"docs":{},"来":{"docs":{},"部":{"docs":{},"署":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"时":{"docs":{},"，":{"docs":{},"任":{"docs":{},"何":{"docs":{},"属":{"docs":{},"性":{"docs":{},"如":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"等":{"docs":{},"不":{"docs":{},"能":{"docs":{},"被":{"docs":{},"在":{"docs":{},"部":{"docs":{},"署":{"docs":{},"时":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{},"部":{"docs":{},"署":{"docs":{},"参":{"docs":{},"数":{"docs":{},"所":{"docs":{},"覆":{"docs":{},"盖":{"docs":{},"。":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"d":{"docs":{},"p":{"docs":{},"时":{"docs":{},"，":{"docs":{},"i":{"docs":{},"p":{"docs":{},"多":{"docs":{},"播":{"docs":{},"是":{"docs":{},"必":{"docs":{},"需":{"docs":{},"的":{"docs":{},"，":{"docs":{},"在":{"docs":{},"一":{"docs":{},"些":{"docs":{},"系":{"docs":{},"统":{"docs":{},"中":{"docs":{},"，":{"docs":{},"多":{"docs":{},"播":{"docs":{},"路":{"docs":{},"由":{"docs":{},"需":{"docs":{},"要":{"docs":{},"被":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"路":{"docs":{},"由":{"docs":{},"表":{"docs":{},"中":{"docs":{},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{},"，":{"docs":{},"缺":{"docs":{},"省":{"docs":{},"路":{"docs":{},"由":{"docs":{},"将":{"docs":{},"被":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"有":{"docs":{},"些":{"docs":{},"系":{"docs":{},"统":{"docs":{},"并":{"docs":{},"不":{"docs":{},"适":{"docs":{},"用":{"docs":{},"路":{"docs":{},"由":{"docs":{},"表":{"docs":{},"中":{"docs":{},"的":{"docs":{},"i":{"docs":{},"p":{"docs":{},"组":{"docs":{},"播":{"docs":{},"路":{"docs":{},"由":{"docs":{},"，":{"docs":{},"只":{"docs":{},"为":{"docs":{},"单":{"docs":{},"播":{"docs":{},"路":{"docs":{},"由":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"关":{"docs":{},"闭":{"docs":{},"操":{"docs":{},"作":{"docs":{},"完":{"docs":{},"成":{"docs":{},"后":{"docs":{},"，":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"将":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"时":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"对":{"docs":{},"象":{"docs":{},"来":{"docs":{},"设":{"docs":{},"置":{"docs":{},"多":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"以":{"docs":{},"更":{"docs":{},"改":{"docs":{},"它":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"（":{"docs":{},"属":{"docs":{},"性":{"docs":{},"）":{"docs":{},"列":{"docs":{},"在":{"docs":{},"这":{"docs":{},"儿":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"送":{"docs":{},"带":{"docs":{},"有":{"docs":{},"应":{"docs":{},"答":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"为":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}},"启":{"docs":{},"用":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"管":{"docs":{},"道":{"docs":{},"时":{"docs":{},"，":{"docs":{},"请":{"docs":{},"求":{"docs":{},"可":{"docs":{},"以":{"docs":{},"不":{"docs":{},"等":{"docs":{},"待":{"docs":{},"以":{"docs":{},"前":{"docs":{},"的":{"docs":{},"响":{"docs":{},"应":{"docs":{},"返":{"docs":{},"回":{"docs":{},"而":{"docs":{},"写":{"docs":{},"入":{"docs":{},"到":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"创":{"docs":{},"建":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"，":{"docs":{},"若":{"docs":{},"存":{"docs":{},"在":{"docs":{},"少":{"docs":{},"于":{"docs":{},"已":{"docs":{},"经":{"docs":{},"为":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"创":{"docs":{},"建":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"连":{"docs":{},"接":{"docs":{},"数":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"高":{"docs":{},"可":{"docs":{},"用":{"docs":{},"方":{"docs":{},"式":{"docs":{},"时":{"docs":{},"，":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"追":{"docs":{},"加":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"的":{"docs":{},"某":{"docs":{},"部":{"docs":{},"分":{"docs":{},"（":{"docs":{},"数":{"docs":{},"据":{"docs":{},"）":{"docs":{},"到":{"docs":{},"达":{"docs":{},"时":{"docs":{},"，":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"结":{"docs":{},"束":{"docs":{},"时":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"果":{"docs":{},"较":{"docs":{},"大":{"docs":{},"时":{"docs":{},"，":{"docs":{},"请":{"docs":{},"使":{"docs":{},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}},"被":{"docs":{},"成":{"docs":{},"功":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"触":{"docs":{},"发":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"网":{"docs":{},"络":{"docs":{},"上":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"多":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"收":{"docs":{},"到":{"1":{"0":{"0":{"docs":{},"响":{"docs":{},"应":{"docs":{},"代":{"docs":{},"码":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"发":{"docs":{},"送":{"docs":{},"剩":{"docs":{},"余":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}},"连":{"docs":{},"接":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"并":{"docs":{},"使":{"docs":{},"用":{"docs":{},"超":{"docs":{},"过":{"docs":{},"一":{"docs":{},"个":{"docs":{},"连":{"docs":{},"接":{"docs":{},"时":{"docs":{},"，":{"docs":{},"则":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"2":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"试":{"docs":{},"图":{"docs":{},"注":{"docs":{},"册":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"时":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"该":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"销":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"时":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"该":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"想":{"docs":{},"要":{"docs":{},"申":{"docs":{},"请":{"docs":{},"访":{"docs":{},"问":{"docs":{},"控":{"docs":{},"制":{"docs":{},"之":{"docs":{},"下":{"docs":{},"受":{"docs":{},"保":{"docs":{},"护":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"时":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"其":{"docs":{},"他":{"docs":{},"资":{"docs":{},"源":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"者":{"docs":{},"先":{"docs":{},"前":{"docs":{},"被":{"docs":{},"授":{"docs":{},"权":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"托":{"docs":{},"管":{"docs":{},"时":{"docs":{},"（":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"超":{"docs":{},"出":{"docs":{},"了":{"docs":{},"本":{"docs":{},"文":{"docs":{},"范":{"docs":{},"畴":{"docs":{},"）":{"docs":{},"，":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"证":{"docs":{},"书":{"docs":{},"（":{"docs":{},"或":{"docs":{},"者":{"docs":{},"其":{"docs":{},"他":{"docs":{},"表":{"docs":{},"示":{"docs":{},"认":{"docs":{},"证":{"docs":{},"含":{"docs":{},"义":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"）":{"docs":{},"申":{"docs":{},"请":{"docs":{},"访":{"docs":{},"问":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"。":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"创":{"docs":{},"建":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"尝":{"docs":{},"试":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"指":{"docs":{},"定":{"docs":{},"名":{"docs":{},"称":{"docs":{},"元":{"docs":{},"素":{"docs":{},"获":{"docs":{},"取":{"docs":{},"a":{"docs":{},"（":{"docs":{},"i":{"docs":{},"p":{"docs":{},"v":{"4":{"docs":{},"）":{"docs":{},"或":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"帧":{"docs":{},"到":{"docs":{},"达":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"给":{"docs":{},"帧":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"并":{"docs":{},"调":{"docs":{},"用":{"docs":{},"它":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"建":{"docs":{},"立":{"docs":{},"连":{"docs":{},"接":{"docs":{},"时":{"docs":{},"，":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"交":{"docs":{},"换":{"docs":{},"初":{"docs":{},"始":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"初":{"docs":{},"始":{"docs":{},"设":{"docs":{},"置":{"docs":{},"由":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"上":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"写":{"docs":{},"入":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"，":{"docs":{},"第":{"docs":{},"一":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"在":{"docs":{},"与":{"docs":{},"现":{"docs":{},"有":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"主":{"docs":{},"机":{"docs":{},"和":{"docs":{},"端":{"docs":{},"口":{"docs":{},"上":{"docs":{},"部":{"docs":{},"署":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"实":{"docs":{},"例":{"docs":{},"时":{"docs":{},"，":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"它":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"创":{"docs":{},"建":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"主":{"docs":{},"机":{"docs":{},"/":{"docs":{},"端":{"docs":{},"口":{"docs":{},"上":{"docs":{},"侦":{"docs":{},"听":{"docs":{},"的":{"docs":{},"新":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"希":{"docs":{},"望":{"docs":{},"限":{"docs":{},"制":{"docs":{},"每":{"docs":{},"个":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"多":{"docs":{},"路":{"docs":{},"复":{"docs":{},"用":{"docs":{},"流":{"docs":{},"数":{"docs":{},"量":{"docs":{},"而":{"docs":{},"使":{"docs":{},"用":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"单":{"docs":{},"个":{"docs":{},"连":{"docs":{},"接":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"想":{"docs":{},"要":{"docs":{},"在":{"docs":{},"任":{"docs":{},"何":{"docs":{},"时":{"docs":{},"间":{"docs":{},"只":{"docs":{},"在":{"docs":{},"集":{"docs":{},"群":{"docs":{},"一":{"docs":{},"个":{"docs":{},"节":{"docs":{},"点":{"docs":{},"上":{"docs":{},"执":{"docs":{},"行":{"docs":{},"某":{"docs":{},"些":{"docs":{},"操":{"docs":{},"作":{"docs":{},"或":{"docs":{},"访":{"docs":{},"问":{"docs":{},"资":{"docs":{},"源":{"docs":{},"时":{"docs":{},"，":{"docs":{},"这":{"docs":{},"很":{"docs":{},"有":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"完":{"docs":{},"锁":{"docs":{},"后":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"编":{"docs":{},"辑":{"docs":{},"资":{"docs":{},"源":{"docs":{},"（":{"docs":{},"如":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"、":{"docs":{},"c":{"docs":{},"s":{"docs":{},"s":{"docs":{},"或":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"）":{"docs":{},"时":{"docs":{},"，":{"docs":{},"这":{"docs":{},"种":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"机":{"docs":{},"制":{"docs":{},"可":{"docs":{},"能":{"docs":{},"令":{"docs":{},"人":{"docs":{},"讨":{"docs":{},"厌":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"提":{"docs":{},"供":{"docs":{},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"版":{"docs":{},"本":{"docs":{},"（":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"若":{"docs":{},"您":{"docs":{},"想":{"docs":{},"重":{"docs":{},"新":{"docs":{},"加":{"docs":{},"载":{"docs":{},"页":{"docs":{},"面":{"docs":{},"，":{"docs":{},"则":{"docs":{},"不":{"docs":{},"会":{"docs":{},"看":{"docs":{},"到":{"docs":{},"您":{"docs":{},"的":{"docs":{},"编":{"docs":{},"辑":{"docs":{},"改":{"docs":{},"变":{"docs":{},"）":{"docs":{},"。":{"docs":{},"要":{"docs":{},"避":{"docs":{},"免":{"docs":{},"此":{"docs":{},"行":{"docs":{},"为":{"docs":{},"，":{"docs":{},"请":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"获":{"docs":{},"取":{"docs":{},"了":{"docs":{},"这":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"连":{"docs":{},"接":{"docs":{},"，":{"docs":{},"其":{"docs":{},"自":{"docs":{},"动":{"docs":{},"提":{"docs":{},"交":{"docs":{},"选":{"docs":{},"项":{"docs":{},"（":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"监":{"docs":{},"听":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"地":{"docs":{},"址":{"docs":{},"和":{"docs":{},"端":{"docs":{},"口":{"docs":{},"时":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"像":{"docs":{},"下":{"docs":{},"边":{"docs":{},"这":{"docs":{},"样":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"更":{"docs":{},"改":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"会":{"docs":{},"话":{"docs":{},"存":{"docs":{},"储":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"会":{"docs":{},"话":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"并":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"很":{"docs":{},"多":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"合":{"docs":{},"理":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"是":{"docs":{},"将":{"docs":{},"它":{"docs":{},"们":{"docs":{},"分":{"docs":{},"隔":{"docs":{},"为":{"docs":{},"多":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"当":{"docs":{},"前":{"docs":{},"流":{"docs":{},"已":{"docs":{},"经":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"并":{"docs":{},"且":{"docs":{},"可":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"连":{"docs":{},"接":{"docs":{},"时":{"docs":{},"，":{"docs":{},"s":{"docs":{},"h":{"docs":{},"u":{"docs":{},"t":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"帧":{"docs":{},"时":{"docs":{},"，":{"docs":{},"不":{"docs":{},"论":{"docs":{},"请":{"docs":{},"求":{"docs":{},"是":{"docs":{},"否":{"docs":{},"暂":{"docs":{},"停":{"docs":{},"，":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"帧":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"都":{"docs":{},"将":{"docs":{},"立":{"docs":{},"即":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"者":{"docs":{},"收":{"docs":{},"到":{"docs":{},"消":{"docs":{},"息":{"docs":{},"并":{"docs":{},"且":{"docs":{},"已":{"docs":{},"经":{"docs":{},"被":{"docs":{},"处":{"docs":{},"理":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"选":{"docs":{},"择":{"docs":{},"性":{"docs":{},"决":{"docs":{},"定":{"docs":{},"回":{"docs":{},"复":{"docs":{},"该":{"docs":{},"消":{"docs":{},"息":{"docs":{},"，":{"docs":{},"若":{"docs":{},"选":{"docs":{},"择":{"docs":{},"回":{"docs":{},"复":{"docs":{},"则":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"的":{"docs":{},"应":{"docs":{},"答":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"当":{"docs":{},"发":{"docs":{},"送":{"docs":{},"者":{"docs":{},"收":{"docs":{},"到":{"docs":{},"回":{"docs":{},"复":{"docs":{},"消":{"docs":{},"息":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"回":{"docs":{},"复":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"过":{"docs":{},"程":{"docs":{},"可":{"docs":{},"以":{"docs":{},"不":{"docs":{},"断":{"docs":{},"重":{"docs":{},"复":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"可":{"docs":{},"以":{"docs":{},"允":{"docs":{},"许":{"docs":{},"在":{"docs":{},"两":{"docs":{},"个":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"整":{"docs":{},"个":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"被":{"docs":{},"完":{"docs":{},"全":{"docs":{},"读":{"docs":{},"取":{"docs":{},"或":{"docs":{},"者":{"docs":{},"无":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"的":{"docs":{},"响":{"docs":{},"应":{"docs":{},"头":{"docs":{},"被":{"docs":{},"完":{"docs":{},"全":{"docs":{},"读":{"docs":{},"取":{"docs":{},"时":{"docs":{},"，":{"docs":{},"响":{"docs":{},"应":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"（":{"docs":{},"包":{"docs":{},"括":{"docs":{},"任":{"docs":{},"何":{"docs":{},"正":{"docs":{},"文":{"docs":{},"）":{"docs":{},"已":{"docs":{},"经":{"docs":{},"被":{"docs":{},"完":{"docs":{},"全":{"docs":{},"读":{"docs":{},"取":{"docs":{},"时":{"docs":{},"，":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"准":{"docs":{},"备":{"docs":{},"推":{"docs":{},"送":{"docs":{},"响":{"docs":{},"应":{"docs":{},"时":{"docs":{},"，":{"docs":{},"推":{"docs":{},"送":{"docs":{},"响":{"docs":{},"应":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"并":{"docs":{},"会":{"docs":{},"发":{"docs":{},"送":{"docs":{},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"向":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"推":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"/":{"docs":{},"响":{"docs":{},"应":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"接":{"docs":{},"受":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"每":{"docs":{},"次":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"上":{"docs":{},"传":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"，":{"docs":{},"该":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"将":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"一":{"docs":{},"次":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"没":{"docs":{},"有":{"docs":{},"及":{"docs":{},"时":{"docs":{},"回":{"docs":{},"应":{"docs":{},"时":{"docs":{},"，":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"从":{"docs":{},"列":{"docs":{},"表":{"docs":{},"中":{"docs":{},"选":{"docs":{},"择":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"解":{"docs":{},"析":{"docs":{},"器":{"docs":{},"，":{"docs":{},"搜":{"docs":{},"索":{"docs":{},"（":{"docs":{},"数":{"docs":{},"量":{"docs":{},"）":{"docs":{},"的":{"docs":{},"限":{"docs":{},"制":{"docs":{},"由":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"设":{"docs":{},"置":{"docs":{},"（":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"是":{"4":{"docs":{},"个":{"docs":{},"查":{"docs":{},"询":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"现":{"docs":{},"实":{"docs":{},"例":{"docs":{},"被":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"也":{"docs":{},"一":{"docs":{},"块":{"docs":{},"被":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"了":{"docs":{},"。":{"docs":{},"执":{"docs":{},"行":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"操":{"docs":{},"作":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"组":{"docs":{},"件":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"准":{"docs":{},"备":{"docs":{},"好":{"docs":{},"可":{"docs":{},"以":{"docs":{},"提":{"docs":{},"供":{"docs":{},"服":{"docs":{},"务":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"发":{"docs":{},"布":{"docs":{},"一":{"docs":{},"条":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"在":{"docs":{},"服":{"docs":{},"务":{"docs":{},"停":{"docs":{},"止":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"会":{"docs":{},"收":{"docs":{},"回":{"docs":{},"这":{"docs":{},"条":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"泵":{"docs":{},"首":{"docs":{},"次":{"docs":{},"创":{"docs":{},"建":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"不":{"docs":{},"会":{"docs":{},"启":{"docs":{},"动":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"到":{"docs":{},"达":{"docs":{},"时":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"我":{"docs":{},"们":{"docs":{},"设":{"docs":{},"置":{"docs":{},"了":{"docs":{},"响":{"docs":{},"应":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"，":{"docs":{},"访":{"docs":{},"问":{"docs":{},"了":{"docs":{},"会":{"docs":{},"话":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"在":{"docs":{},"响":{"docs":{},"应":{"docs":{},"完":{"docs":{},"成":{"docs":{},"向":{"docs":{},"会":{"docs":{},"话":{"docs":{},"存":{"docs":{},"储":{"docs":{},"回":{"docs":{},"写":{"docs":{},"会":{"docs":{},"话":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"话":{"docs":{},"会":{"docs":{},"被":{"docs":{},"标":{"docs":{},"记":{"docs":{},"为":{"docs":{},"被":{"docs":{},"访":{"docs":{},"问":{"docs":{},"的":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"发":{"docs":{},"生":{"docs":{},"时":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"会":{"docs":{},"检":{"docs":{},"测":{"docs":{},"到":{"docs":{},"并":{"docs":{},"记":{"docs":{},"录":{"docs":{},"下":{"docs":{},"边":{"docs":{},"警":{"docs":{},"告":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"它":{"docs":{},"会":{"docs":{},"将":{"docs":{},"消":{"docs":{},"息":{"docs":{},"回":{"docs":{},"复":{"docs":{},"给":{"docs":{},"发":{"docs":{},"送":{"docs":{},"者":{"docs":{},"并":{"docs":{},"且":{"docs":{},"在":{"docs":{},"发":{"docs":{},"送":{"docs":{},"者":{"docs":{},"中":{"docs":{},"调":{"docs":{},"用":{"docs":{},"应":{"docs":{},"答":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"回":{"docs":{},"复":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"连":{"docs":{},"接":{"docs":{},"建":{"docs":{},"立":{"docs":{},"时":{"docs":{},"，":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"将":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"并":{"docs":{},"且":{"docs":{},"传":{"docs":{},"入":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"成":{"docs":{},"功":{"docs":{},"时":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"处":{"docs":{},"理":{"docs":{},"得":{"docs":{},"到":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"提":{"docs":{},"供":{"docs":{},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"从":{"docs":{},"给":{"docs":{},"定":{"docs":{},"的":{"docs":{},"字":{"docs":{},"节":{"docs":{},"开":{"docs":{},"始":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"像":{"docs":{},"下":{"docs":{},"边":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"向":{"docs":{},"响":{"docs":{},"应":{"docs":{},"中":{"docs":{},"写":{"docs":{},"入":{"docs":{},"响":{"docs":{},"应":{"docs":{},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{},"时":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"基":{"docs":{},"础":{"docs":{},"认":{"docs":{},"证":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"收":{"docs":{},"到":{"docs":{},"了":{"docs":{},"这":{"docs":{},"些":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"使":{"docs":{},"用":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"和":{"docs":{},"密":{"docs":{},"码":{"docs":{},"调":{"docs":{},"用":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"开":{"docs":{},"发":{"docs":{},"非":{"docs":{},"单":{"docs":{},"页":{"docs":{},"面":{"docs":{},"应":{"docs":{},"用":{"docs":{},"，":{"docs":{},"并":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"来":{"docs":{},"发":{"docs":{},"送":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"设":{"docs":{},"置":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"希":{"docs":{},"望":{"docs":{},"不":{"docs":{},"同":{"docs":{},"含":{"docs":{},"义":{"docs":{},"的":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"对":{"docs":{},"象":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"采":{"docs":{},"用":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"它":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"它":{"docs":{},"们":{"docs":{},"要":{"docs":{},"与":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"进":{"docs":{},"行":{"docs":{},"交":{"docs":{},"互":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"它":{"docs":{},"们":{"docs":{},"要":{"docs":{},"与":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"进":{"docs":{},"行":{"docs":{},"交":{"docs":{},"互":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"写":{"docs":{},"服":{"docs":{},"务":{"docs":{},"模":{"docs":{},"块":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"写":{"docs":{},"很":{"docs":{},"多":{"docs":{},"重":{"docs":{},"复":{"docs":{},"的":{"docs":{},"模":{"docs":{},"板":{"docs":{},"代":{"docs":{},"码":{"docs":{},"来":{"docs":{},"监":{"docs":{},"听":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"新":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"发":{"docs":{},"送":{"docs":{},"了":{"docs":{},"携":{"docs":{},"带":{"docs":{},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"，":{"docs":{},"所":{"docs":{},"有":{"docs":{},"上":{"docs":{},"传":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"会":{"docs":{},"被":{"docs":{},"自":{"docs":{},"动":{"docs":{},"地":{"docs":{},"写":{"docs":{},"入":{"docs":{},"到":{"docs":{},"上":{"docs":{},"传":{"docs":{},"目":{"docs":{},"录":{"docs":{},"中":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"该":{"docs":{},"目":{"docs":{},"录":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"费":{"docs":{},"者":{"docs":{},"需":{"docs":{},"要":{"docs":{},"从":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"用":{"docs":{},"户":{"docs":{},"提":{"docs":{},"交":{"docs":{},"登":{"docs":{},"录":{"docs":{},"表":{"docs":{},"单":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"会":{"docs":{},"处":{"docs":{},"理":{"docs":{},"用":{"docs":{},"户":{"docs":{},"认":{"docs":{},"证":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"则":{"docs":{},"将":{"docs":{},"用":{"docs":{},"户":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"到":{"docs":{},"原":{"docs":{},"始":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"上":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"一":{"docs":{},"个":{"docs":{},"需":{"docs":{},"要":{"docs":{},"授":{"docs":{},"权":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"，":{"docs":{},"基":{"docs":{},"础":{"docs":{},"认":{"docs":{},"证":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"包":{"docs":{},"含":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"试":{"docs":{},"图":{"docs":{},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"消":{"docs":{},"息":{"docs":{},"发":{"docs":{},"布":{"docs":{},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"时":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"该":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"送":{"docs":{},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"时":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"该":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"端":{"docs":{},"消":{"docs":{},"息":{"docs":{},"发":{"docs":{},"布":{"docs":{},"到":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"时":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"该":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}},"该":{"docs":{},"功":{"docs":{},"能":{"docs":{},"启":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"根":{"docs":{},"据":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"订":{"docs":{},"阅":{"docs":{},"时":{"docs":{},"，":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}},"操":{"docs":{},"作":{"docs":{},"完":{"docs":{},"成":{"docs":{},"时":{"docs":{},"，":{"docs":{},"回":{"docs":{},"调":{"docs":{},"方":{"docs":{},"法":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"执":{"docs":{},"行":{"docs":{},"：":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}},"更":{"docs":{},"新":{"docs":{},"结":{"docs":{},"束":{"docs":{},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"执":{"docs":{},"行":{"docs":{},"回":{"docs":{},"调":{"docs":{},"方":{"docs":{},"法":{"docs":{},"处":{"docs":{},"理":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{},"更":{"docs":{},"新":{"docs":{},"结":{"docs":{},"果":{"docs":{},"包":{"docs":{},"装":{"docs":{},"在":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}},"查":{"docs":{},"询":{"docs":{},"结":{"docs":{},"束":{"docs":{},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"执":{"docs":{},"行":{"docs":{},"回":{"docs":{},"调":{"docs":{},"方":{"docs":{},"法":{"docs":{},"处":{"docs":{},"理":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{},"查":{"docs":{},"询":{"docs":{},"结":{"docs":{},"果":{"docs":{},"包":{"docs":{},"装":{"docs":{},"在":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}},"然":{"docs":{},"你":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"在":{"docs":{},"内":{"docs":{},"嵌":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"不":{"docs":{},"愿":{"docs":{},"意":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"你":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"不":{"docs":{},"用":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"来":{"docs":{},"访":{"docs":{},"问":{"docs":{},"远":{"docs":{},"程":{"docs":{},"服":{"docs":{},"务":{"docs":{},"。":{"docs":{},"被":{"docs":{},"广":{"docs":{},"泛":{"docs":{},"接":{"docs":{},"受":{"docs":{},"的":{"docs":{},"与":{"docs":{},"服":{"docs":{},"务":{"docs":{},"交":{"docs":{},"互":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"就":{"docs":{},"是":{"docs":{},"直":{"docs":{},"接":{"docs":{},"在":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"没":{"docs":{},"有":{"docs":{},"被":{"docs":{},"提":{"docs":{},"供":{"docs":{},"，":{"docs":{},"执":{"docs":{},"行":{"docs":{},"将":{"docs":{},"会":{"docs":{},"回":{"docs":{},"滚":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"不":{"docs":{},"安":{"docs":{},"全":{"docs":{},"的":{"docs":{},"模":{"docs":{},"式":{"docs":{},"同":{"docs":{},"时":{"docs":{},"签":{"docs":{},"名":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"被":{"docs":{},"验":{"docs":{},"证":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"被":{"docs":{},"外":{"docs":{},"部":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"签":{"docs":{},"名":{"docs":{},"或":{"docs":{},"加":{"docs":{},"密":{"docs":{},"后":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"这":{"docs":{},"是":{"docs":{},"非":{"docs":{},"常":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"。":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"描":{"docs":{},"述":{"docs":{},"一":{"docs":{},"个":{"docs":{},"角":{"docs":{},"色":{"docs":{},"使":{"docs":{},"用":{"docs":{},"通":{"docs":{},"配":{"docs":{},"符":{"docs":{},"*":{"docs":{},"时":{"docs":{},"，":{"docs":{},"说":{"docs":{},"明":{"docs":{},"这":{"docs":{},"个":{"docs":{},"角":{"docs":{},"色":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"权":{"docs":{},"限":{"docs":{},"。":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"你":{"docs":{},"使":{"docs":{},"用":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"访":{"docs":{},"问":{"docs":{},"完":{"docs":{},"成":{"docs":{},"过":{"docs":{},"后":{"docs":{},"想":{"docs":{},"要":{"docs":{},"注":{"docs":{},"销":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"撤":{"docs":{},"销":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"v":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"）":{"docs":{},"访":{"docs":{},"问":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"和":{"docs":{},"刷":{"docs":{},"新":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"。":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"不":{"docs":{},"再":{"docs":{},"需":{"docs":{},"要":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"在":{"docs":{},"容":{"docs":{},"器":{"docs":{},"或":{"docs":{},"云":{"docs":{},"上":{"docs":{},"部":{"docs":{},"署":{"docs":{},"你":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"你":{"docs":{},"不":{"docs":{},"能":{"docs":{},"确":{"docs":{},"定":{"docs":{},"公":{"docs":{},"开":{"docs":{},"的":{"docs":{},"i":{"docs":{},"p":{"docs":{},"地":{"docs":{},"址":{"docs":{},"和":{"docs":{},"端":{"docs":{},"口":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"发":{"docs":{},"布":{"docs":{},"必":{"docs":{},"须":{"docs":{},"通":{"docs":{},"过":{"docs":{},"其":{"docs":{},"他":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"这":{"docs":{},"些":{"docs":{},"信":{"docs":{},"息":{"docs":{},"的":{"docs":{},"实":{"docs":{},"体":{"docs":{},"来":{"docs":{},"进":{"docs":{},"行":{"docs":{},"，":{"docs":{},"这":{"docs":{},"通":{"docs":{},"常":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"对":{"docs":{},"象":{"docs":{},"（":{"docs":{},"b":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"g":{"docs":{},"e":{"docs":{},"）":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"容":{"docs":{},"器":{"docs":{},"与":{"docs":{},"另":{"docs":{},"外":{"docs":{},"一":{"docs":{},"个":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"容":{"docs":{},"器":{"docs":{},"链":{"docs":{},"接":{"docs":{},"在":{"docs":{},"一":{"docs":{},"起":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},")":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"将":{"docs":{},"会":{"docs":{},"注":{"docs":{},"入":{"docs":{},"一":{"docs":{},"组":{"docs":{},"环":{"docs":{},"境":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"该":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"将":{"docs":{},"分":{"docs":{},"析":{"docs":{},"这":{"docs":{},"些":{"docs":{},"环":{"docs":{},"境":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"针":{"docs":{},"对":{"docs":{},"每":{"docs":{},"个":{"docs":{},"链":{"docs":{},"接":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},")":{"docs":{},"，":{"docs":{},"生":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"。":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"从":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"中":{"docs":{},"推":{"docs":{},"断":{"docs":{},"；":{"docs":{},"如":{"docs":{},"果":{"docs":{},"没":{"docs":{},"有":{"docs":{},"设":{"docs":{},"置":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"将":{"docs":{},"被":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"。":{"docs":{},"目":{"docs":{},"前":{"docs":{},"暂":{"docs":{},"时":{"docs":{},"只":{"docs":{},"支":{"docs":{},"持":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"选":{"docs":{},"择":{"docs":{},"好":{"docs":{},"了":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"后":{"docs":{},"，":{"docs":{},"你":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"获":{"docs":{},"得":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"得":{"docs":{},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"写":{"docs":{},"好":{"docs":{},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"以":{"docs":{},"后":{"docs":{},"，":{"docs":{},"执":{"docs":{},"行":{"docs":{},"构":{"docs":{},"建":{"docs":{},"操":{"docs":{},"作":{"docs":{},"以":{"docs":{},"生":{"docs":{},"成":{"docs":{},"代":{"docs":{},"码":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"你":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"“":{"docs":{},"注":{"docs":{},"册":{"docs":{},"”":{"docs":{},"到":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"布":{"docs":{},"（":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"）":{"docs":{},"以":{"docs":{},"后":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"能":{"docs":{},"想":{"docs":{},"要":{"docs":{},"去":{"docs":{},"调":{"docs":{},"用":{"docs":{},"它":{"docs":{},"。":{"docs":{},"这":{"docs":{},"时":{"docs":{},"，":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"，":{"docs":{},"而":{"docs":{},"代":{"docs":{},"理":{"docs":{},"的":{"docs":{},"创":{"docs":{},"建":{"docs":{},"可":{"docs":{},"以":{"docs":{},"利":{"docs":{},"用":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"回":{"docs":{},"调":{"docs":{},"失":{"docs":{},"败":{"docs":{},"时":{"docs":{},"，":{"docs":{},"观":{"docs":{},"察":{"docs":{},"者":{"docs":{},"的":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"成":{"docs":{},"功":{"docs":{},"时":{"docs":{},"，":{"docs":{},"观":{"docs":{},"察":{"docs":{},"者":{"docs":{},"的":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"注":{"docs":{},"册":{"docs":{},"后":{"docs":{},"，":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"决":{"docs":{},"定":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"复":{"docs":{},"位":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"（":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}},"在":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"状":{"docs":{},"态":{"docs":{},"中":{"docs":{},"，":{"docs":{},"对":{"docs":{},"其":{"docs":{},"调":{"docs":{},"用":{"docs":{},"会":{"docs":{},"立":{"docs":{},"即":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"不":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"实":{"docs":{},"际":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{},"经":{"docs":{},"过":{"docs":{},"适":{"docs":{},"当":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"（":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"熔":{"docs":{},"断":{"docs":{},"时":{"docs":{},"将":{"docs":{},"调":{"docs":{},"用":{"docs":{},"此":{"docs":{},"处":{"docs":{},"代":{"docs":{},"码":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}}}}}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"时":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"确":{"docs":{},"保":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"使":{"docs":{},"用":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"网":{"docs":{},"络":{"docs":{},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{},"当":{"docs":{},"通":{"docs":{},"过":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"模":{"docs":{},"式":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"置":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"编":{"docs":{},"程":{"docs":{},"模":{"docs":{},"式":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}},"部":{"docs":{},"署":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{},"，":{"docs":{},"选":{"docs":{},"择":{"docs":{},"服":{"docs":{},"务":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"工":{"docs":{},"厂":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"编":{"docs":{},"程":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"部":{"docs":{},"署":{"docs":{},",":{"docs":{},"例":{"docs":{},"如":{"docs":{},":":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"工":{"docs":{},"厂":{"docs":{},"首":{"docs":{},"先":{"docs":{},"在":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"中":{"docs":{},"查":{"docs":{},"找":{"docs":{},"这":{"docs":{},"个":{"docs":{},"文":{"docs":{},"件":{"docs":{},"描":{"docs":{},"述":{"docs":{},"符":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"文":{"docs":{},"件":{"docs":{},"描":{"docs":{},"述":{"docs":{},"器":{"docs":{},"就":{"docs":{},"是":{"docs":{},"服":{"docs":{},"务":{"docs":{},"名":{"docs":{},"加":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"。":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"编":{"docs":{},"写":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"应":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"能":{"docs":{},"想":{"docs":{},"将":{"docs":{},"某":{"docs":{},"个":{"docs":{},"功":{"docs":{},"能":{"docs":{},"在":{"docs":{},"某":{"docs":{},"处":{"docs":{},"隔":{"docs":{},"离":{"docs":{},"开":{"docs":{},"来":{"docs":{},"，":{"docs":{},"并":{"docs":{},"对":{"docs":{},"应":{"docs":{},"用":{"docs":{},"的":{"docs":{},"其":{"docs":{},"它":{"docs":{},"部":{"docs":{},"分":{"docs":{},"提":{"docs":{},"供":{"docs":{},"服":{"docs":{},"务":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"力":{"docs":{},"求":{"docs":{},"做":{"docs":{},"到":{"docs":{},"第":{"docs":{},"一":{"docs":{},"境":{"docs":{},"界":{"docs":{},"即":{"docs":{},"可":{"docs":{},"。":{"docs":{},"信":{"docs":{},"：":{"docs":{},"即":{"docs":{},"译":{"docs":{},"文":{"docs":{},"要":{"docs":{},"准":{"docs":{},"确":{"docs":{},"，":{"docs":{},"不":{"docs":{},"偏":{"docs":{},"离":{"docs":{},"，":{"docs":{},"不":{"docs":{},"遗":{"docs":{},"漏":{"docs":{},"，":{"docs":{},"也":{"docs":{},"不":{"docs":{},"要":{"docs":{},"随":{"docs":{},"意":{"docs":{},"增":{"docs":{},"减":{"docs":{},"意":{"docs":{},"思":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"来":{"docs":{},"替":{"docs":{},"代":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"类":{"docs":{},"，":{"docs":{},"这":{"docs":{},"也":{"docs":{},"是":{"docs":{},"官":{"docs":{},"方":{"docs":{},"推":{"docs":{},"荐":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"在":{"docs":{},"p":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{},"中":{"docs":{},"加":{"docs":{},"入":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"该":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"修":{"docs":{},"改":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"看":{"docs":{},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{},"某":{"docs":{},"个":{"docs":{},"程":{"docs":{},"序":{"docs":{},"要":{"docs":{},"求":{"docs":{},"，":{"docs":{},"当":{"docs":{},"前":{"docs":{},"线":{"docs":{},"程":{"docs":{},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"给":{"docs":{},"网":{"docs":{},"络":{"docs":{},"上":{"docs":{},"另":{"docs":{},"外":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"获":{"docs":{},"取":{"docs":{},"到":{"docs":{},"结":{"docs":{},"果":{"docs":{},"之":{"docs":{},"后":{"docs":{},"作":{"docs":{},"出":{"docs":{},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{},"那":{"docs":{},"么":{"docs":{},"此":{"docs":{},"时":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"明":{"docs":{},"显":{"docs":{},"的":{"docs":{},"i":{"docs":{},"o":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"发":{"docs":{},"送":{"docs":{},"网":{"docs":{},"络":{"docs":{},"请":{"docs":{},"求":{"docs":{},"并":{"docs":{},"等":{"docs":{},"待":{"docs":{},"对":{"docs":{},"方":{"docs":{},"返":{"docs":{},"回":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"网":{"docs":{},"络":{"docs":{},"的":{"docs":{},"速":{"docs":{},"度":{"docs":{},"要":{"docs":{},"远":{"docs":{},"远":{"docs":{},"慢":{"docs":{},"于":{"docs":{},"内":{"docs":{},"存":{"docs":{},"处":{"docs":{},"理":{"docs":{},"的":{"docs":{},"速":{"docs":{},"度":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"此":{"docs":{},"时":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"便":{"docs":{},"是":{"docs":{},"非":{"docs":{},"纯":{"docs":{},"粹":{"docs":{},"内":{"docs":{},"存":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"就":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"造":{"docs":{},"成":{"docs":{},"线":{"docs":{},"程":{"docs":{},"的":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"此":{"docs":{},"时":{"docs":{},"应":{"docs":{},"该":{"docs":{},"将":{"docs":{},"这":{"docs":{},"个":{"docs":{},"操":{"docs":{},"作":{"docs":{},"交":{"docs":{},"给":{"docs":{},"其":{"docs":{},"它":{"docs":{},"线":{"docs":{},"程":{"docs":{},"予":{"docs":{},"以":{"docs":{},"处":{"docs":{},"理":{"docs":{},"，":{"docs":{},"在":{"docs":{},"处":{"docs":{},"理":{"docs":{},"完":{"docs":{},"成":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"释":{"docs":{},"放":{"docs":{},"当":{"docs":{},"前":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"等":{"docs":{},"处":{"docs":{},"理":{"docs":{},"完":{"docs":{},"成":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"再":{"docs":{},"由":{"docs":{},"当":{"docs":{},"前":{"docs":{},"线":{"docs":{},"程":{"docs":{},"执":{"docs":{},"行":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"自":{"docs":{},"带":{"docs":{},"的":{"docs":{},"网":{"docs":{},"络":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"（":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"等":{"docs":{},"）":{"docs":{},"已":{"docs":{},"经":{"docs":{},"帮":{"docs":{},"您":{"docs":{},"包":{"docs":{},"装":{"docs":{},"好":{"docs":{},"了":{"docs":{},"这":{"docs":{},"部":{"docs":{},"分":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"直":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"等":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"就":{"docs":{},"会":{"docs":{},"将":{"docs":{},"发":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"并":{"docs":{},"等":{"docs":{},"待":{"docs":{},"返":{"docs":{},"回":{"docs":{},"结":{"docs":{},"果":{"docs":{},"这":{"docs":{},"部":{"docs":{},"分":{"docs":{},"代":{"docs":{},"码":{"docs":{},"交":{"docs":{},"给":{"docs":{},"另":{"docs":{},"外":{"docs":{},"一":{"docs":{},"个":{"docs":{},"线":{"docs":{},"程":{"docs":{},"予":{"docs":{},"以":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"此":{"docs":{},"时":{"docs":{},"这":{"docs":{},"另":{"docs":{},"外":{"docs":{},"一":{"docs":{},"个":{"docs":{},"线":{"docs":{},"程":{"docs":{},"是":{"docs":{},"内":{"docs":{},"核":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"这":{"docs":{},"部":{"docs":{},"分":{"docs":{},"的":{"docs":{},"异":{"docs":{},"步":{"docs":{},"处":{"docs":{},"理":{"docs":{},"由":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"以":{"docs":{},"及":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"完":{"docs":{},"成":{"docs":{},"，":{"docs":{},"您":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"自":{"docs":{},"己":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"线":{"docs":{},"程":{"docs":{},"并":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"类":{"docs":{},"似":{"docs":{},"的":{"docs":{},"，":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"同":{"docs":{},"样":{"docs":{},"涉":{"docs":{},"及":{"docs":{},"i":{"docs":{},"o":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"自":{"docs":{},"带":{"docs":{},"的":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"（":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"会":{"docs":{},"帮":{"docs":{},"您":{"docs":{},"完":{"docs":{},"成":{"docs":{},"这":{"docs":{},"部":{"docs":{},"分":{"docs":{},"的":{"docs":{},"封":{"docs":{},"装":{"docs":{},"，":{"docs":{},"您":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"直":{"docs":{},"接":{"docs":{},"调":{"docs":{},"用":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"各":{"docs":{},"种":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"便":{"docs":{},"可":{"docs":{},"完":{"docs":{},"成":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"此":{"docs":{},"时":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"其":{"docs":{},"它":{"docs":{},"进":{"docs":{},"程":{"docs":{},"中":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"会":{"docs":{},"使":{"docs":{},"用":{"docs":{},"进":{"docs":{},"程":{"docs":{},"池":{"docs":{},"来":{"docs":{},"建":{"docs":{},"立":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"该":{"docs":{},"线":{"docs":{},"程":{"docs":{},"亦":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"您":{"docs":{},"去":{"docs":{},"创":{"docs":{},"建":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"帮":{"docs":{},"您":{"docs":{},"完":{"docs":{},"成":{"docs":{},"了":{"docs":{},"这":{"docs":{},"些":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{},"类":{"docs":{},"似":{"docs":{},"的":{"docs":{},"，":{"docs":{},"硬":{"docs":{},"盘":{"docs":{},"上":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"，":{"docs":{},"也":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"造":{"docs":{},"成":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"非":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"值":{"docs":{},"得":{"docs":{},"说":{"docs":{},"明":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"硬":{"docs":{},"盘":{"docs":{},"上":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"只":{"docs":{},"是":{"docs":{},"少":{"docs":{},"量":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"执":{"docs":{},"行":{"docs":{},"时":{"docs":{},"间":{"docs":{},"上":{"docs":{},"也":{"docs":{},"不":{"docs":{},"会":{"docs":{},"明":{"docs":{},"显":{"docs":{},"超":{"docs":{},"长":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"同":{"docs":{},"时":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"硬":{"docs":{},"盘":{"docs":{},"操":{"docs":{},"作":{"docs":{},"的":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"和":{"docs":{},"非":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"两":{"docs":{},"种":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"。":{"docs":{},"最":{"docs":{},"后":{"docs":{},"我":{"docs":{},"们":{"docs":{},"来":{"docs":{},"看":{"docs":{},"一":{"docs":{},"个":{"docs":{},"纯":{"docs":{},"粹":{"docs":{},"内":{"docs":{},"存":{"docs":{},"操":{"docs":{},"作":{"docs":{},"同":{"docs":{},"时":{"docs":{},"又":{"docs":{},"是":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"看":{"docs":{},"相":{"docs":{},"关":{"docs":{},"代":{"docs":{},"码":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"假":{"docs":{},"设":{"docs":{},"您":{"docs":{},"希":{"docs":{},"望":{"docs":{},"所":{"docs":{},"有":{"docs":{},"路":{"docs":{},"径":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"不":{"docs":{},"会":{"docs":{},"将":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"内":{"docs":{},"容":{"docs":{},"重":{"docs":{},"写":{"docs":{},"成":{"docs":{},"异":{"docs":{},"步":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"我":{"docs":{},"们":{"docs":{},"为":{"docs":{},"您":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"种":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"会":{"docs":{},"话":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"需":{"docs":{},"要":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"知":{"docs":{},"道":{"docs":{},"用":{"docs":{},"户":{"docs":{},"的":{"docs":{},"语":{"docs":{},"言":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"返":{"docs":{},"回":{"docs":{},"这":{"docs":{},"个":{"docs":{},"信":{"docs":{},"息":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"前":{"docs":{},"边":{"docs":{},"提":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}},"一":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"将":{"docs":{},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"较":{"docs":{},"长":{"docs":{},"时":{"docs":{},"间":{"docs":{},"的":{"docs":{},"持":{"docs":{},"有":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}},"利":{"docs":{},"用":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},"用":{"docs":{},"类":{"docs":{},"似":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}},"从":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"将":{"docs":{},"在":{"docs":{},"下":{"docs":{},"一":{"docs":{},"节":{"docs":{},"中":{"docs":{},"介":{"docs":{},"绍":{"docs":{},"如":{"docs":{},"何":{"docs":{},"加":{"docs":{},"入":{"docs":{},"多":{"docs":{},"播":{"docs":{},"组":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"接":{"docs":{},"收":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"种":{"docs":{},"模":{"docs":{},"式":{"docs":{},"称":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"已":{"docs":{},"经":{"docs":{},"快":{"docs":{},"达":{"docs":{},"到":{"docs":{},"我":{"docs":{},"们":{"docs":{},"的":{"docs":{},"目":{"docs":{},"标":{"docs":{},"，":{"docs":{},"但":{"docs":{},"还":{"docs":{},"没":{"docs":{},"有":{"docs":{},"完":{"docs":{},"全":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"现":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"三":{"docs":{},"个":{"docs":{},"节":{"docs":{},"点":{"docs":{},"，":{"docs":{},"这":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"现":{"docs":{},"在":{"docs":{},"想":{"docs":{},"象":{"docs":{},"一":{"docs":{},"个":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"，":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"称":{"docs":{},"之":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"生":{"docs":{},"成":{"docs":{},"固":{"docs":{},"定":{"docs":{},"尺":{"docs":{},"寸":{"docs":{},"的":{"docs":{},"块":{"docs":{},"，":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"样":{"docs":{},"，":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}},"会":{"docs":{},"在":{"docs":{},"本":{"docs":{},"手":{"docs":{},"册":{"docs":{},"里":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"所":{"docs":{},"有":{"docs":{},"上":{"docs":{},"述":{"docs":{},"的":{"docs":{},"特":{"docs":{},"性":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"每":{"docs":{},"隔":{"docs":{},"一":{"docs":{},"段":{"docs":{},"时":{"docs":{},"间":{"docs":{},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"个":{"docs":{},"心":{"docs":{},"跳":{"docs":{},"包":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"避":{"docs":{},"免":{"docs":{},"由":{"docs":{},"于":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"间":{"docs":{},"过":{"docs":{},"长":{"docs":{},"导":{"docs":{},"致":{"docs":{},"连":{"docs":{},"接":{"docs":{},"被":{"docs":{},"代":{"docs":{},"理":{"docs":{},"和":{"docs":{},"负":{"docs":{},"载":{"docs":{},"均":{"docs":{},"衡":{"docs":{},"器":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"每":{"docs":{},"隔":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"首":{"docs":{},"先":{"docs":{},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"在":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}},"只":{"docs":{},"想":{"docs":{},"要":{"6":{"0":{"docs":{},"秒":{"docs":{},"之":{"docs":{},"前":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}},"需":{"docs":{},"要":{"docs":{},"对":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"提":{"docs":{},"供":{"docs":{},"基":{"docs":{},"于":{"docs":{},"身":{"docs":{},"份":{"docs":{},"认":{"docs":{},"证":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"l":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"开":{"docs":{},"箱":{"docs":{},"即":{"docs":{},"用":{"docs":{},"的":{"docs":{},"支":{"docs":{},"持":{"docs":{},"，":{"docs":{},"你":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"插":{"docs":{},"件":{"docs":{},"，":{"docs":{},"在":{"docs":{},"任":{"docs":{},"何":{"docs":{},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{},"期":{"docs":{},"望":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"和":{"docs":{},"密":{"docs":{},"码":{"docs":{},"作":{"docs":{},"为":{"docs":{},"凭":{"docs":{},"据":{"docs":{},"的":{"docs":{},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"为":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}},"本":{"docs":{},"着":{"docs":{},"开":{"docs":{},"源":{"docs":{},"的":{"docs":{},"精":{"docs":{},"神":{"docs":{},"，":{"docs":{},"贡":{"docs":{},"献":{"docs":{},"先":{"docs":{},"于":{"docs":{},"索":{"docs":{},"取":{"docs":{},"，":{"docs":{},"自":{"docs":{},"愿":{"docs":{},"自":{"docs":{},"发":{"docs":{},"的":{"docs":{},"为":{"docs":{},"社":{"docs":{},"区":{"docs":{},"，":{"docs":{},"为":{"docs":{},"社":{"docs":{},"会":{"docs":{},"贡":{"docs":{},"献":{"docs":{},"，":{"docs":{},"才":{"docs":{},"能":{"docs":{},"为":{"docs":{},"后":{"docs":{},"人":{"docs":{},"造":{"docs":{},"福":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"项":{"docs":{},"目":{"docs":{},"的":{"docs":{},"在":{"docs":{},"线":{"docs":{},"版":{"docs":{},"本":{"docs":{},"部":{"docs":{},"署":{"docs":{},"在":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}},"文":{"docs":{},"将":{"docs":{},"会":{"docs":{},"建":{"docs":{},"立":{"docs":{},"一":{"docs":{},"个":{"docs":{},"基":{"docs":{},"本":{"docs":{},"的":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"，":{"docs":{},"并":{"docs":{},"监":{"docs":{},"听":{"8":{"0":{"8":{"0":{"docs":{},"端":{"docs":{},"口":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"任":{"docs":{},"何":{"docs":{},"发":{"docs":{},"往":{"docs":{},"该":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"以":{"docs":{},"及":{"docs":{},"端":{"docs":{},"口":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"地":{"docs":{},"共":{"docs":{},"享":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"仅":{"docs":{},"允":{"docs":{},"许":{"docs":{},"将":{"docs":{},"某":{"docs":{},"些":{"docs":{},"数":{"docs":{},"据":{"docs":{},"类":{"docs":{},"型":{"docs":{},"作":{"docs":{},"为":{"docs":{},"键":{"docs":{},"值":{"docs":{},"和":{"docs":{},"值":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"不":{"docs":{},"可":{"docs":{},"变":{"docs":{},"的":{"docs":{},"，":{"docs":{},"或":{"docs":{},"可":{"docs":{},"以":{"docs":{},"像":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"那":{"docs":{},"样":{"docs":{},"复":{"docs":{},"制":{"docs":{},"某":{"docs":{},"些":{"docs":{},"其":{"docs":{},"他":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"在":{"docs":{},"后":{"docs":{},"一":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"中":{"docs":{},"，":{"docs":{},"键":{"docs":{},"/":{"docs":{},"值":{"docs":{},"将":{"docs":{},"被":{"docs":{},"复":{"docs":{},"制":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"再":{"docs":{},"放":{"docs":{},"到":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"远":{"docs":{},"程":{"docs":{},"地":{"docs":{},"址":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"的":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"和":{"docs":{},"分":{"docs":{},"布":{"docs":{},"式":{"docs":{},"集":{"docs":{},"群":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"会":{"docs":{},"话":{"docs":{},"存":{"docs":{},"储":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"基":{"docs":{},"于":{"docs":{},"本":{"docs":{},"地":{"docs":{},"的":{"docs":{},"共":{"docs":{},"享":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"化":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"身":{"docs":{},"不":{"docs":{},"提":{"docs":{},"供":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"检":{"docs":{},"查":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"这":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"开":{"docs":{},"发":{"docs":{},"者":{"docs":{},"您":{"docs":{},"自":{"docs":{},"身":{"docs":{},"如":{"docs":{},"何":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"基":{"docs":{},"于":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"节":{"docs":{},"将":{"docs":{},"解":{"docs":{},"释":{"docs":{},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"机":{"docs":{},"制":{"docs":{},"所":{"docs":{},"涉":{"docs":{},"及":{"docs":{},"到":{"docs":{},"的":{"docs":{},"一":{"docs":{},"些":{"docs":{},"概":{"docs":{},"念":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}},"详":{"docs":{},"细":{"docs":{},"介":{"docs":{},"绍":{"docs":{},"一":{"docs":{},"下":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"如":{"docs":{},"何":{"docs":{},"使":{"docs":{},"用":{"docs":{},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"框":{"docs":{},"架":{"docs":{},"已":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"几":{"docs":{},"种":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"讲":{"docs":{},"述":{"docs":{},"的":{"docs":{},"是":{"docs":{},"最":{"docs":{},"基":{"docs":{},"本":{"docs":{},"的":{"docs":{},"获":{"docs":{},"取":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"每":{"docs":{},"种":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"都":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"快":{"docs":{},"捷":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"来":{"docs":{},"简":{"docs":{},"化":{"docs":{},"获":{"docs":{},"取":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"步":{"docs":{},"骤":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"组":{"docs":{},"件":{"docs":{},"基":{"docs":{},"于":{"docs":{},"如":{"docs":{},"下":{"docs":{},"几":{"docs":{},"个":{"docs":{},"概":{"docs":{},"念":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"仅":{"docs":{},"支":{"docs":{},"持":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"次":{"docs":{},"计":{"docs":{},"划":{"docs":{},"预":{"docs":{},"计":{"docs":{},"五":{"docs":{},"月":{"docs":{},"下":{"docs":{},"旬":{"docs":{},"完":{"docs":{},"成":{"docs":{},"。":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}},"中":{"docs":{},"旬":{"docs":{},"完":{"docs":{},"成":{"docs":{},"。":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}}},"构":{"docs":{},"建":{"docs":{"./":{"ref":"./","tf":0.01282051282051282},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},"方":{"docs":{},"法":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}},"包":{"docs":{},"含":{"docs":{},"命":{"docs":{},"令":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"。":{"docs":{},"确":{"docs":{},"保":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"s":{"docs":{},"p":{"docs":{},"i":{"docs":{},"文":{"docs":{},"件":{"docs":{},"（":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"工":{"docs":{},"具":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"连":{"docs":{},"接":{"docs":{},"到":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"的":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"告":{"docs":{},"诉":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"每":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"模":{"docs":{},"块":{"docs":{},"由":{"docs":{},"一":{"docs":{},"人":{"docs":{},"主":{"docs":{},"导":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"，":{"docs":{},"二":{"docs":{},"人":{"docs":{},"主":{"docs":{},"导":{"docs":{},"校":{"docs":{},"对":{"docs":{},"，":{"docs":{},"校":{"docs":{},"对":{"docs":{},"的":{"docs":{},"人":{"docs":{},"反":{"docs":{},"馈":{"docs":{},"给":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"的":{"docs":{},"人":{"docs":{},"修":{"docs":{},"改":{"docs":{},"，":{"docs":{},"或":{"docs":{},"获":{"docs":{},"得":{"docs":{},"同":{"docs":{},"意":{"docs":{},"后":{"docs":{},"直":{"docs":{},"接":{"docs":{},"修":{"docs":{},"改":{"docs":{},"，":{"docs":{},"三":{"docs":{},"人":{"docs":{},"都":{"docs":{},"确":{"docs":{},"认":{"docs":{},"无":{"docs":{},"误":{"docs":{},"后":{"docs":{},"，":{"docs":{},"合":{"docs":{},"并":{"docs":{},"到":{"docs":{},"主":{"docs":{},"分":{"docs":{},"支":{"docs":{},"上":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"翻":{"docs":{},"译":{"docs":{},"模":{"docs":{},"块":{"docs":{},"归":{"docs":{},"属":{"docs":{},"于":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"者":{"docs":{},"所":{"docs":{},"有":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"需":{"docs":{},"要":{"docs":{},"发":{"docs":{},"布":{"docs":{},"不":{"docs":{},"属":{"docs":{},"于":{"docs":{},"自":{"docs":{},"己":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"的":{"docs":{},"模":{"docs":{},"块":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"需":{"docs":{},"要":{"docs":{},"与":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"者":{"docs":{},"协":{"docs":{},"商":{"docs":{},"获":{"docs":{},"得":{"docs":{},"许":{"docs":{},"可":{"docs":{},"后":{"docs":{},"发":{"docs":{},"布":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"界":{"docs":{},"面":{"docs":{},"必":{"docs":{},"须":{"docs":{},"定":{"docs":{},"义":{"docs":{},"将":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"选":{"docs":{},"项":{"docs":{},"和":{"docs":{},"参":{"docs":{},"数":{"docs":{},"集":{"docs":{},"合":{"docs":{},"。":{"docs":{},"它":{"docs":{},"也":{"docs":{},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"字":{"docs":{},"。":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"操":{"docs":{},"作":{"docs":{},"都":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"和":{"docs":{},"非":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"非":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"版":{"docs":{},"本":{"docs":{},"接":{"docs":{},"受":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"连":{"docs":{},"接":{"docs":{},"最":{"docs":{},"多":{"docs":{},"可":{"docs":{},"用":{"docs":{},"三":{"docs":{},"个":{"docs":{},"连":{"docs":{},"接":{"docs":{},"，":{"docs":{},"每":{"docs":{},"个":{"docs":{},"连":{"docs":{},"接":{"docs":{},"可":{"docs":{},"连":{"docs":{},"接":{"1":{"0":{"docs":{},"个":{"docs":{},"流":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"预":{"docs":{},"处":{"docs":{},"理":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"数":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"0":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"服":{"docs":{},"务":{"docs":{},"请":{"docs":{},"求":{"docs":{},"对":{"docs":{},"象":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"响":{"docs":{},"应":{"docs":{},"对":{"docs":{},"象":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"上":{"docs":{},"传":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"会":{"docs":{},"被":{"docs":{},"自":{"docs":{},"动":{"docs":{},"生":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"文":{"docs":{},"件":{"docs":{},"名":{"docs":{},"，":{"docs":{},"并":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"匹":{"docs":{},"配":{"docs":{},"规":{"docs":{},"则":{"docs":{},"对":{"docs":{},"应":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"被":{"docs":{},"路":{"docs":{},"由":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"对":{"docs":{},"应":{"docs":{},"一":{"docs":{},"个":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"静":{"docs":{},"态":{"docs":{},"资":{"docs":{},"源":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"处":{"docs":{},"理":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"都":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"目":{"docs":{},"录":{"docs":{},"或":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"行":{"docs":{},"应":{"docs":{},"该":{"docs":{},"要":{"docs":{},"么":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"户":{"docs":{},"的":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"、":{"docs":{},"密":{"docs":{},"码":{"docs":{},"和":{"docs":{},"角":{"docs":{},"色":{"docs":{},"，":{"docs":{},"要":{"docs":{},"么":{"docs":{},"包":{"docs":{},"含":{"docs":{},"角":{"docs":{},"色":{"docs":{},"的":{"docs":{},"权":{"docs":{},"限":{"docs":{},"。":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"次":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"使":{"docs":{},"用":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"完":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"无":{"docs":{},"需":{"docs":{},"调":{"docs":{},"用":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{},"方":{"docs":{},"法":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"，":{"docs":{},"频":{"docs":{},"繁":{"docs":{},"创":{"docs":{},"建":{"docs":{},"销":{"docs":{},"毁":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"会":{"docs":{},"在":{"docs":{},"一":{"docs":{},"定":{"docs":{},"程":{"docs":{},"度":{"docs":{},"上":{"docs":{},"消":{"docs":{},"耗":{"docs":{},"系":{"docs":{},"统":{"docs":{},"资":{"docs":{},"源":{"docs":{},"，":{"docs":{},"降":{"docs":{},"低":{"docs":{},"性":{"docs":{},"能":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"增":{"docs":{},"加":{"docs":{},"开":{"docs":{},"发":{"docs":{},"人":{"docs":{},"员":{"docs":{},"的":{"docs":{},"负":{"docs":{},"担":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"提":{"docs":{},"供":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{},"目":{"docs":{},"的":{"docs":{},"就":{"docs":{},"在":{"docs":{},"于":{"docs":{},"复":{"docs":{},"用":{"docs":{},"连":{"docs":{},"接":{"docs":{},"以":{"docs":{},"减":{"docs":{},"少":{"docs":{},"资":{"docs":{},"源":{"docs":{},"消":{"docs":{},"耗":{"docs":{},"，":{"docs":{},"提":{"docs":{},"升":{"docs":{},"性":{"docs":{},"能":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"简":{"docs":{},"化":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"减":{"docs":{},"轻":{"docs":{},"开":{"docs":{},"发":{"docs":{},"人":{"docs":{},"员":{"docs":{},"的":{"docs":{},"负":{"docs":{},"担":{"docs":{},"。":{"docs":{},"如":{"docs":{},"您":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"，":{"docs":{},"在":{"docs":{},"下":{"docs":{},"一":{"docs":{},"次":{"docs":{},"使":{"docs":{},"用":{"docs":{},"该":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"重":{"docs":{},"新":{"docs":{},"创":{"docs":{},"建":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{},"此":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"就":{"docs":{},"相":{"docs":{},"当":{"docs":{},"于":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}},"事":{"docs":{},"件":{"docs":{},"信":{"docs":{},"息":{"docs":{},"包":{"docs":{},"含":{"docs":{},"以":{"docs":{},"下":{"docs":{},"：":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"状":{"docs":{},"态":{"docs":{},"发":{"docs":{},"生":{"docs":{},"变":{"docs":{},"化":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"在":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}},"当":{"docs":{},"有":{"docs":{},"新":{"docs":{},"连":{"docs":{},"接":{"docs":{},"到":{"docs":{},"达":{"docs":{},"时":{"docs":{},"，":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{},"被":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"或":{"docs":{},"者":{"docs":{},"被":{"docs":{},"释":{"docs":{},"放":{"docs":{},"，":{"docs":{},"都":{"docs":{},"会":{"docs":{},"有":{"docs":{},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{},"事":{"docs":{},"件":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"布":{"docs":{},"或":{"docs":{},"回":{"docs":{},"收":{"docs":{},"服":{"docs":{},"务":{"docs":{},"时":{"docs":{},"，":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"布":{"docs":{},"或":{"docs":{},"者":{"docs":{},"取":{"docs":{},"消":{"docs":{},"发":{"docs":{},"布":{"docs":{},"，":{"docs":{},"都":{"docs":{},"会":{"docs":{},"有":{"docs":{},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{},"事":{"docs":{},"件":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"注":{"docs":{},"意":{"docs":{},"一":{"docs":{},"定":{"docs":{},"要":{"docs":{},"输":{"docs":{},"出":{"docs":{},"到":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}},"：":{"docs":{},"我":{"docs":{},"们":{"docs":{},"会":{"docs":{},"尽":{"docs":{},"量":{"docs":{},"将":{"docs":{},"原":{"docs":{},"理":{"docs":{},"讲":{"docs":{},"得":{"docs":{},"通":{"docs":{},"俗":{"docs":{},"易":{"docs":{},"懂":{"docs":{},"，":{"docs":{},"但":{"docs":{},"还":{"docs":{},"是":{"docs":{},"要":{"docs":{},"求":{"docs":{},"读":{"docs":{},"者":{"docs":{},"具":{"docs":{},"备":{"docs":{},"有":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"进":{"docs":{},"程":{"docs":{},"，":{"docs":{},"内":{"docs":{},"存":{"docs":{},"，":{"docs":{},"c":{"docs":{},"p":{"docs":{},"u":{"docs":{},"，":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"，":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"，":{"docs":{},"算":{"docs":{},"法":{"docs":{},"等":{"docs":{},"专":{"docs":{},"业":{"docs":{},"基":{"docs":{},"础":{"docs":{},"知":{"docs":{},"识":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"分":{"docs":{},"块":{"docs":{},"响":{"docs":{},"应":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"压":{"docs":{},"缩":{"docs":{},"可":{"docs":{},"以":{"docs":{},"减":{"docs":{},"少":{"docs":{},"网":{"docs":{},"络":{"docs":{},"流":{"docs":{},"量":{"docs":{},"，":{"docs":{},"单":{"docs":{},"是":{"docs":{},"c":{"docs":{},"p":{"docs":{},"u":{"docs":{},"密":{"docs":{},"集":{"docs":{},"度":{"docs":{},"会":{"docs":{},"更":{"docs":{},"高":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"目":{"docs":{},"前":{"docs":{},"如":{"docs":{},"果":{"docs":{},"连":{"docs":{},"接":{"docs":{},"失":{"docs":{},"效":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"将":{"docs":{},"不":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"重":{"docs":{},"新":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{},"重":{"docs":{},"新":{"docs":{},"连":{"docs":{},"接":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"和":{"docs":{},"时":{"docs":{},"间":{"docs":{},"间":{"docs":{},"隔":{"docs":{},"仅":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"创":{"docs":{},"建":{"docs":{},"初":{"docs":{},"始":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"若":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{},"官":{"docs":{},"方":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"可":{"docs":{},"共":{"docs":{},"享":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"类":{"docs":{},"似":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}},"通":{"docs":{},"过":{"docs":{},"系":{"docs":{},"统":{"docs":{},"变":{"docs":{},"量":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}},"要":{"docs":{},"添":{"docs":{},"加":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"，":{"docs":{},"详":{"docs":{},"情":{"docs":{},"见":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"章":{"docs":{},"节":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"即":{"docs":{},"使":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"中":{"docs":{},"处":{"docs":{},"理":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"于":{"docs":{},"持":{"docs":{},"有":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"，":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"需":{"docs":{},"要":{"docs":{},"做":{"docs":{},"的":{"docs":{},"是":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"发":{"docs":{},"生":{"docs":{},"的":{"docs":{},"这":{"docs":{},"些":{"docs":{},"没":{"docs":{},"有":{"docs":{},"线":{"docs":{},"程":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"应":{"docs":{},"该":{"docs":{},"只":{"docs":{},"能":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"角":{"docs":{},"色":{"docs":{},"在":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"里":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"直":{"docs":{},"接":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"个":{"docs":{},"事":{"docs":{},"实":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"第":{"docs":{},"三":{"docs":{},"和":{"docs":{},"第":{"docs":{},"四":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},"个":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"与":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"没":{"docs":{},"有":{"docs":{},"直":{"docs":{},"接":{"docs":{},"关":{"docs":{},"系":{"docs":{},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"关":{"docs":{},"于":{"docs":{},"部":{"docs":{},"署":{"docs":{},"单":{"docs":{},"个":{"docs":{},"组":{"docs":{},"件":{"docs":{},"的":{"docs":{},"设":{"docs":{},"施":{"docs":{},"。":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"（":{"docs":{},"服":{"docs":{},"务":{"docs":{},"实":{"docs":{},"现":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"）":{"docs":{},"都":{"docs":{},"需":{"docs":{},"要":{"docs":{},"用":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"语":{"docs":{},"言":{"docs":{},"开":{"docs":{},"发":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}},"机":{"docs":{},"制":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"于":{"docs":{},"代":{"docs":{},"码":{"docs":{},"生":{"docs":{},"成":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"每":{"docs":{},"次":{"docs":{},"修":{"docs":{},"改":{"docs":{},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"以":{"docs":{},"后":{"docs":{},"都":{"docs":{},"需":{"docs":{},"重":{"docs":{},"新":{"docs":{},"执":{"docs":{},"行":{"docs":{},"构":{"docs":{},"建":{"docs":{},"过":{"docs":{},"程":{"docs":{},"来":{"docs":{},"重":{"docs":{},"新":{"docs":{},"生":{"docs":{},"成":{"docs":{},"代":{"docs":{},"码":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"现":{"docs":{},"模":{"docs":{},"块":{"docs":{},"并":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}},"事":{"docs":{},"项":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}},"册":{"docs":{},"在":{"docs":{},"该":{"docs":{},"地":{"docs":{},"址":{"docs":{},"上":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"这":{"docs":{},"和":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"为":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"于":{"docs":{},"侦":{"docs":{},"听":{"docs":{},"撤":{"docs":{},"销":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}},"新":{"docs":{},"分":{"docs":{},"配":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"指":{"docs":{},"标":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}},"解":{"docs":{},"后":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"以":{"docs":{},"下":{"docs":{},"命":{"docs":{},"令":{"docs":{},"来":{"docs":{},"定":{"docs":{},"义":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"并":{"docs":{},"注":{"docs":{},"入":{"docs":{},"值":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}},"来":{"docs":{},"注":{"docs":{},"销":{"docs":{},"代":{"docs":{},"理":{"docs":{},"。":{"docs":{},"当":{"docs":{},"此":{"docs":{},"方":{"docs":{},"法":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"代":{"docs":{},"理":{"docs":{},"实":{"docs":{},"例":{"docs":{},"被":{"docs":{},"清":{"docs":{},"除":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"会":{"docs":{},"触":{"docs":{},"发":{"docs":{},"生":{"docs":{},"成":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"辅":{"docs":{},"助":{"docs":{},"类":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}},"类":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}},"相":{"docs":{},"结":{"docs":{},"合":{"docs":{},"，":{"docs":{},"用":{"docs":{},"于":{"docs":{},"生":{"docs":{},"成":{"docs":{},"其":{"docs":{},"它":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"语":{"docs":{},"言":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"销":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"服":{"docs":{},"务":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}},"释":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"理":{"docs":{},"念":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}},"目":{"docs":{},"录":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"作":{"docs":{},"为":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}},"，":{"docs":{},"才":{"docs":{},"能":{"docs":{},"被":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"您":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"中":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"查":{"docs":{},"找":{"docs":{},"模":{"docs":{},"板":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"下":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"建":{"docs":{},"议":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}},"。":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}},"标":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}},"前":{"docs":{"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353}},"，":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"组":{"docs":{},"件":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"几":{"docs":{},"种":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}},"确":{"docs":{},"定":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"内":{"docs":{},"容":{"docs":{},"后":{"docs":{},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"把":{"docs":{},"内":{"docs":{},"容":{"docs":{},"分":{"docs":{},"模":{"docs":{},"块":{"docs":{},"，":{"docs":{},"每":{"docs":{},"人":{"docs":{},"根":{"docs":{},"据":{"docs":{},"自":{"docs":{},"己":{"docs":{},"实":{"docs":{},"际":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"情":{"docs":{},"况":{"docs":{},"领":{"docs":{},"取":{"docs":{},"翻":{"docs":{},"译":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"保":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"请":{"docs":{},"求":{"docs":{},"完":{"docs":{},"成":{"docs":{},"后":{"docs":{},"结":{"docs":{},"束":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"请":{"docs":{},"求":{"docs":{},"都":{"docs":{},"会":{"docs":{},"经":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"认":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}},"站":{"docs":{},"点":{"docs":{},"。":{"docs":{},"以":{"docs":{},"下":{"docs":{},"是":{"docs":{},"构":{"docs":{},"建":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}},"翻":{"docs":{},"译":{"docs":{},"三":{"docs":{},"个":{"docs":{},"境":{"docs":{},"界":{"docs":{},"：":{"docs":{},"信":{"docs":{},"，":{"docs":{},"达":{"docs":{},"，":{"docs":{},"雅":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}},"人":{"docs":{},"员":{"docs":{},"在":{"docs":{},"领":{"docs":{},"取":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"任":{"docs":{},"务":{"docs":{},"后":{"docs":{},"尽":{"docs":{},"可":{"docs":{},"能":{"docs":{},"在":{"docs":{},"自":{"docs":{},"己":{"docs":{},"评":{"docs":{},"估":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"内":{"docs":{},"完":{"docs":{},"成":{"docs":{},"，":{"docs":{},"校":{"docs":{},"对":{"docs":{},"人":{"docs":{},"员":{"docs":{},"校":{"docs":{},"对":{"docs":{},"任":{"docs":{},"务":{"docs":{},"同":{"docs":{},"理":{"docs":{},"，":{"docs":{},"如":{"docs":{},"无":{"docs":{},"法":{"docs":{},"完":{"docs":{},"成":{"docs":{},"则":{"docs":{},"告":{"docs":{},"知":{"docs":{},"大":{"docs":{},"家":{"docs":{},"，":{"docs":{},"多":{"docs":{},"次":{"docs":{},"无":{"docs":{},"理":{"docs":{},"由":{"docs":{},"延":{"docs":{},"期":{"docs":{},"的":{"docs":{},"，":{"docs":{},"自":{"docs":{},"动":{"docs":{},"退":{"docs":{},"出":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"小":{"docs":{},"组":{"docs":{},"。":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"协":{"docs":{},"作":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}},"计":{"docs":{},"划":{"docs":{"./":{"ref":"./","tf":0.01282051282051282},"PLAN.html":{"ref":"PLAN.html","tf":10.008064516129032}}}},"成":{"docs":{},"了":{"docs":{},"反":{"docs":{},"应":{"docs":{},"器":{"docs":{},"模":{"docs":{},"式":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"：":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}},"赵":{"docs":{},"亮":{"docs":{},"，":{"docs":{},"校":{"docs":{},"对":{"docs":{},"：":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}},"背":{"docs":{},"景":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}},"识":{"docs":{},"别":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}},"这":{"docs":{},"是":{"docs":{},"针":{"docs":{},"对":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}},"一":{"docs":{},"个":{"docs":{},"常":{"docs":{},"见":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"为":{"docs":{},"您":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"认":{"docs":{},"证":{"docs":{},"会":{"docs":{},"由":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243}}}}},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}},"针":{"docs":{},"对":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}},"专":{"docs":{},"家":{"docs":{},"级":{"docs":{},"别":{"docs":{},"的":{"docs":{},"技":{"docs":{},"巧":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"因":{"docs":{},"为":{"docs":{},"让":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"可":{"docs":{},"能":{"docs":{},"非":{"docs":{},"常":{"docs":{},"大":{"docs":{},"（":{"docs":{},"如":{"docs":{},"文":{"docs":{},"件":{"docs":{},"上":{"docs":{},"传":{"docs":{},"）":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"我":{"docs":{},"们":{"docs":{},"不":{"docs":{},"会":{"docs":{},"在":{"docs":{},"内":{"docs":{},"容":{"docs":{},"发":{"docs":{},"送":{"docs":{},"给":{"docs":{},"您":{"docs":{},"之":{"docs":{},"前":{"docs":{},"将":{"docs":{},"其":{"docs":{},"全":{"docs":{},"部":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"存":{"docs":{},"储":{"docs":{},"在":{"docs":{},"内":{"docs":{},"存":{"docs":{},"中":{"docs":{},"，":{"docs":{},"这":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"导":{"docs":{},"致":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"耗":{"docs":{},"尽":{"docs":{},"可":{"docs":{},"用":{"docs":{},"内":{"docs":{},"存":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"不":{"docs":{},"能":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"如":{"docs":{},"果":{"docs":{},"服":{"docs":{},"务":{"docs":{},"是":{"docs":{},"远":{"docs":{},"程":{"docs":{},"的":{"docs":{},"，":{"docs":{},"不":{"docs":{},"可":{"docs":{},"能":{"docs":{},"立":{"docs":{},"即":{"docs":{},"返":{"docs":{},"回":{"docs":{},"结":{"docs":{},"果":{"docs":{},"而":{"docs":{},"不":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"处":{"docs":{},"理":{"docs":{},"请":{"docs":{},"求":{"docs":{},"并":{"docs":{},"回":{"docs":{},"复":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"贯":{"docs":{},"穿":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"随":{"docs":{},"机":{"docs":{},"访":{"docs":{},"问":{"docs":{},"写":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"为":{"docs":{},"了":{"docs":{},"保":{"docs":{},"证":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}},"通":{"docs":{},"过":{"docs":{},"指":{"docs":{},"定":{"docs":{},"类":{"docs":{},"型":{"docs":{},"创":{"docs":{},"建":{"docs":{},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"现":{"docs":{},"在":{"docs":{},"非":{"docs":{},"常":{"docs":{},"接":{"docs":{},"近":{"docs":{},"于":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"有":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"它":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"认":{"docs":{},"证":{"docs":{},"用":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"这":{"docs":{},"些":{"docs":{},"信":{"docs":{},"息":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"；":{"docs":{},"对":{"docs":{},"于":{"docs":{},"简":{"docs":{},"单":{"docs":{},"基":{"docs":{},"于":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"/":{"docs":{},"密":{"docs":{},"码":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"的":{"docs":{},"认":{"docs":{},"证":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"如":{"docs":{},"下":{"docs":{},"信":{"docs":{},"息":{"docs":{},"：":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"完":{"docs":{},"成":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"你":{"docs":{},"是":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"持":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"一":{"docs":{},"步":{"docs":{},"就":{"docs":{},"完":{"docs":{},"成":{"docs":{},"服":{"docs":{},"务":{"docs":{},"查":{"docs":{},"找":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"获":{"docs":{},"取":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"是":{"docs":{},"流":{"docs":{},"式":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"链":{"docs":{},"式":{"docs":{},"地":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"是":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"例":{"docs":{},"子":{"docs":{},"不":{"docs":{},"会":{"docs":{},"耗":{"docs":{},"尽":{"docs":{},"内":{"docs":{},"存":{"docs":{},"，":{"docs":{},"但":{"docs":{},"如":{"docs":{},"果":{"docs":{},"写":{"docs":{},"入":{"docs":{},"队":{"docs":{},"列":{"docs":{},"已":{"docs":{},"满":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"最":{"docs":{},"终":{"docs":{},"会":{"docs":{},"丢":{"docs":{},"失":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{},"我":{"docs":{},"们":{"docs":{},"真":{"docs":{},"正":{"docs":{},"想":{"docs":{},"要":{"docs":{},"做":{"docs":{},"的":{"docs":{},"是":{"docs":{},"在":{"docs":{},"写":{"docs":{},"入":{"docs":{},"队":{"docs":{},"列":{"docs":{},"已":{"docs":{},"满":{"docs":{},"时":{"docs":{},"暂":{"docs":{},"停":{"docs":{},"读":{"docs":{},"取":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"做":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"件":{"docs":{},"事":{"docs":{},"是":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"功":{"docs":{},"能":{"docs":{},"不":{"docs":{},"能":{"docs":{},"用":{"docs":{},"于":{"docs":{},"生":{"docs":{},"产":{"docs":{},"环":{"docs":{},"境":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"对":{"docs":{},"于":{"docs":{},"跨":{"docs":{},"多":{"docs":{},"核":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"时":{"docs":{},"很":{"docs":{},"有":{"docs":{},"用":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"您":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"需":{"docs":{},"要":{"docs":{},"部":{"docs":{},"署":{"docs":{},"在":{"docs":{},"多":{"docs":{},"核":{"docs":{},"的":{"docs":{},"机":{"docs":{},"器":{"docs":{},"上":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"部":{"docs":{},"署":{"docs":{},"多":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"来":{"docs":{},"利":{"docs":{},"用":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"核":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"将":{"docs":{},"会":{"docs":{},"每":{"docs":{},"隔":{"docs":{},"一":{"docs":{},"秒":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"一":{"docs":{},"次":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"会":{"docs":{},"向":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"在":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"上":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"回":{"docs":{},"调":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"是":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"能":{"docs":{},"够":{"docs":{},"处":{"docs":{},"理":{"docs":{},"范":{"docs":{},"围":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{},"当":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"请":{"docs":{},"求":{"docs":{},"静":{"docs":{},"态":{"docs":{},"资":{"docs":{},"源":{"docs":{},"时":{"docs":{},"，":{"docs":{},"该":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{},"范":{"docs":{},"围":{"docs":{},"单":{"docs":{},"位":{"docs":{},"的":{"docs":{},"说":{"docs":{},"明":{"docs":{},"到":{"docs":{},"响":{"docs":{},"应":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"学":{"docs":{},"题":{"docs":{},"并":{"docs":{},"不":{"docs":{},"难":{"docs":{},"，":{"docs":{},"将":{"docs":{},"留":{"docs":{},"给":{"docs":{},"读":{"docs":{},"者":{"docs":{},"作":{"docs":{},"为":{"docs":{},"练":{"docs":{},"习":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"正":{"docs":{},"在":{"docs":{},"监":{"docs":{},"听":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"模":{"docs":{},"型":{"docs":{},"不":{"docs":{},"能":{"docs":{},"说":{"docs":{},"是":{"docs":{},"严":{"docs":{},"格":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"不":{"docs":{},"想":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"将":{"docs":{},"会":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"所":{"docs":{},"有":{"docs":{},"在":{"docs":{},"地":{"docs":{},"址":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"策":{"docs":{},"略":{"docs":{},"将":{"docs":{},"会":{"docs":{},"处":{"docs":{},"理":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"的":{"docs":{},"原":{"docs":{},"始":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"会":{"docs":{},"以":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"精":{"docs":{},"确":{"docs":{},"地":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"消":{"docs":{},"息":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{},"哪":{"docs":{},"些":{"docs":{},"地":{"docs":{},"址":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"通":{"docs":{},"过":{"docs":{},"精":{"docs":{},"确":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"来":{"docs":{},"控":{"docs":{},"制":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"选":{"docs":{},"项":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"正":{"docs":{},"则":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"来":{"docs":{},"定":{"docs":{},"义":{"docs":{},"消":{"docs":{},"息":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{},"哪":{"docs":{},"些":{"docs":{},"地":{"docs":{},"址":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"通":{"docs":{},"过":{"docs":{},"正":{"docs":{},"则":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"来":{"docs":{},"控":{"docs":{},"制":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"选":{"docs":{},"项":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"指":{"docs":{},"定":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"来":{"docs":{},"控":{"docs":{},"制":{"docs":{},"消":{"docs":{},"息":{"docs":{},"是":{"docs":{},"否":{"docs":{},"可":{"docs":{},"以":{"docs":{},"发":{"docs":{},"送":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"配":{"docs":{},"置":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"段":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"消":{"docs":{},"息":{"docs":{},"中":{"docs":{},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"值":{"docs":{},"一":{"docs":{},"致":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"配":{"docs":{},"置":{"docs":{},"只":{"docs":{},"能":{"docs":{},"用":{"docs":{},"于":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"值":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"用":{"docs":{},"于":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"某":{"docs":{},"些":{"docs":{},"传":{"docs":{},"输":{"docs":{},"方":{"docs":{},"式":{"docs":{},"。":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"值":{"docs":{},"包":{"docs":{},"括":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"存":{"docs":{},"储":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"您":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"没":{"docs":{},"有":{"docs":{},"使":{"docs":{},"用":{"docs":{},"粘":{"docs":{},"性":{"docs":{},"会":{"docs":{},"话":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"您":{"docs":{},"的":{"docs":{},"负":{"docs":{},"载":{"docs":{},"均":{"docs":{},"衡":{"docs":{},"器":{"docs":{},"会":{"docs":{},"将":{"docs":{},"来":{"docs":{},"自":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"请":{"docs":{},"求":{"docs":{},"转":{"docs":{},"发":{"docs":{},"到":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"库":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"为":{"docs":{},"可":{"docs":{},"读":{"docs":{},"流":{"docs":{},"、":{"docs":{},"可":{"docs":{},"写":{"docs":{},"流":{"docs":{},"都":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"这":{"docs":{},"两":{"docs":{},"者":{"docs":{},"分":{"docs":{},"别":{"docs":{},"扮":{"docs":{},"演":{"docs":{},"了":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}},"正":{"docs":{},"则":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"可":{"docs":{},"以":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"路":{"docs":{},"径":{"docs":{},"类":{"docs":{},"似":{"docs":{},"于":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"路":{"docs":{},"由":{"docs":{},"器":{"docs":{},"的":{"docs":{},"调":{"docs":{},"用":{"docs":{},"规":{"docs":{},"则":{"docs":{},"和":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"一":{"docs":{},"样":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}},"组":{"docs":{},"件":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"开":{"docs":{},"箱":{"docs":{},"即":{"docs":{},"用":{"docs":{},"的":{"docs":{},"j":{"docs":{},"w":{"docs":{},"t":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}},"元":{"docs":{},"素":{"docs":{},"{":{"0":{"docs":{},"}":{"docs":{},"是":{"docs":{},"创":{"docs":{},"建":{"docs":{},"实":{"docs":{},"际":{"docs":{},"的":{"docs":{},"查":{"docs":{},"找":{"docs":{},"时":{"docs":{},"替":{"docs":{},"换":{"docs":{},"成":{"docs":{},"用":{"docs":{},"户":{"docs":{},"的":{"docs":{},"i":{"docs":{},"d":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"设":{"docs":{},"置":{"docs":{},"是":{"docs":{},"强":{"docs":{},"制":{"docs":{},"的":{"docs":{},"。":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}},"实":{"docs":{},"现":{"docs":{},"当":{"docs":{},"前":{"docs":{},"假":{"docs":{},"定":{"docs":{},"了":{"docs":{},"在":{"docs":{},"基":{"docs":{},"本":{"docs":{},"的":{"docs":{},"验":{"docs":{},"证":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"和":{"docs":{},"密":{"docs":{},"码":{"docs":{},"。":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"文":{"docs":{},"件":{"docs":{},"应":{"docs":{},"该":{"docs":{},"遵":{"docs":{},"从":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"结":{"docs":{},"构":{"docs":{},"：":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}},"地":{"docs":{},"址":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"地":{"docs":{},"址":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"是":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"可":{"docs":{},"以":{"docs":{},"连":{"docs":{},"接":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"过":{"docs":{},"程":{"docs":{},"既":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}},"里":{"docs":{},"的":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"l":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"d":{"docs":{},"a":{"docs":{},"/":{"docs":{},"匿":{"docs":{},"名":{"docs":{},"函":{"docs":{},"数":{"docs":{},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}},"想":{"docs":{},"法":{"docs":{},"是":{"docs":{},"允":{"docs":{},"许":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"在":{"docs":{},"发":{"docs":{},"送":{"docs":{},"大":{"docs":{},"量":{"docs":{},"数":{"docs":{},"据":{"docs":{},"之":{"docs":{},"前":{"docs":{},"授":{"docs":{},"权":{"docs":{},"、":{"docs":{},"接":{"docs":{},"收":{"docs":{},"/":{"docs":{},"拒":{"docs":{},"绝":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"若":{"docs":{},"请":{"docs":{},"求":{"docs":{},"不":{"docs":{},"能":{"docs":{},"被":{"docs":{},"接":{"docs":{},"收":{"docs":{},"，":{"docs":{},"则":{"docs":{},"发":{"docs":{},"送":{"docs":{},"大":{"docs":{},"量":{"docs":{},"数":{"docs":{},"据":{"docs":{},"信":{"docs":{},"息":{"docs":{},"会":{"docs":{},"浪":{"docs":{},"费":{"docs":{},"带":{"docs":{},"宽":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"在":{"docs":{},"读":{"docs":{},"取":{"docs":{},"即":{"docs":{},"将":{"docs":{},"丢":{"docs":{},"弃":{"docs":{},"的":{"docs":{},"无":{"docs":{},"用":{"docs":{},"数":{"docs":{},"据":{"docs":{},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"代":{"docs":{},"码":{"docs":{},"可":{"docs":{},"以":{"docs":{},"成":{"docs":{},"功":{"docs":{},"或":{"docs":{},"者":{"docs":{},"失":{"docs":{},"败":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"有":{"docs":{},"三":{"docs":{},"个":{"docs":{},"操":{"docs":{},"作":{"docs":{},"被":{"docs":{},"串":{"docs":{},"起":{"docs":{},"来":{"docs":{},"了":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"抛":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"故":{"docs":{},"意":{"docs":{},"将":{"docs":{},"请":{"docs":{},"求":{"docs":{},"处":{"docs":{},"理":{"docs":{},"为":{"docs":{},"失":{"docs":{},"败":{"docs":{},"状":{"docs":{},"态":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"派":{"docs":{},"发":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"认":{"docs":{},"证":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"并":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}},"基":{"docs":{},"于":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"/":{"docs":{},"密":{"docs":{},"码":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"认":{"docs":{},"证":{"docs":{},"用":{"docs":{},"户":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"实":{"docs":{},"现":{"docs":{},"：":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"用":{"docs":{},"户":{"docs":{},"授":{"docs":{},"权":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}},"有":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"从":{"docs":{},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}},"某":{"docs":{},"个":{"docs":{},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}},"一":{"docs":{},"些":{"docs":{},"示":{"docs":{},"例":{"docs":{},"，":{"docs":{},"展":{"docs":{},"示":{"docs":{},"了":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}},"两":{"docs":{},"个":{"docs":{},"快":{"docs":{},"捷":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"种":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"些":{"docs":{},"帧":{"docs":{},"被":{"docs":{},"立":{"docs":{},"即":{"docs":{},"发":{"docs":{},"送":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"不":{"docs":{},"受":{"docs":{},"流":{"docs":{},"程":{"docs":{},"控":{"docs":{},"制":{"docs":{},"的":{"docs":{},"影":{"docs":{},"响":{"docs":{},"—":{"docs":{},"—":{"docs":{},"当":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"帧":{"docs":{},"被":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{},"那":{"docs":{},"里":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"阻":{"docs":{},"塞":{"docs":{},"做":{"docs":{},"法":{"docs":{},"包":{"docs":{},"括":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"是":{"docs":{},"最":{"docs":{},"基":{"docs":{},"本":{"docs":{},"的":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"我":{"docs":{},"们":{"docs":{},"来":{"docs":{},"看":{"docs":{},"一":{"docs":{},"下":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"细":{"docs":{},"节":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"方":{"docs":{},"法":{"docs":{},"；":{"docs":{},"它":{"docs":{},"们":{"docs":{},"会":{"docs":{},"在":{"docs":{},"内":{"docs":{},"部":{"docs":{},"被":{"docs":{},"自":{"docs":{},"动":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}},"还":{"docs":{},"必":{"docs":{},"须":{"docs":{},"加":{"docs":{},"上":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}},"资":{"docs":{},"源":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"称":{"docs":{},"为":{"docs":{},"服":{"docs":{},"务":{"docs":{},"。":{"docs":{},"服":{"docs":{},"务":{"docs":{},"就":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"发":{"docs":{},"现":{"docs":{},"和":{"docs":{},"访":{"docs":{},"问":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"它":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"、":{"docs":{},"元":{"docs":{},"数":{"docs":{},"据":{"docs":{},"和":{"docs":{},"位":{"docs":{},"置":{"docs":{},"来":{"docs":{},"进":{"docs":{},"行":{"docs":{},"描":{"docs":{},"述":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"、":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"、":{"docs":{},"一":{"docs":{},"个":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"应":{"docs":{},"用":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"任":{"docs":{},"何":{"docs":{},"你":{"docs":{},"能":{"docs":{},"想":{"docs":{},"到":{"docs":{},"的":{"docs":{},"可":{"docs":{},"描":{"docs":{},"述":{"docs":{},"、":{"docs":{},"可":{"docs":{},"发":{"docs":{},"现":{"docs":{},"、":{"docs":{},"可":{"docs":{},"交":{"docs":{},"互":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"。":{"docs":{},"它":{"docs":{},"不":{"docs":{},"一":{"docs":{},"定":{"docs":{},"是":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"体":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"任":{"docs":{},"何":{"docs":{},"组":{"docs":{},"件":{"docs":{},"。":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"来":{"docs":{},"简":{"docs":{},"化":{"docs":{},"这":{"docs":{},"个":{"docs":{},"过":{"docs":{},"程":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}},"使":{"docs":{},"得":{"docs":{},"它":{"docs":{},"们":{"docs":{},"对":{"docs":{},"于":{"docs":{},"托":{"docs":{},"管":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"它":{"docs":{},"用":{"docs":{},"少":{"docs":{},"量":{"docs":{},"的":{"docs":{},"内":{"docs":{},"核":{"docs":{},"线":{"docs":{},"程":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"处":{"docs":{},"理":{"docs":{},"大":{"docs":{},"量":{"docs":{},"的":{"docs":{},"并":{"docs":{},"发":{"docs":{},"(":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"处":{"docs":{},"理":{"docs":{},"很":{"docs":{},"多":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"、":{"docs":{},"消":{"docs":{},"息":{"docs":{},"之":{"docs":{},"类":{"docs":{},")":{"docs":{},"，":{"docs":{},"具":{"docs":{},"有":{"docs":{},"优":{"docs":{},"异":{"docs":{},"的":{"docs":{},"可":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"性":{"docs":{},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"儿":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"非":{"docs":{},"常":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"它":{"docs":{},"回":{"docs":{},"应":{"docs":{},"了":{"docs":{},"任":{"docs":{},"何":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"部":{"docs":{},"署":{"docs":{},"不":{"docs":{},"同":{"docs":{},"类":{"docs":{},"型":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"些":{"docs":{},"写":{"docs":{},"入":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"创":{"docs":{},"建":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"三":{"docs":{},"种":{"docs":{},"不":{"docs":{},"同":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"允":{"docs":{},"许":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"使":{"docs":{},"用":{"docs":{},"块":{"docs":{},"方":{"docs":{},"式":{"docs":{},"写":{"docs":{},"入":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"它":{"docs":{},"同":{"docs":{},"时":{"docs":{},"处":{"docs":{},"理":{"docs":{},"支":{"docs":{},"持":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"您":{"docs":{},"部":{"docs":{},"署":{"docs":{},"用":{"docs":{},"任":{"docs":{},"何":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"语":{"docs":{},"言":{"docs":{},"编":{"docs":{},"写":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"应":{"docs":{},"用":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"部":{"docs":{},"分":{"docs":{},"设":{"docs":{},"置":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"失":{"docs":{},"败":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"几":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"完":{"docs":{},"成":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"向":{"docs":{},"上":{"docs":{},"文":{"docs":{},"所":{"docs":{},"述":{"docs":{},"的":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"规":{"docs":{},"则":{"docs":{},"中":{"docs":{},"加":{"docs":{},"入":{"docs":{},"额":{"docs":{},"外":{"docs":{},"的":{"docs":{},"字":{"docs":{},"段":{"docs":{},"来":{"docs":{},"指":{"docs":{},"定":{"docs":{},"该":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"需":{"docs":{},"要":{"docs":{},"哪":{"docs":{},"些":{"docs":{},"权":{"docs":{},"限":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"您":{"docs":{},"自":{"docs":{},"己":{"docs":{},"实":{"docs":{},"现":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"处":{"docs":{},"理":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"被":{"docs":{},"我":{"docs":{},"们":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"专":{"docs":{},"用":{"docs":{},"错":{"docs":{},"误":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"更":{"docs":{},"加":{"docs":{},"详":{"docs":{},"细":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"完":{"docs":{},"全":{"docs":{},"一":{"docs":{},"样":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"是":{"docs":{},"在":{"docs":{},"发":{"docs":{},"送":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"的":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"个":{"docs":{},"（":{"docs":{},"数":{"docs":{},"据":{"docs":{},"）":{"docs":{},"块":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"阻":{"docs":{},"止":{"docs":{},"从":{"1":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"2":{"docs":{},"发":{"docs":{},"送":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}}}},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"分":{"docs":{},"布":{"docs":{},"式":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"在":{"docs":{},"响":{"docs":{},"应":{"docs":{},"发":{"docs":{},"送":{"docs":{},"回":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"自":{"docs":{},"动":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"正":{"docs":{},"在":{"docs":{},"重":{"docs":{},"置":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"连":{"docs":{},"接":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"它":{"docs":{},"。":{"docs":{},"此":{"docs":{},"消":{"docs":{},"息":{"docs":{},"还":{"docs":{},"可":{"docs":{},"能":{"docs":{},"表":{"docs":{},"示":{"docs":{},"您":{"docs":{},"没":{"docs":{},"有":{"docs":{},"读":{"docs":{},"取":{"docs":{},"完":{"docs":{},"整":{"docs":{},"的":{"docs":{},"有":{"docs":{},"效":{"docs":{},"负":{"docs":{},"荷":{"docs":{},"（":{"docs":{},"连":{"docs":{},"接":{"docs":{},"在":{"docs":{},"读":{"docs":{},"取":{"docs":{},"完":{"docs":{},"全":{"docs":{},"之":{"docs":{},"前":{"docs":{},"被":{"docs":{},"切":{"docs":{},"断":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"向":{"docs":{},"这":{"docs":{},"个":{"docs":{},"地":{"docs":{},"址":{"docs":{},"发":{"docs":{},"送":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{},"有":{"docs":{},"s":{"docs":{},"l":{"docs":{},"f":{"4":{"docs":{},"j":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"保":{"docs":{},"证":{"docs":{},"您":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"每":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"远":{"docs":{},"程":{"docs":{},"对":{"docs":{},"等":{"docs":{},"体":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"只":{"docs":{},"用":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"编":{"docs":{},"写":{"docs":{},"你":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"一":{"docs":{},"次":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"其":{"docs":{},"他":{"docs":{},"语":{"docs":{},"言":{"docs":{},"中":{"docs":{},"以":{"docs":{},"一":{"docs":{},"种":{"docs":{},"习":{"docs":{},"惯":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"风":{"docs":{},"格":{"docs":{},"进":{"docs":{},"行":{"docs":{},"服":{"docs":{},"务":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"必":{"docs":{},"管":{"docs":{},"服":{"docs":{},"务":{"docs":{},"是":{"docs":{},"在":{"docs":{},"本":{"docs":{},"地":{"docs":{},"还":{"docs":{},"是":{"docs":{},"在":{"docs":{},"e":{"docs":{},"v":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"点":{"docs":{},"类":{"docs":{},"似":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}},"样":{"docs":{},"做":{"docs":{},"可":{"docs":{},"以":{"docs":{},"得":{"docs":{},"到":{"docs":{},"和":{"docs":{},"上":{"docs":{},"边":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"您":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"被":{"docs":{},"发":{"docs":{},"送":{"docs":{},"至":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"的":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},"链":{"docs":{},"式":{"docs":{},"调":{"docs":{},"用":{"docs":{},"会":{"docs":{},"让":{"docs":{},"您":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"更":{"docs":{},"为":{"docs":{},"简":{"docs":{},"洁":{"docs":{},"。":{"docs":{},"当":{"docs":{},"然":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"不":{"docs":{},"喜":{"docs":{},"欢":{"docs":{},"流":{"docs":{},"式":{"docs":{},"风":{"docs":{},"格":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"不":{"docs":{},"强":{"docs":{},"制":{"docs":{},"您":{"docs":{},"用":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"书":{"docs":{},"写":{"docs":{},"代":{"docs":{},"码":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"更":{"docs":{},"倾":{"docs":{},"向":{"docs":{},"于":{"docs":{},"用":{"docs":{},"以":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"编":{"docs":{},"码":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"它":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"您":{"docs":{},"将":{"docs":{},"能":{"docs":{},"够":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"被":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"确":{"docs":{},"保":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"不":{"docs":{},"同":{"docs":{},"线":{"docs":{},"程":{"docs":{},"之":{"docs":{},"间":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}},"次":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"端":{"docs":{},"口":{"8":{"0":{"docs":{},"和":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"主":{"docs":{},"机":{"docs":{},"名":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"docs":{}},"docs":{}}}}}}}},"种":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"不":{"docs":{},"处":{"docs":{},"理":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"先":{"docs":{},"监":{"docs":{},"听":{"docs":{},"他":{"docs":{},"们":{"docs":{},"，":{"docs":{},"之":{"docs":{},"后":{"docs":{},"再":{"docs":{},"取":{"docs":{},"消":{"docs":{},"监":{"docs":{},"听":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"主":{"docs":{},"要":{"docs":{},"缺":{"docs":{},"点":{"docs":{},"是":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"版":{"docs":{},"本":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"于":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"的":{"docs":{},"版":{"docs":{},"本":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"解":{"docs":{},"决":{"docs":{},"这":{"docs":{},"个":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"对":{"docs":{},"于":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"要":{"docs":{},"获":{"docs":{},"取":{"docs":{},"资":{"docs":{},"源":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"者":{"docs":{},"证":{"docs":{},"书":{"docs":{},"是":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"。":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}},"（":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"和":{"docs":{},"密":{"docs":{},"码":{"docs":{},"，":{"docs":{},"通":{"docs":{},"常":{"docs":{},"使":{"docs":{},"用":{"docs":{},"交":{"docs":{},"互":{"docs":{},"式":{"docs":{},"表":{"docs":{},"单":{"docs":{},"）":{"docs":{},"是":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"。":{"docs":{},"它":{"docs":{},"用":{"docs":{},"于":{"docs":{},"从":{"docs":{},"已":{"docs":{},"经":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{},"直":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{},"认":{"docs":{},"证":{"docs":{},"模":{"docs":{},"式":{"docs":{},"的":{"docs":{},"如":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{},"或":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"向":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{},"认":{"docs":{},"证":{"docs":{},"方":{"docs":{},"式":{"docs":{},"迁":{"docs":{},"移":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"将":{"docs":{},"证":{"docs":{},"书":{"docs":{},"直":{"docs":{},"接":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{},"中":{"docs":{},"的":{"docs":{},"访":{"docs":{},"问":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"。":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"任":{"docs":{},"何":{"docs":{},"进":{"docs":{},"一":{"docs":{},"步":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"非":{"docs":{},"常":{"docs":{},"像":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"表":{"docs":{},"示":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"会":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"所":{"docs":{},"有":{"docs":{},"路":{"docs":{},"径":{"docs":{},"以":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"将":{"docs":{},"所":{"docs":{},"有":{"docs":{},"以":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"在":{"docs":{},"开":{"docs":{},"发":{"docs":{},"时":{"docs":{},"会":{"docs":{},"导":{"docs":{},"致":{"docs":{},"一":{"docs":{},"个":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"当":{"docs":{},"您":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"您":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"有":{"docs":{},"多":{"docs":{},"个":{"docs":{},"应":{"docs":{},"用":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"希":{"docs":{},"望":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"使":{"docs":{},"用":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"任":{"docs":{},"何":{"docs":{},"请":{"docs":{},"求":{"docs":{},"受":{"docs":{},"保":{"docs":{},"护":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"你":{"docs":{},"应":{"docs":{},"该":{"docs":{},"传":{"docs":{},"入":{"docs":{},"这":{"docs":{},"个":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"到":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"头":{"docs":{},"授":{"docs":{},"权":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"像":{"docs":{},"这":{"docs":{},"样":{"docs":{},"：":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"部":{"docs":{},"分":{"docs":{},"内":{"docs":{},"容":{"docs":{},"阐":{"docs":{},"述":{"docs":{},"了":{"docs":{},"如":{"docs":{},"何":{"docs":{},"在":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"中":{"docs":{},"配":{"docs":{},"置":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}},"就":{"docs":{},"是":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"（":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}},"进":{"docs":{},"入":{"docs":{},"项":{"docs":{},"目":{"docs":{},"根":{"docs":{},"目":{"docs":{},"录":{"docs":{"./":{"ref":"./","tf":0.01282051282051282}}}}}}}},"程":{"docs":{},"能":{"docs":{},"够":{"docs":{},"在":{"docs":{},"您":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"，":{"docs":{},"与":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"行":{"docs":{},"交":{"docs":{},"互":{"docs":{},"。":{"docs":{},"主":{"docs":{},"要":{"docs":{},"用":{"docs":{},"于":{"docs":{},"运":{"docs":{},"行":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"保":{"docs":{},"存":{"docs":{},"，":{"docs":{},"获":{"docs":{},"取":{"docs":{},"，":{"docs":{},"搜":{"docs":{},"索":{"docs":{},"和":{"docs":{},"删":{"docs":{},"除":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}},"编":{"docs":{},"码":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"结":{"docs":{},"果":{"docs":{},"写":{"docs":{},"入":{"docs":{},"到":{"docs":{},"报":{"docs":{},"文":{"docs":{},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"自":{"docs":{},"动":{"docs":{},"类":{"docs":{},"型":{"docs":{},"转":{"docs":{},"换":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}},"迭":{"docs":{},"代":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}},"一":{"docs":{},"些":{"docs":{},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"具":{"docs":{},"体":{"docs":{},"可":{"docs":{},"以":{"docs":{},"参":{"docs":{},"考":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}},"消":{"docs":{},"费":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"加":{"docs":{},"入":{"docs":{},"到":{"docs":{},"某":{"docs":{},"个":{"docs":{},"消":{"docs":{},"费":{"docs":{},"组":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"在":{"docs":{},"单":{"docs":{},"节":{"docs":{},"点":{"docs":{},"时":{"docs":{},"它":{"docs":{},"的":{"docs":{},"值":{"docs":{},"是":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"，":{"docs":{},"在":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"时":{"docs":{},"是":{"docs":{},"节":{"docs":{},"点":{"docs":{},"的":{"docs":{},"i":{"docs":{},"d":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"果":{"docs":{},"将":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}},"方":{"docs":{},"法":{"docs":{},"调":{"docs":{},"用":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}},"制":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"来":{"docs":{},"保":{"docs":{},"存":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"随":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"着":{"docs":{"./":{"ref":"./","tf":0.01282051282051282},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"后":{"docs":{},"在":{"docs":{},"p":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{},"中":{"docs":{},"加":{"docs":{},"入":{"docs":{},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"和":{"docs":{},"插":{"docs":{},"件":{"docs":{},"，":{"docs":{},"如":{"docs":{},"下":{"docs":{},"所":{"docs":{},"示":{"docs":{},"：":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"/":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"/":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"目":{"docs":{},"录":{"docs":{},"下":{"docs":{},"新":{"docs":{},"增":{"docs":{},"m":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"文":{"docs":{},"件":{"docs":{},"：":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"打":{"docs":{},"开":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"，":{"docs":{},"在":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"栏":{"docs":{},"中":{"docs":{},"输":{"docs":{},"入":{"docs":{},"：":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},":":{"8":{"0":{"8":{"0":{"docs":{},"/":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"修":{"docs":{},"改":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"为":{"docs":{},"：":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}},"点":{"docs":{},"开":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"右":{"docs":{},"边":{"docs":{},"的":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"窗":{"docs":{},"口":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}},"机":{"docs":{},"访":{"docs":{},"问":{"docs":{},"写":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"读":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"\"":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}},"docs":{}}},"docs":{}}},"docs":{}},"\"":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"1":{"0":{"0":{"0":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"2":{"4":{"docs":{},"\"":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"docs":{}},"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0013005109150023223}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"2":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"2":{"3":{"2":{"4":{"4":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}},"docs":{}},"docs":{}},"docs":{}},"7":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},";":{"docs":{},"/":{"docs":{},"/":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"9":{"3":{"7":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"docs":{}},"docs":{}},"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.003976143141153081}}}}}},"2":{"3":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"8":{"1":{"2":{"docs":{},"b":{"9":{"4":{"5":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},".":{"5":{"docs":{},".":{"1":{"3":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"docs":{}},"docs":{}}},"docs":{}}},"3":{"2":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"docs":{},"(":{"docs":{},"#":{"0":{"docs":{},"/":{"docs":{},"!":{"docs":{},"~":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}},"docs":{}}}},"4":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"docs":{}}},"docs":{}}},"8":{"1":{"0":{"7":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.006409660938225732},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.019553072625698324},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.004073319755600814},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.004103967168262654},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.008614976805831677},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.016666666666666666},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0046168051708217915},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.009554140127388535},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0058823529411764705}},"/":{"docs":{},"\"":{"docs":{},",":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.008403361344537815}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"l":{"docs":{},"a":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"/":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{},"/":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}},"docs":{}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}},";":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}},";":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.0260707635009311}},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"u":{"docs":{},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},":":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"/":{"docs":{},":":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{},"/":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"/":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"/":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"i":{"docs":{},"d":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"m":{"docs":{},"y":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"m":{"docs":{},"s":{"docs":{},"/":{"docs":{},"\"":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}}}}}}}}}},"u":{"docs":{},"a":{"docs":{},"s":{"docs":{},"/":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{},"/":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"_":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"\"":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.008403361344537815}}},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.002742230347349177}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}},":":{"2":{"1":{"8":{"1":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}},"docs":{}},"docs":{}},"docs":{}},"9":{"0":{"9":{"2":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.007952286282306162}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"x":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"/":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"m":{"docs":{},"e":{"2":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"\"":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},")":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},",":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"h":{"docs":{},"e":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.00746775288526816},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"/":{"docs":{},"指":{"docs":{},"定":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"函":{"docs":{},"数":{"docs":{},"所":{"docs":{},"在":{"docs":{},"的":{"docs":{},"类":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"/":{"docs":{},"新":{"docs":{},"增":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},",":{"docs":{},"/":{"docs":{},"/":{"docs":{},"改":{"docs":{},"为":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"a":{"docs":{},"f":{"docs":{},"k":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{},"/":{"docs":{},"/":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}},":":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}},"n":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"\"":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},":":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"\"":{"docs":{},":":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},":":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.037383177570093455}}}}}},"x":{"docs":{},"i":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},":":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},":":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}},"_":{"docs":{},"\"":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544}}}}}}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}},"y":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.0260707635009311}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"1":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}},"docs":{}}}}}}}},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"/":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"p":{"3":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"docs":{}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"3":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"d":{"docs":{},"b":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.007462686567164179}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"\"":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}},")":{"docs":{},";":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"d":{"docs":{},"b":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.007462686567164179}}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.003976143141153081}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"\"":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}},"i":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.006398537477148081}},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"b":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"*":{"docs":{},"*":{"docs":{},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}},"*":{"docs":{},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}},"\"":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}},"d":{"docs":{},"b":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}}}},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0058823529411764705}},"e":{"docs":{},"\"":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},":":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.020439448134900357}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},".":{"docs":{},"d":{"docs":{},"b":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}}}}}}}}}}},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.005390835579514825}}}}},".":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"\"":{"docs":{},"|":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"\"":{"docs":{},"|":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"|":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},"|":{"docs":{},"\"":{"docs":{},"u":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}}}}}}}}},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"\"":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},".":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},")":{"docs":{},")":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.009917355371900827}},")":{"docs":{},";":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"[":{"docs":{},"\\":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\\":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\\":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"\"":{"docs":{},"]":{"docs":{},"\"":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"a":{"2":{"docs":{},"f":{"docs":{},"p":{"docs":{},"b":{"docs":{},"h":{"docs":{},"v":{"docs":{},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"l":{"docs":{},"z":{"docs":{},"i":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"z":{"docs":{},"s":{"docs":{},"a":{"docs":{},"j":{"docs":{},"m":{"docs":{},"s":{"docs":{},"b":{"docs":{},"i":{"docs":{},"z":{"docs":{},"w":{"docs":{},"f":{"docs":{},"j":{"docs":{},"a":{"docs":{},"c":{"docs":{},"b":{"docs":{},"p":{"docs":{},"b":{"docs":{},"i":{"docs":{},"b":{"0":{"docs":{},"a":{"docs":{},"g":{"docs":{},"u":{"docs":{},"g":{"docs":{},"d":{"2":{"9":{"docs":{},"y":{"docs":{},"b":{"docs":{},"g":{"docs":{},"q":{"docs":{},"=":{"docs":{},"\"":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"docs":{}},"docs":{}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"/":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}}}}}}}}}}}}}}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"\"":{"docs":{},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}}},"l":{"docs":{},"b":{"docs":{},"u":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"a":{"docs":{},"n":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"2":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"docs":{}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{},"m":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}},"\"":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}},"}":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},":":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"\"":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"\"":{"docs":{},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"l":{"docs":{},"a":{"docs":{},"h":{"docs":{},"\"":{"docs":{},",":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"m":{"docs":{},"y":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.009917355371900827}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.009917355371900827}},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"2":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"docs":{}}}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"k":{"docs":{},"g":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"b":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}},",":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},":":{"docs":{},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},":":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"\"":{"docs":{},":":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036}}}}}},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"\"":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},":":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}},"n":{"docs":{},"=":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"=":{"docs":{},",":{"docs":{},"o":{"docs":{},"=":{"docs":{},",":{"docs":{},"l":{"docs":{},"=":{"docs":{},",":{"docs":{},"s":{"docs":{},"t":{"docs":{},"=":{"docs":{},",":{"docs":{},"c":{"docs":{},"=":{"docs":{},"\"":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.016172506738544475}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"f":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}},"o":{"docs":{},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},":":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"r":{"docs":{},"\"":{"docs":{},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.003976143141153081}}},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}}}}}}},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"r":{"docs":{},"t":{"docs":{},"b":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"y":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},":":{"3":{"0":{"0":{"0":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"8":{"0":{"8":{"0":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"8":{"8":{"8":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"/":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}},"s":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},":":{"8":{"4":{"4":{"7":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},".":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}}}}}}}}}}}}}},"t":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"/":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"h":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{},"/":{"docs":{},"v":{"3":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}},"docs":{}}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}},"s":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}},"o":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"o":{"docs":{},"k":{"docs":{},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"s":{"docs":{},"l":{"docs":{},"f":{"4":{"docs":{},"j":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"d":{"docs":{},"b":{"docs":{},".":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"d":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"k":{"docs":{},"a":{"docs":{},"f":{"docs":{},"k":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.008639308855291577}}}}}},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}},"w":{"docs":{},"i":{"docs":{},"b":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}},"t":{"docs":{},"h":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},":":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"t":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"a":{"docs":{},"y":{"docs":{},"!":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}},"{":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.004103967168262654}},"\\":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\\":{"docs":{},"\"":{"docs":{},":":{"docs":{},"\\":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"\\":{"docs":{},"\"":{"docs":{},"}":{"docs":{},"\"":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"\"":{"docs":{},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}},"a":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.003976143141153081}}}}}}}}}}}},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"\"":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"c":{"docs":{},"e":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.005390835579514825}}}}}}}},".":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0047522063815342835}}},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},":":{"docs":{},"h":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"d":{"docs":{},"b":{"docs":{},":":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},":":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"?":{"docs":{},"s":{"docs":{},"h":{"docs":{},"u":{"docs":{},"t":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"c":{"docs":{},"e":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"1":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"3":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"w":{"0":{"docs":{},"r":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},":":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}},")":{"docs":{},";":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}},"t":{"docs":{},"\"":{"docs":{},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},"s":{"docs":{},"t":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"p":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"1":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}},"docs":{}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},",":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"2":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"2":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"docs":{}}}}}}}}}}}}}}},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0064794816414686825}}},")":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}},"g":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"d":{"docs":{},"\"":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}},"的":{"docs":{},"记":{"docs":{},"录":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"\"":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.005301524188204109}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"=":{"docs":{},"\"":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"=":{"docs":{},"\"":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"=":{"docs":{},"\"":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}}}}},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{},"\"":{"docs":{},";":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"$":{"docs":{},"{":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"}":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"}":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.005847953216374269}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"}":{"docs":{},"/":{"docs":{},"$":{"docs":{},"{":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{},"}":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"}":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"}":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.011695906432748537}}}}}}}}}}},"_":{"docs":{},"h":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"}":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"}":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211}},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"c":{"docs":{},"w":{"docs":{},"d":{"docs":{},"/":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"_":{"docs":{},"h":{"docs":{},"o":{"docs":{},"m":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},"e":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}},"(":{"docs":{},"o":{"docs":{},"c":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}},"*":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.011695906432748537},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.004103967168262654},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"/":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.011695906432748537},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"*":{"docs":{},"，":{"docs":{},"*":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"/":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},"*":{"docs":{},"*":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.011695906432748537},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}},"/":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.019136089177891315},"web/Web.html":{"ref":"web/Web.html","tf":0.037244401168451804},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.027932960893854747},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.032586558044806514},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.03146374829001368},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.017278617710583154},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.012437810945273632},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.021206096752816435},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.02631578947368421},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.008086253369272238},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.014778325123152709},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.02040816326530612},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.05289256198347107},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.024007386888273315},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.022727272727272728},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.012738853503184714},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.06796116504854369},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.037815126050420166},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.007312614259597806},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.007677543186180422},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.011029411764705883},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.011661807580174927},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.03411764705882353}},"以":{"docs":{},"下":{"docs":{},"部":{"docs":{},"分":{"docs":{},"新":{"docs":{},"增":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}},"程":{"docs":{},"序":{"docs":{},"先":{"docs":{},"向":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"1":{"docs":{},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"个":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"等":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"1":{"docs":{},"回":{"docs":{},"复":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"将":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"1":{"docs":{},"的":{"docs":{},"回":{"docs":{},"复":{"docs":{},"消":{"docs":{},"息":{"docs":{},"发":{"docs":{},"送":{"docs":{},"给":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"2":{"docs":{},"，":{"docs":{},"最":{"docs":{},"后":{"docs":{},"将":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"2":{"docs":{},"的":{"docs":{},"回":{"docs":{},"复":{"docs":{},"打":{"docs":{},"印":{"docs":{},"到":{"docs":{},"控":{"docs":{},"制":{"docs":{},"台":{"docs":{},"上":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}},"上":{"docs":{},"和":{"docs":{},"以":{"docs":{},"下":{"docs":{},"两":{"docs":{},"种":{"docs":{},"写":{"docs":{},"法":{"docs":{},"是":{"docs":{},"等":{"docs":{},"效":{"docs":{},"的":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.008565310492505354}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"方":{"docs":{},"法":{"docs":{},"填":{"docs":{},"充":{"docs":{},"参":{"docs":{},"数":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"配":{"docs":{},"置":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}},"将":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"存":{"docs":{},"入":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"中":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"实":{"docs":{},"现":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"扁":{"docs":{},"平":{"docs":{},"化":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"对":{"docs":{},"象":{"docs":{},"与":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"对":{"docs":{},"象":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"选":{"docs":{},"取":{"docs":{},"了":{"docs":{},"三":{"docs":{},"种":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"作":{"docs":{},"为":{"docs":{},"示":{"docs":{},"范":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"或":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"未":{"docs":{},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"时":{"docs":{},"，":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"嵌":{"docs":{},"在":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"方":{"docs":{},"法":{"docs":{},"内":{"docs":{},"部":{"docs":{},"，":{"docs":{},"以":{"docs":{},"匿":{"docs":{},"名":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"作":{"docs":{},"为":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"仅":{"docs":{},"回":{"docs":{},"传":{"docs":{},"数":{"docs":{},"据":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"异":{"docs":{},"常":{"docs":{},"处":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"虽":{"docs":{},"然":{"docs":{},"通":{"docs":{},"过":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"发":{"docs":{},"送":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"请":{"docs":{},"求":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}},"注":{"docs":{},"册":{"docs":{},"一":{"docs":{},"个":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"处":{"docs":{},"理":{"docs":{},"进":{"docs":{},"来":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}},"获":{"docs":{},"取":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"平":{"docs":{},"均":{"docs":{},"值":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}},"这":{"docs":{},"里":{"docs":{},"l":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"d":{"docs":{},"a":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"用":{"docs":{},"于":{"docs":{},"接":{"docs":{},"收":{"docs":{},"消":{"docs":{},"息":{"docs":{},"处":{"docs":{},"理":{"docs":{},"结":{"docs":{},"果":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"/":{"docs":{},"b":{"docs":{},"/":{"docs":{},"c":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"?":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"1":{"docs":{},"=":{"docs":{},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"&":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"2":{"docs":{},"=":{"docs":{},"x":{"docs":{},"y":{"docs":{},"z":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"docs":{}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"1":{"2":{"3":{"4":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"w":{"docs":{},"i":{"docs":{},"b":{"docs":{},"b":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"u":{"docs":{},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{},"/":{"docs":{},"d":{"docs":{},"r":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"1":{"2":{"3":{"docs":{},"/":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"会":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"/":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"h":{"docs":{},".":{"docs":{},"h":{"docs":{},"b":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"/":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"/":{"docs":{},"w":{"docs":{},"i":{"docs":{},"b":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}},"/":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"/":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"b":{"docs":{},"，":{"docs":{},"该":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"最":{"docs":{},"后":{"docs":{},"结":{"docs":{},"束":{"docs":{},"了":{"docs":{},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"/":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"h":{"docs":{},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"s":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"首":{"docs":{},"先":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"向":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"添":{"docs":{},"加":{"docs":{},"了":{"docs":{},"值":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"路":{"docs":{},"由":{"docs":{},"到":{"docs":{},"了":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"转":{"docs":{},"发":{"docs":{},"到":{"docs":{},"了":{"docs":{},"路":{"docs":{},"径":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"/":{"docs":{},"c":{"docs":{},"s":{"docs":{},"s":{"docs":{},"/":{"docs":{},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"s":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"h":{"docs":{},".":{"docs":{},"h":{"docs":{},"b":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{},"/":{"docs":{},"d":{"docs":{},"r":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"1":{"2":{"3":{"docs":{},"/":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"会":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}},"，":{"docs":{},"则":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"子":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"所":{"docs":{},"以":{"docs":{},"路":{"docs":{},"径":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"/":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"/":{"docs":{},"$":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"/":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"/":{"docs":{},"$":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"/":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"/":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"/":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"/":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}},"=":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.01824817518248175},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.029978586723768737},"core/Core.html":{"ref":"core/Core.html","tf":0.03725034835113795},"web/Web.html":{"ref":"web/Web.html","tf":0.033836416747809156},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.0335195530726257},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.027834351663272233},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0196078431372549},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.04377564979480164},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.012958963282937365},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.03233830845771144},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.03777335984095427},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.025},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.05263157894736842},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.013477088948787063},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.06403940886699508},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.047619047619047616},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.04462809917355372},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.05263157894736842},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.022727272727272728},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.028662420382165606},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.027082268778742973},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.031512605042016806},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.03656307129798903},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.02111324376199616},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.018480492813141684},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.025735294117647058},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.02040816326530612},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.014778325123152709},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.021176470588235293}},"=":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}},">":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036}}}},">":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.02569593147751606},"core/Core.html":{"ref":"core/Core.html","tf":0.01644217371110079},"web/Web.html":{"ref":"web/Web.html","tf":0.019717624148003893},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.030726256983240222},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.019008825526137134},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.025991792065663474},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.008639308855291577},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.026507620941020542},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.016666666666666666},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.02631578947368421},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.014778325123152709},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.02040816326530612},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.013223140495867768},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.04709141274238227},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.012738853503184714},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.01992846193152785},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.05042016806722689},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.006398537477148081},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0058823529411764705}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"项":{"docs":{},"目":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"，":{"docs":{},"双":{"docs":{},"击":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"便":{"docs":{},"可":{"docs":{},"在":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"s":{"docs":{},"文":{"docs":{},"件":{"docs":{},"夹":{"docs":{},"下":{"docs":{},"生":{"docs":{},"成":{"docs":{},"可":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"我":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{},"是":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052}}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}},"勾":{"docs":{},"选":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}},"填":{"docs":{},"入":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"i":{"docs":{},"d":{"docs":{},"（":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"你":{"docs":{},"所":{"docs":{},"在":{"docs":{},"组":{"docs":{},"织":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"）":{"docs":{},"和":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{},"（":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"项":{"docs":{},"目":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"）":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"/":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"{":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.014989293361884369}},"/":{"docs":{},"/":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"}":{"docs":{},"就":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"，":{"docs":{},"在":{"docs":{},"随":{"docs":{},"后":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"用":{"1":{"docs":{},"s":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"以":{"docs":{},"及":{"2":{"docs":{},"n":{"docs":{},"d":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"来":{"docs":{},"指":{"docs":{},"代":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"匿":{"docs":{},"名":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"让":{"docs":{},"代":{"docs":{},"码":{"docs":{},"更":{"docs":{},"加":{"docs":{},"清":{"docs":{},"晰":{"docs":{},"明":{"docs":{},"了":{"docs":{},"，":{"docs":{},"放":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"中":{"docs":{},"类":{"docs":{},"似":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"=":{"3":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}},"docs":{}}},"docs":{}}},"docs":{}}},"@":{"docs":{},"a":{"docs":{},"f":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}},"{":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"'":{"docs":{},")":{"docs":{},"}":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{},"}":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"'":{"docs":{},")":{"docs":{},"}":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.009411764705882352}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.005847953216374269},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677},"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"e":{"docs":{},"{":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"#":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}},"o":{"docs":{},"v":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0015791918253599629},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00558659217877095},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.003976143141153081},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.015329586101175269},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},"g":{"0":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{},"s":{"docs":{},")":{"docs":{},"{":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413}}}}}}}}},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"]":{"docs":{},"相":{"docs":{},"对":{"docs":{},"应":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"对":{"docs":{},"应":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"，":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"对":{"docs":{},"应":{"docs":{},"参":{"docs":{},"数":{"docs":{},"值":{"docs":{},"）":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0014862981885740826}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00931098696461825},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0035769034236075624}},".":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0010218300046446818},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00931098696461825},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.005620848237097598},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"1":{"2":{"3":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"<":{"docs":{},">":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"_":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.005847953216374269},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.007462686567164179},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"2":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"3":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677},"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}}}}}},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"内":{"docs":{},"容":{"docs":{},"）":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"需":{"docs":{},"要":{"docs":{},"链":{"docs":{},"接":{"docs":{},"的":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0010218300046446818},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.003693444136657433}},"e":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"、":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"、":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"关":{"docs":{},"闭":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"希":{"docs":{},"望":{"docs":{},"在":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"过":{"docs":{},"后":{"docs":{},"收":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"作":{"docs":{},"为":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"）":{"docs":{},"参":{"docs":{},"数":{"docs":{},"传":{"docs":{},"入":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.014925373134328358}}}}}}}},"。":{"docs":{},"此":{"docs":{},"组":{"docs":{},"件":{"docs":{},"让":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}},":":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}},"p":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}},"l":{"docs":{},"i":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"/":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}},"*":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"q":{"docs":{},"=":{"0":{"docs":{},".":{"7":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"docs":{}}},"docs":{}}}}}}}}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"：":{"docs":{},"应":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"x":{"docs":{},"x":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"/":{"1":{"docs":{},".":{"2":{"docs":{},".":{"3":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"i":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.0013005109150023223},"web/Web.html":{"ref":"web/Web.html","tf":0.002677702044790652},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.004975124378109453},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.01662049861495845},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.01910828025477707},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},"我":{"docs":{},"们":{"docs":{},"会":{"docs":{},"将":{"docs":{},"它":{"docs":{},"挂":{"docs":{},"载":{"docs":{},"到":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"些":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"当":{"docs":{},"在":{"docs":{},"程":{"docs":{},"序":{"docs":{},"启":{"docs":{},"动":{"docs":{},"时":{"docs":{},"，":{"docs":{},"设":{"docs":{},"置":{"docs":{},"选":{"docs":{},"项":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}},"不":{"docs":{},"会":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"只":{"docs":{},"使":{"docs":{},"用":{"docs":{},"少":{"docs":{},"量":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"大":{"docs":{},"量":{"docs":{},"的":{"docs":{},"并":{"docs":{},"发":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"的":{"docs":{},"一":{"docs":{},"些":{"docs":{},"对":{"docs":{},"象":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"流":{"docs":{},"程":{"docs":{},"控":{"docs":{},"制":{"docs":{},"（":{"docs":{},"回":{"docs":{},"压":{"docs":{},"）":{"docs":{},"功":{"docs":{},"能":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"却":{"docs":{},"没":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"。":{"docs":{},"s":{"docs":{},"l":{"docs":{},"f":{"4":{"docs":{},"j":{"docs":{},"记":{"docs":{},"录":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"将":{"docs":{},"会":{"docs":{},"丢":{"docs":{},"失":{"docs":{},"。":{"docs":{},"您":{"docs":{},"应":{"docs":{},"该":{"docs":{},"将":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"加":{"docs":{},"入":{"docs":{},"您":{"docs":{},"的":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"。":{"docs":{},"参":{"docs":{},"考":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"内":{"docs":{},"部":{"docs":{},"可":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"每":{"docs":{},"隔":{"docs":{},"一":{"docs":{},"秒":{"docs":{},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"个":{"docs":{},"事":{"docs":{},"件":{"docs":{},"的":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{},"缺":{"docs":{},"省":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"三":{"docs":{},"个":{"docs":{},"步":{"docs":{},"骤":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"拷":{"docs":{},"贝":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"，":{"docs":{},"它":{"docs":{},"本":{"docs":{},"质":{"docs":{},"上":{"docs":{},"是":{"docs":{},"同":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"无":{"docs":{},"论":{"docs":{},"多":{"docs":{},"么":{"docs":{},"努":{"docs":{},"力":{"docs":{},"地":{"docs":{},"去":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"都":{"docs":{},"不":{"docs":{},"能":{"docs":{},"像":{"docs":{},"魔":{"docs":{},"法":{"docs":{},"小":{"docs":{},"精":{"docs":{},"灵":{"docs":{},"撒":{"docs":{},"尘":{"docs":{},"变":{"docs":{},"法":{"docs":{},"一":{"docs":{},"样":{"docs":{},"将":{"docs":{},"它":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"异":{"docs":{},"步":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"毕":{"docs":{},"竟":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"语":{"docs":{},"言":{"docs":{},"有":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"风":{"docs":{},"格":{"docs":{},"，":{"docs":{},"若":{"docs":{},"强":{"docs":{},"行":{"docs":{},"让":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"所":{"docs":{},"以":{"docs":{},"熟":{"docs":{},"悉":{"docs":{},"基":{"docs":{},"于":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"此":{"docs":{},"时":{"docs":{},"您":{"docs":{},"应":{"docs":{},"当":{"docs":{},"使":{"docs":{},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}},"总":{"docs":{},"结":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}},"省":{"docs":{},"去":{"docs":{},"了":{"docs":{},"手":{"docs":{},"写":{"docs":{},"命":{"docs":{},"令":{"docs":{},"的":{"docs":{},"麻":{"docs":{},"烦":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"想":{"docs":{},"通":{"docs":{},"过":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}},"非":{"docs":{},"常":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"页":{"docs":{},"面":{"docs":{},"应":{"docs":{},"用":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}},"有":{"docs":{},"两":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"自":{"docs":{},"然":{"docs":{},"组":{"docs":{},"合":{"docs":{},"成":{"docs":{},"链":{"docs":{},"式":{"docs":{},"处":{"docs":{},"理":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"些":{"docs":{},"接":{"docs":{},"口":{"docs":{},"将":{"docs":{},"这":{"docs":{},"些":{"docs":{},"方":{"docs":{},"法":{"docs":{},"展":{"docs":{},"现":{"docs":{},"给":{"docs":{},"用":{"docs":{},"户":{"docs":{},"，":{"docs":{},"其":{"docs":{},"他":{"docs":{},"语":{"docs":{},"言":{"docs":{},"版":{"docs":{},"本":{"docs":{},"也":{"docs":{},"应":{"docs":{},"该":{"docs":{},"类":{"docs":{},"似":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"或":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"请":{"docs":{},"求":{"docs":{},"访":{"docs":{},"问":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"。":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{},"它":{"docs":{},"不":{"docs":{},"能":{"docs":{},"将":{"docs":{},"服":{"docs":{},"务":{"docs":{},"导":{"docs":{},"出":{"docs":{},"到":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"也":{"docs":{},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"修":{"docs":{},"改":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"配":{"docs":{},"置":{"docs":{},"好":{"docs":{},"了":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"和":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"的":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"（":{"docs":{},"其":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"表":{"docs":{},"现":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"）":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"等":{"docs":{},"等":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}},"=":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0019474196689386564},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515},"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.058823529411764705},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":5.018382352941177},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":5.005830903790088}}}}}},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},"（":{"docs":{},"为":{"docs":{},"空":{"docs":{},"内":{"docs":{},"容":{"docs":{},"建":{"docs":{},"立":{"docs":{},"文":{"docs":{},"件":{"docs":{},"夹":{"docs":{},"结":{"docs":{},"构":{"docs":{},"）":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789},"auth/Auth.html":{"ref":"auth/Auth.html","tf":0.25},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":5.033333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":5.035087719298246},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":5.013477088948787},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":5.029556650246305},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":5.0272108843537415},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"auth/Auth.html":{"ref":"auth/Auth.html","tf":5.041666666666667},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"：":{"docs":{},"认":{"docs":{},"证":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}},"验":{"docs":{},"证":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"：":{"docs":{},"真":{"docs":{},"实":{"docs":{},"性":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922}}}}}}},"o":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.008264462809917356}},"i":{"docs":{},"z":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}},"s":{"docs":{"auth/Auth.html":{"ref":"auth/Auth.html","tf":5.041666666666667}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"：":{"docs":{},"授":{"docs":{},"权":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.016666666666666666}}}}},"：":{"docs":{},"权":{"docs":{},"限":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.009852216748768473},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},",":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"：":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"s":{"docs":{},"/":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"auth/Auth.html":{"ref":"auth/Auth.html","tf":0.16666666666666666}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}},"项":{"docs":{},"目":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"处":{"docs":{},"理":{"docs":{},"认":{"docs":{},"证":{"docs":{},"和":{"docs":{},"授":{"docs":{},"权":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}},"自":{"docs":{},"身":{"docs":{},"并":{"docs":{},"不":{"docs":{},"要":{"docs":{},"求":{"docs":{},"使":{"docs":{},"用":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"许":{"docs":{},"可":{"docs":{},"模":{"docs":{},"型":{"docs":{},"（":{"docs":{},"它":{"docs":{},"本":{"docs":{},"身":{"docs":{},"只":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"不":{"docs":{},"透":{"docs":{},"明":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"）":{"docs":{},"，":{"docs":{},"但":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"比":{"docs":{},"较":{"docs":{},"熟":{"docs":{},"悉":{"docs":{},"的":{"docs":{},"：":{"docs":{},"用":{"docs":{},"户":{"docs":{},"/":{"docs":{},"角":{"docs":{},"色":{"docs":{},"/":{"docs":{},"许":{"docs":{},"可":{"docs":{},"模":{"docs":{},"型":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"在":{"docs":{},"应":{"docs":{},"用":{"docs":{},"里":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"或":{"docs":{},"者":{"docs":{},"多":{"docs":{},"个":{"docs":{},"角":{"docs":{},"色":{"docs":{},"，":{"docs":{},"而":{"docs":{},"一":{"docs":{},"个":{"docs":{},"角":{"docs":{},"色":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"或":{"docs":{},"者":{"docs":{},"多":{"docs":{},"个":{"docs":{},"许":{"docs":{},"可":{"docs":{},"。":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"代":{"docs":{},"码":{"docs":{},"：":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}},"：":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"或":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"上":{"docs":{},"加":{"docs":{},"载":{"docs":{},"一":{"docs":{},"个":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"文":{"docs":{},"件":{"docs":{},"要":{"docs":{},"么":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"要":{"docs":{},"么":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"用":{"docs":{},"于":{"docs":{},"签":{"docs":{},"名":{"docs":{},"和":{"docs":{},"验":{"docs":{},"证":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"，":{"docs":{},"。":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}},"尽":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"轻":{"docs":{},"便":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"使":{"docs":{},"用":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{},"或":{"docs":{},"者":{"docs":{},"通":{"docs":{},"过":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"指":{"docs":{},"定":{"docs":{},"你":{"docs":{},"想":{"docs":{},"要":{"docs":{},"的":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"角":{"docs":{},"色":{"docs":{},"上":{"docs":{},"执":{"docs":{},"行":{"docs":{},"断":{"docs":{},"言":{"docs":{},"。":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"本":{"docs":{},"身":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"授":{"docs":{},"权":{"docs":{},"任":{"docs":{},"何":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"许":{"docs":{},"可":{"docs":{},"（":{"docs":{},"它":{"docs":{},"们":{"docs":{},"仅":{"docs":{},"是":{"docs":{},"不":{"docs":{},"透":{"docs":{},"明":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"）":{"docs":{},"模":{"docs":{},"型":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"和":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"z":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"i":{"docs":{},"v":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"o":{"docs":{},"n":{"0":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}},"1":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}},"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"s":{"docs":{},"）":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.0034079844206426485}},"(":{"3":{"docs":{},")":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"docs":{}},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0019474196689386564}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"e":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"）":{"docs":{},"的":{"docs":{},"路":{"docs":{},"由":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{"data/Data.html":{"ref":"data/Data.html","tf":5.333333333333333},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.011570247933884297}},"等":{"docs":{},"）":{"docs":{},"中":{"docs":{},"找":{"docs":{},"到":{"docs":{},"这":{"docs":{},"些":{"docs":{},"功":{"docs":{},"能":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}}}}}}},"：":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"已":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"校":{"docs":{},"对":{"docs":{},"完":{"docs":{},"成":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.019704433497536946}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"1":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"2":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"3":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.009852216748768473}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"'":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}}}},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"选":{"docs":{},"项":{"docs":{},"会":{"docs":{},"被":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"\"":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.004705882352941176}}},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},",":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}},":":{"docs":{},"挑":{"docs":{},"选":{"docs":{},"任":{"docs":{},"务":{"docs":{},"符":{"docs":{},"合":{"docs":{},"i":{"docs":{},"p":{"docs":{},"地":{"docs":{},"址":{"docs":{},"规":{"docs":{},"则":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"1":{"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"docs":{},"*":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}}}}}}},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"p":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"的":{"docs":{},"p":{"docs":{},"t":{"docs":{},"r":{"docs":{},"概":{"docs":{},"念":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"a":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"l":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"/":{"docs":{},"c":{"docs":{},"r":{"docs":{},"l":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"r":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"d":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"e":{"docs":{},"c":{"docs":{},"d":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"v":{"1":{"docs":{},".":{"1":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"2":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"1":{"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"2":{"docs":{},":":{"4":{"0":{"0":{"0":{"0":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"b":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"b":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"1":{"docs":{},")":{"docs":{},".":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}},"3":{"docs":{},")":{"docs":{},".":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"b":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"b":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"1":{"docs":{},")":{"docs":{},".":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"2":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"integration/JCAAdaptor.html":{"ref":"integration/JCAAdaptor.html","tf":5.333333333333333},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"k":{"docs":{},"a":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.011363636363636364}},"）":{"docs":{},"获":{"docs":{},"得":{"docs":{},"一":{"docs":{},"个":{"docs":{},"发":{"docs":{},"布":{"docs":{},"者":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"其":{"docs":{},"数":{"docs":{},"据":{"docs":{},"泵":{"docs":{},"入":{"docs":{},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"的":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"a":{"docs":{},"a":{"docs":{},"a":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"b":{"docs":{},"/":{"docs":{},"c":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"?":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"1":{"docs":{},"=":{"docs":{},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"&":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"2":{"docs":{},"=":{"docs":{},"x":{"docs":{},"y":{"docs":{},"z":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}},"docs":{}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"n":{"docs":{},"_":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"r":{"docs":{},"b":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"a":{"docs":{},"a":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"那":{"docs":{},"样":{"docs":{},"做":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"（":{"docs":{},"i":{"docs":{},"p":{"docs":{},"v":{"6":{"docs":{},"）":{"docs":{},"记":{"docs":{},"录":{"docs":{},"。":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"（":{"docs":{},"记":{"docs":{},"录":{"docs":{},"）":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"它":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"方":{"docs":{},"式":{"docs":{},"与":{"docs":{},"在":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"第":{"docs":{},"一":{"docs":{},"条":{"docs":{},"被":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"（":{"docs":{},"记":{"docs":{},"录":{"docs":{},"）":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{},"它":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"方":{"docs":{},"式":{"docs":{},"和":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}},"e":{"docs":{},"s":{"1":{"2":{"8":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"docs":{}},"docs":{}},"2":{"5":{"6":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"docs":{}},"docs":{}},"docs":{}}},"f":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"g":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.009554140127388535},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"。":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"代":{"docs":{},"理":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"为":{"docs":{},"运":{"docs":{},"行":{"docs":{},"它":{"docs":{},"的":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"选":{"docs":{},"择":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{},"版":{"docs":{},"本":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"）":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"会":{"docs":{},"进":{"docs":{},"行":{"docs":{},"周":{"docs":{},"期":{"docs":{},"性":{"docs":{},"的":{"docs":{},"扫":{"docs":{},"描":{"docs":{},"，":{"docs":{},"来":{"docs":{},"更":{"docs":{},"新":{"docs":{},"服":{"docs":{},"务":{"docs":{},"情":{"docs":{},"况":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}},"=":{"8":{"6":{"4":{"0":{"0":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"一":{"docs":{},"天":{"docs":{},"。":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"聚":{"docs":{},"合":{"docs":{},"）":{"docs":{},"命":{"docs":{},"令":{"docs":{},"。":{"docs":{},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"命":{"docs":{},"令":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"要":{"docs":{},"做":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215}},"e":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"将":{"docs":{},"不":{"docs":{},"会":{"docs":{},"被":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"自":{"docs":{},"动":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"，":{"docs":{},"要":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"它":{"docs":{},"们":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.02425876010781671}}}},"p":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"支":{"docs":{},"持":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"的":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"，":{"docs":{},"它":{"docs":{},"在":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"开":{"docs":{},"始":{"docs":{},"交":{"docs":{},"换":{"docs":{},"数":{"docs":{},"据":{"docs":{},"之":{"docs":{},"前":{"docs":{},"协":{"docs":{},"商":{"docs":{},"协":{"docs":{},"议":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"小":{"docs":{},"型":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"，":{"docs":{},"它":{"docs":{},"覆":{"docs":{},"盖":{"docs":{},"了":{"docs":{},"几":{"docs":{},"种":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"g":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.02425876010781671}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"a":{"docs":{},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"）":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"当":{"docs":{},"运":{"docs":{},"行":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"突":{"docs":{},"然":{"docs":{},"挂":{"docs":{},"掉":{"docs":{},"时":{"docs":{},"，":{"docs":{},"该":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"l":{"docs":{},"c":{"docs":{},"e":{"docs":{},"将":{"docs":{},"迁":{"docs":{},"移":{"docs":{},"到":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"高":{"docs":{},"可":{"docs":{},"用":{"docs":{},"性":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"y":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"h":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},"h":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.006369426751592357}}}}}}}}}}}}}},"z":{"docs":{},"u":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"最":{"docs":{},"终":{"docs":{},"得":{"docs":{},"到":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"是":{"docs":{},"：":{"docs":{},"{":{"docs":{},"a":{"docs":{},":":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"e":{"docs":{},"或":{"docs":{},"者":{"docs":{},"是":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}},"的":{"docs":{},"支":{"docs":{},"持":{"docs":{},"，":{"docs":{},"幸":{"docs":{},"运":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"些":{"docs":{},"貌":{"docs":{},"似":{"docs":{},"很":{"docs":{},"牛":{"docs":{},"逼":{"docs":{},"其":{"docs":{},"实":{"docs":{},"无":{"docs":{},"用":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"用":{"docs":{},"社":{"docs":{},"区":{"docs":{},"版":{"docs":{},"就":{"docs":{},"好":{"docs":{},"了":{"docs":{},"。":{"docs":{},"下":{"docs":{},"载":{"docs":{},"后":{"docs":{},"安":{"docs":{},"装":{"docs":{},"。":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.017543859649122806},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.005847953216374269},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.006423982869379015},"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"：":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"将":{"docs":{},"密":{"docs":{},"码":{"docs":{},"最":{"docs":{},"终":{"docs":{},"加":{"docs":{},"密":{"docs":{},"结":{"docs":{},"果":{"docs":{},"存":{"docs":{},"储":{"docs":{},"在":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"中":{"docs":{},"，":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"“":{"docs":{},"值":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"外":{"docs":{},"部":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"进":{"docs":{},"行":{"docs":{},"设":{"docs":{},"置":{"docs":{},"。":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}},"c":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.008565310492505354},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"r":{"docs":{},"若":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"发":{"docs":{},"生":{"docs":{},"异":{"docs":{},"常":{"docs":{},"，":{"docs":{},"将":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"若":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"发":{"docs":{},"生":{"docs":{},"异":{"docs":{},"常":{"docs":{},"，":{"docs":{},"则":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},"o":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"等":{"docs":{},"这":{"docs":{},"些":{"docs":{},"并":{"docs":{},"发":{"docs":{},"和":{"docs":{},"线":{"docs":{},"程":{"docs":{},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{},"东":{"docs":{},"西":{"docs":{},"就":{"docs":{},"不":{"docs":{},"再":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"由":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"全":{"docs":{},"面":{"docs":{},"接":{"docs":{},"管":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"不":{"docs":{},"得":{"docs":{},"不":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"上":{"docs":{},"诉":{"docs":{},"内":{"docs":{},"容":{"docs":{},"，":{"docs":{},"则":{"docs":{},"多":{"docs":{},"少":{"docs":{},"暗":{"docs":{},"示":{"docs":{},"着":{"docs":{},"您":{"docs":{},"的":{"docs":{},"设":{"docs":{},"计":{"docs":{},"或":{"docs":{},"者":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"姿":{"docs":{},"势":{"docs":{},"出":{"docs":{},"现":{"docs":{},"了":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"建":{"docs":{},"议":{"docs":{},"再":{"docs":{},"斟":{"docs":{},"酌":{"docs":{},"商":{"docs":{},"榷":{"docs":{},"一":{"docs":{},"下":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"e":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"s":{"docs":{},".":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"o":{"docs":{},"s":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}},"m":{"docs":{},"p":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.004103967168262654}},"t":{"docs":{},"i":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"y":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}},"c":{"2":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"。":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}},"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.008086253369272238}},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"6":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"docs":{}}}}}}}}},"d":{"docs":{},"s":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.008086253369272238}}}}},"l":{"docs":{},"i":{"docs":{},"p":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"e":{"docs":{},"：":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"运":{"docs":{},"行":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"作":{"docs":{},"为":{"docs":{},"主":{"docs":{},"类":{"docs":{},"。":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"b":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.006688341848583372},"web/Web.html":{"ref":"web/Web.html","tf":0.005355404089581304},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.009554140127388535},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.004087889626980072},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}},"b":{"docs":{},"u":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.0010218300046446818},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"eventbusbridge/TCPEventbusBridge.html":{"ref":"eventbusbridge/TCPEventbusBridge.html","tf":3.583333333333333},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.009554140127388535},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"s":{"docs":{},".":{"docs":{},"u":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"s":{"docs":{},".":{"docs":{},"u":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"j":{"docs":{},"o":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"s":{"docs":{},".":{"docs":{},"u":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}},"j":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"还":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"指":{"docs":{},"定":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"(":{"docs":{},"'":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},":":{"8":{"0":{"8":{"0":{"docs":{},"/":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036}},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"(":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"y":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}},"a":{"docs":{},"l":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0064794816414686825}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0064794816414686825}}}}}}}},".":{"docs":{},"g":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"b":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.009554140127388535},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"s":{"docs":{},".":{"docs":{},"u":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"f":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}},"d":{"docs":{},"：":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"o":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"_":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"_":{"docs":{},"a":{"docs":{},"g":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001114723641430562},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.009554140127388535}},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\\":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"e":{"docs":{},"r":{"docs":{},"：":{"docs":{},"当":{"docs":{},"流":{"docs":{},"到":{"docs":{},"达":{"docs":{},"时":{"docs":{},"将":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"这":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"到":{"docs":{},"达":{"docs":{},"了":{"docs":{},"描":{"docs":{},"述":{"docs":{},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{},"、":{"docs":{},"达":{"docs":{},"到":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"结":{"docs":{},"束":{"docs":{},"、":{"docs":{},"或":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}},":":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}},"服":{"docs":{},"务":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"发":{"docs":{},"布":{"docs":{},"好":{"docs":{},"了":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"获":{"docs":{},"取":{"docs":{},"到":{"docs":{},"这":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"。":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"象":{"docs":{},"就":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"配":{"docs":{},"置":{"docs":{},"了":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"、":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"和":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"的":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"个":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"=":{"docs":{},"\"":{"docs":{},"+":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001207617278216442}}},"：":{"docs":{},"条":{"docs":{},"目":{"docs":{},"（":{"docs":{},"一":{"docs":{},"条":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"=":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"的":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"y":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"v":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"x":{"docs":{},"，":{"docs":{},"（":{"docs":{},"这":{"docs":{},"个":{"docs":{},"）":{"docs":{},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"导":{"docs":{},"出":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"*":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"r":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"o":{"docs":{},"r":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.002793296089385475},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"您":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"需":{"docs":{},"要":{"docs":{},"覆":{"docs":{},"盖":{"docs":{},"到":{"docs":{},"的":{"docs":{},"路":{"docs":{},"径":{"docs":{},"上":{"docs":{},"将":{"docs":{},"它":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"失":{"docs":{},"败":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"(":{"9":{"docs":{},")":{"docs":{},"来":{"docs":{},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.002793296089385475}}}}}}}}}}}}}}}}},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}},":":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.008403361344537815}}}}},")":{"docs":{},"，":{"docs":{},"如":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"没":{"docs":{},"有":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"已":{"docs":{},"注":{"docs":{},"册":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"s":{"2":{"5":{"6":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}},"docs":{}},"docs":{}},"3":{"8":{"4":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}},"docs":{}},"docs":{}},"5":{"1":{"2":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}},"docs":{}},"docs":{}},"docs":{}},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}},"f":{"2":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"3":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.004705882352941176}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"，":{"docs":{},"随":{"docs":{},"后":{"docs":{},"会":{"docs":{},"建":{"docs":{},"立":{"docs":{},"以":{"docs":{},"下":{"docs":{},"文":{"docs":{},"件":{"docs":{},"结":{"docs":{},"构":{"docs":{},"，":{"docs":{},"跟":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"文":{"docs":{},"件":{"docs":{},"夹":{"docs":{},"结":{"docs":{},"构":{"docs":{},"几":{"docs":{},"乎":{"docs":{},"一":{"docs":{},"样":{"docs":{},"：":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"d":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407}},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}},"p":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}},"l":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001672085462145843},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.003693444136657433},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"(":{"docs":{},"r":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"s":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}},".":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"/":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"o":{"docs":{},"r":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}},"，":{"docs":{},"即":{"docs":{},"文":{"docs":{},"件":{"docs":{},"上":{"docs":{},"传":{"docs":{},"）":{"docs":{},"，":{"docs":{},"该":{"docs":{},"功":{"docs":{},"能":{"docs":{},"可":{"docs":{},"能":{"docs":{},"在":{"docs":{},"将":{"docs":{},"来":{"docs":{},"版":{"docs":{},"本":{"docs":{},"中":{"docs":{},"予":{"docs":{},"以":{"docs":{},"支":{"docs":{},"持":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.004570383912248629}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"r":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"r":{"docs":{},"e":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"d":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407}},"（":{"docs":{},"字":{"docs":{},"段":{"docs":{},"）":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"是":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.012738853503184714}},"(":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"这":{"docs":{},"个":{"docs":{},"词":{"docs":{},"国":{"docs":{},"内":{"docs":{},"有":{"docs":{},"译":{"docs":{},"作":{"docs":{},"纤":{"docs":{},"程":{"docs":{},"，":{"docs":{},"类":{"docs":{},"似":{"docs":{},"协":{"docs":{},"程":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},"字":{"docs":{},"节":{"docs":{},"码":{"docs":{},"增":{"docs":{},"强":{"docs":{},"工":{"docs":{},"作":{"docs":{},"是":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},".":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}},".":{"docs":{},"c":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"j":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"g":{"docs":{},"z":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"x":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"r":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.002793296089385475}},"a":{"docs":{},"t":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.003656307129798903}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.004598875830352581}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"\"":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"r":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"x":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}},"p":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"o":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.008565310492505354}}},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"e":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"这":{"docs":{},"样":{"docs":{},"任":{"docs":{},"何":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"q":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":10.002141327623127}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":5.037383177570093},"services/MavenServiceFactory.html":{"ref":"services/MavenServiceFactory.html","tf":3.583333333333333},"services/HTTPServiceFactory.html":{"ref":"services/HTTPServiceFactory.html","tf":3.583333333333333}}},"y":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"会":{"docs":{},"从":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"：":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"？":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},":":{"3":{"docs":{},".":{"2":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}},"docs":{}}},"docs":{}}},"docs":{}},"的":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"是":{"docs":{},"f":{"docs":{},"a":{"docs":{},"t":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"i":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.017543859649122806},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.009852216748768473},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.013605442176870748},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.004087889626980072},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}},"e":{"docs":{},"d":{"docs":{},"!":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.005471956224350205},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}},"u":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},":":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001207617278216442},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.004975124378109453},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635}},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215}}}}}}},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.004103967168262654}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},"方":{"docs":{},"法":{"docs":{},"当":{"docs":{},"且":{"docs":{},"仅":{"docs":{},"当":{"docs":{},"前":{"docs":{},"一":{"docs":{},"个":{"docs":{},"异":{"docs":{},"步":{"docs":{},"流":{"docs":{},"程":{"docs":{},"执":{"docs":{},"行":{"docs":{},"成":{"docs":{},"功":{"docs":{},"时":{"docs":{},"才":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}},"该":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}},"(":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}}},"e":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}},"?":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}},"t":{"1":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"中":{"docs":{},"文":{"docs":{},"件":{"docs":{},"创":{"docs":{},"建":{"docs":{},"完":{"docs":{},"成":{"docs":{},"后":{"docs":{},"执":{"docs":{},"行":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"2":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"文":{"docs":{},"件":{"docs":{},"写":{"docs":{},"入":{"docs":{},"完":{"docs":{},"成":{"docs":{},"后":{"docs":{},"执":{"docs":{},"行":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"docs":{},"u":{"docs":{},"r":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.019271948608137045},"core/Core.html":{"ref":"core/Core.html","tf":0.0039015327450069672},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.01680672268907563},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.003656307129798903},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"e":{"1":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677}},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}},"2":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677}},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}},"3":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"docs":{},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}},".":{"docs":{},">":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},"(":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}},"f":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.008565310492505354}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677}}}}}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}},")":{"docs":{},";":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0063025210084033615}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"s":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},"e":{"docs":{},"(":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.01284796573875803},"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.008403361344537815}}}}}}}},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}},"r":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},">":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.01284796573875803}}},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"当":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"这":{"docs":{},"个":{"docs":{},"特":{"docs":{},"性":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"于":{"docs":{},"定":{"docs":{},"制":{"docs":{},"您":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"过":{"docs":{},"滤":{"docs":{},"器":{"docs":{},"、":{"docs":{},"细":{"docs":{},"粒":{"docs":{},"度":{"docs":{},"的":{"docs":{},"授":{"docs":{},"权":{"docs":{},"或":{"docs":{},"指":{"docs":{},"标":{"docs":{},"收":{"docs":{},"集":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"果":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"的":{"docs":{},"启":{"docs":{},"动":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"型":{"docs":{},"的":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"必":{"docs":{},"须":{"docs":{},"使":{"docs":{},"用":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}},"，":{"docs":{},"针":{"docs":{},"对":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"过":{"docs":{},"程":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"声":{"docs":{},"明":{"docs":{},"中":{"docs":{},"间":{"docs":{},"变":{"docs":{},"量":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}},"以":{"docs":{},"此":{"docs":{},"来":{"docs":{},"汇":{"docs":{},"报":{"docs":{},"处":{"docs":{},"理":{"docs":{},"成":{"docs":{},"功":{"docs":{},"或":{"docs":{},"者":{"docs":{},"失":{"docs":{},"败":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"否":{"docs":{},"则":{"docs":{},"就":{"docs":{},"标":{"docs":{},"记":{"docs":{},"为":{"docs":{},"失":{"docs":{},"败":{"docs":{},"。":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"3":{"docs":{},".":{"4":{"docs":{},".":{"0":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"）":{"docs":{},"会":{"docs":{},"是":{"docs":{},"成":{"docs":{},"功":{"docs":{},"的":{"docs":{},"；":{"docs":{},"其":{"docs":{},"中":{"docs":{},"任":{"docs":{},"何":{"docs":{},"一":{"docs":{},"步":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"则":{"docs":{},"最":{"docs":{},"终":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"；":{"docs":{},"当":{"docs":{},"任":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"(":{"docs":{},"超":{"docs":{},"时":{"docs":{},")":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},":":{"docs":{},":":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"：":{"docs":{},"流":{"docs":{},"式":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"s":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"：":{"docs":{},"刷":{"docs":{},"新":{"docs":{},"（":{"docs":{},"指":{"docs":{},"将":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"区":{"docs":{},"中":{"docs":{},"已":{"docs":{},"有":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"一":{"docs":{},"次":{"docs":{},"性":{"docs":{},"压":{"docs":{},"入":{"docs":{},"，":{"docs":{},"用":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"清":{"docs":{},"空":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"区":{"docs":{},"，":{"docs":{},"传":{"docs":{},"统":{"docs":{},"上":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"成":{"docs":{},"刷":{"docs":{},"新":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"w":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}},"：":{"docs":{},"流":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"1":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"2":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"3":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"s":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"：":{"docs":{},"帧":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},")":{"docs":{},"。":{"docs":{},"但":{"docs":{},"是":{"docs":{},"若":{"docs":{},"您":{"docs":{},"不":{"docs":{},"想":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"e":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243}},"e":{"docs":{},"r":{"docs":{},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}},"：":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},":":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}},"/":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}}}}}}},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052},"core/Core.html":{"ref":"core/Core.html","tf":0.0019507663725034836},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.009950248756218905},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.01727447216890595},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.02053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.026239067055393587},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"。":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"文":{"docs":{},"件":{"docs":{},"本":{"docs":{},"质":{"docs":{},"上":{"docs":{},"就":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"打":{"docs":{},"开":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"的":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"工":{"docs":{},"具":{"docs":{},"解":{"docs":{},"压":{"docs":{},"，":{"docs":{},"读":{"docs":{},"者":{"docs":{},"可":{"docs":{},"自":{"docs":{},"行":{"docs":{},"解":{"docs":{},"压":{"docs":{},"拆":{"docs":{},"开":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"包":{"docs":{},"，":{"docs":{},"看":{"docs":{},"看":{"docs":{},"相":{"docs":{},"关":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"是":{"docs":{},"否":{"docs":{},"在":{"docs":{},"里":{"docs":{},"面":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"除":{"docs":{},"了":{"docs":{},"生":{"docs":{},"成":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"和":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"文":{"docs":{},"件":{"docs":{},"以":{"docs":{},"外":{"docs":{},"，":{"docs":{},"还":{"docs":{},"同":{"docs":{},"时":{"docs":{},"将":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"的":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"中":{"docs":{},"的":{"docs":{},"内":{"docs":{},"容":{"docs":{},"压":{"docs":{},"入":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"包":{"docs":{},"。":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}},"一":{"docs":{},"样":{"docs":{},"可":{"docs":{},"直":{"docs":{},"接":{"docs":{},"执":{"docs":{},"行":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"中":{"docs":{},"时":{"docs":{},"，":{"docs":{},"您":{"docs":{},"必":{"docs":{},"须":{"docs":{},"将":{"docs":{},"下":{"docs":{},"边":{"docs":{},"信":{"docs":{},"息":{"docs":{},"写":{"docs":{},"入":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"f":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"或":{"docs":{},"包":{"docs":{},"含":{"docs":{},"在":{"docs":{},"其":{"docs":{},"中":{"docs":{},"）":{"docs":{},"的":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{},"，":{"docs":{},"或":{"docs":{},"放":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"发":{"docs":{},"行":{"docs":{},"版":{"docs":{},"的":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"目":{"docs":{},"录":{"docs":{},"中":{"docs":{},"，":{"docs":{},"您":{"docs":{},"将":{"docs":{},"可":{"docs":{},"以":{"docs":{},"执":{"docs":{},"行":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"则":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"命":{"docs":{},"令":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"要":{"docs":{},"确":{"docs":{},"保":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}},"）":{"docs":{},"里":{"docs":{},"进":{"docs":{},"行":{"docs":{},"分":{"docs":{},"发":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"包":{"docs":{},"为":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"如":{"docs":{},"下":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"：":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.005847953216374269},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"core/Core.html":{"ref":"core/Core.html","tf":0.002693915466790525},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.009554140127388535},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.007677543186180422},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.008213552361396304},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.011661807580174927}},"基":{"docs":{},"础":{"docs":{},"知":{"docs":{},"识":{"docs":{},"，":{"docs":{},"您":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"了":{"docs":{},"解":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}},"的":{"docs":{},"知":{"docs":{},"识":{"docs":{},"点":{"docs":{},"。":{"docs":{},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"：":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}},"中":{"docs":{},"，":{"docs":{},"l":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"d":{"docs":{},"a":{"docs":{},"本":{"docs":{},"身":{"docs":{},"也":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"@":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"对":{"docs":{},"象":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"或":{"docs":{},"者":{"docs":{},"多":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"上":{"docs":{},"述":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"m":{"docs":{},"y":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"中":{"docs":{},"就":{"docs":{},"包":{"docs":{},"含":{"docs":{},"有":{"docs":{},"两":{"docs":{},"个":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"，":{"docs":{},"完":{"docs":{},"成":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"部":{"docs":{},"署":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"真":{"docs":{},"正":{"docs":{},"调":{"docs":{},"用":{"docs":{},"处":{"docs":{},"理":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"的":{"docs":{},"入":{"docs":{},"口":{"docs":{},"往":{"docs":{},"往":{"docs":{},"是":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"保":{"docs":{},"证":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"普":{"docs":{},"通":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"（":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"=":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"=":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"（":{"docs":{},"j":{"docs":{},"u":{"docs":{},"l":{"docs":{},"）":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{},"具":{"docs":{},"体":{"docs":{},"配":{"docs":{},"置":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{},"/":{"docs":{},"a":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"/":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0021908471275559884},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"）":{"docs":{},"，":{"docs":{},"当":{"docs":{},"消":{"docs":{},"息":{"docs":{},"发":{"docs":{},"送":{"docs":{},"时":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}}}}}}},"d":{"docs":{},"e":{"4":{"docs":{},"j":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.005847953216374269}}}}},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}},"）":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"想":{"docs":{},"切":{"docs":{},"换":{"docs":{},"至":{"docs":{},"其":{"docs":{},"他":{"docs":{},"日":{"docs":{},"志":{"docs":{},"库":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"设":{"docs":{},"置":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":5.08578431372549},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":5.017543859649122},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0030659172202350538},"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.012254901960784314},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.017543859649122806},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.007352941176470588},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}}}}}}},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}},"，":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"同":{"docs":{},"时":{"docs":{},"提":{"docs":{},"供":{"docs":{},"：":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"位":{"docs":{},"置":{"docs":{},"信":{"docs":{},"息":{"docs":{},"、":{"docs":{},"元":{"docs":{},"数":{"docs":{},"据":{"docs":{},"以":{"docs":{},"及":{"docs":{},"服":{"docs":{},"务":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}},"/":{"docs":{},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"/":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"）":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"/":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}},"j":{"docs":{},"w":{"docs":{},"t":{"docs":{"auth/Auth.html":{"ref":"auth/Auth.html","tf":0.041666666666666664}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"3":{"docs":{},".":{"2":{"docs":{},".":{"1":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}},"docs":{}}},"docs":{}}},"docs":{}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"(":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"（":{"docs":{},"该":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"将":{"docs":{},"从":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"、":{"docs":{},"元":{"docs":{},"数":{"docs":{},"据":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"中":{"docs":{},"获":{"docs":{},"取":{"docs":{},"）":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"1":{"docs":{},".":{"8":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"docs":{}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152}},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{},"可":{"docs":{},"用":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"s":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0018578727357176034},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.00746775288526816},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.01511879049676026},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.010054844606946984},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.01094391244870041},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"）":{"docs":{},"还":{"docs":{},"有":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"对":{"docs":{},"象":{"docs":{},"在":{"docs":{},"传":{"docs":{},"递":{"docs":{},"过":{"docs":{},"程":{"docs":{},"中":{"docs":{},"是":{"docs":{},"不":{"docs":{},"可":{"docs":{},"变":{"docs":{},"的":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"9":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"docs":{}}}}}},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}},"j":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}},"o":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}},"h":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"o":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"，":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612},"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.01493550577053632},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.007352941176470588},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.014925373134328358},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.009852216748768473},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.013605442176870748},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.01818181818181818},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.006398537477148081},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.010588235294117647}},"(":{"docs":{},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0027155465037338763},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.005390835579514825},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.021487603305785124},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.010054844606946984},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.007153806847215125},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.004073319755600814}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"docs":{}}}}}},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.014925373134328358}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.005390835579514825}}}}}}}}},"\"":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}},"o":{"docs":{},"m":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0035769034236075624}}}},"h":{"docs":{},"o":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"b":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"$":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0027155465037338763}}}}}}},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.00746775288526816}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036}}}}}}}}}}},"r":{"docs":{},"l":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.002742230347349177}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.002742230347349177}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"）":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"函":{"docs":{},"数":{"docs":{},"对":{"docs":{},"于":{"docs":{},"在":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"中":{"docs":{},"处":{"docs":{},"理":{"docs":{},"数":{"docs":{},"据":{"docs":{},"实":{"docs":{},"体":{"docs":{},"来":{"docs":{},"说":{"docs":{},"都":{"docs":{},"是":{"docs":{},"必":{"docs":{},"要":{"docs":{},"的":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"c":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"并":{"docs":{},"不":{"docs":{},"强":{"docs":{},"制":{"docs":{},"您":{"docs":{},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"并":{"docs":{},"且":{"docs":{},"为":{"docs":{},"了":{"docs":{},"保":{"docs":{},"持":{"docs":{},"稳":{"docs":{},"定":{"docs":{},"性":{"docs":{},"，":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}}}}},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}},"体":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"的":{"docs":{},"编":{"docs":{},"码":{"docs":{},"和":{"docs":{},"解":{"docs":{},"码":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}},"对":{"docs":{},"象":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}},"（":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"格":{"docs":{},"式":{"docs":{},"的":{"docs":{},"文":{"docs":{},"档":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}},"解":{"docs":{},"码":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}},"）":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}},"还":{"docs":{},"能":{"docs":{},"提":{"docs":{},"供":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"可":{"docs":{},"精":{"docs":{},"确":{"docs":{},"的":{"docs":{},"被":{"docs":{},"映":{"docs":{},"射":{"docs":{},"到":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"对":{"docs":{},"象":{"docs":{},"中":{"docs":{},"。":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},".":{"docs":{},"j":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"d":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"负":{"docs":{},"载":{"docs":{},"均":{"docs":{},"衡":{"docs":{},"器":{"docs":{},"可":{"docs":{},"以":{"docs":{},"保":{"docs":{},"证":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}}}}}},"k":{"docs":{},"s":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"m":{"docs":{},"y":{"docs":{},"/":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"i":{"docs":{},"b":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"d":{"docs":{},"a":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},"v":{"docs":{},"m":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152}},"必":{"docs":{},"须":{"docs":{},"将":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"w":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":5.010781671159029}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.005390835579514825}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}},"，":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"/":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"/":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{"auth/Auth.html":{"ref":"auth/Auth.html","tf":0.041666666666666664}}}}}}}}}}}}},":":{"3":{"docs":{},".":{"2":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}},"docs":{}}},"docs":{}}},"docs":{}},"主":{"docs":{},"要":{"docs":{},"的":{"docs":{},"优":{"docs":{},"点":{"docs":{},"有":{"docs":{},"：":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}},"用":{"docs":{},"法":{"docs":{},"的":{"docs":{},"典":{"docs":{},"型":{"docs":{},"流":{"docs":{},"程":{"docs":{},"是":{"docs":{},"，":{"docs":{},"在":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"终":{"docs":{},"点":{"docs":{},"颁":{"docs":{},"发":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"终":{"docs":{},"点":{"docs":{},"应":{"docs":{},"在":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"模":{"docs":{},"式":{"docs":{},"下":{"docs":{},"运":{"docs":{},"行":{"docs":{},"，":{"docs":{},"终":{"docs":{},"点":{"docs":{},"这":{"docs":{},"通":{"docs":{},"过":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"和":{"docs":{},"密":{"docs":{},"码":{"docs":{},"验":{"docs":{},"证":{"docs":{},"完":{"docs":{},"请":{"docs":{},"求":{"docs":{},"用":{"docs":{},"户":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"你":{"docs":{},"将":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"生":{"docs":{},"成":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"：":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{"integration/JCAAdaptor.html":{"ref":"integration/JCAAdaptor.html","tf":5.333333333333333}}},"e":{"docs":{},"k":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.02425876010781671}}}}},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228}}}}}},"g":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"s":{"docs":{},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.022587268993839837},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":10.044334975369457}},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152}}}}}},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.014778325123152709}}}}}},"与":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}},"文":{"docs":{},"档":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}},"docs":{}}},"docs":{}}},"docs":{}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{},"多":{"docs":{},"种":{"docs":{},"传":{"docs":{},"播":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"多":{"docs":{},"播":{"docs":{},"与":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"配":{"docs":{},"置":{"docs":{},"时":{"docs":{},"多":{"docs":{},"播":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"需":{"docs":{},"要":{"docs":{},"确":{"docs":{},"保":{"docs":{},"网":{"docs":{},"络":{"docs":{},"是":{"docs":{},"否":{"docs":{},"启":{"docs":{},"用":{"docs":{},"多":{"docs":{},"播":{"docs":{},"。":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"2":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},".":{"docs":{},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"=":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"f":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}},"b":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"k":{"docs":{},"u":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"=":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}},"_":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"r":{"docs":{},"b":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"）":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"b":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"j":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},".":{"docs":{},"d":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.006611570247933884},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0030659172202350538},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"#":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"，":{"docs":{},"该":{"docs":{},"方":{"docs":{},"法":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"调":{"docs":{},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}},":":{"docs":{},":":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.04801477377654663}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},">":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"#":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"(":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"r":{"docs":{},"x":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"r":{"docs":{},"x":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"j":{"docs":{},"o":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"x":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"j":{"docs":{},"o":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"i":{"docs":{},"d":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"r":{"docs":{},"x":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"docs":{}},"docs":{}},"docs":{}}}}}},"o":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}}},"，":{"docs":{},"即":{"docs":{},"不":{"docs":{},"管":{"docs":{},"是":{"docs":{},"否":{"docs":{},"有":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"都":{"docs":{},"会":{"docs":{},"产":{"docs":{},"生":{"docs":{},"通":{"docs":{},"知":{"docs":{},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0046168051708217915}}}}}}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"：":{"docs":{},"观":{"docs":{},"察":{"docs":{},"者":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.007952286282306162}},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"：":{"docs":{},"读":{"docs":{},"取":{"docs":{},"数":{"docs":{},"据":{"docs":{},"将":{"docs":{},"被":{"docs":{},"放":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"偏":{"docs":{},"移":{"docs":{},"量":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"=":{"docs":{},"\"":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"+":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},"+":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},"+":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"，":{"docs":{},"调":{"docs":{},"用":{"docs":{},"此":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"可":{"docs":{},"以":{"docs":{},"返":{"docs":{},"回":{"docs":{},"大":{"docs":{},"于":{"docs":{},"等":{"docs":{},"于":{"docs":{},"给":{"docs":{},"定":{"docs":{},"时":{"docs":{},"间":{"docs":{},"戳":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"+":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.010242085661080074},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"!":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"e":{"docs":{},"、":{"docs":{},"a":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"。":{"docs":{},"不":{"docs":{},"同":{"docs":{},"语":{"docs":{},"义":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"要":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"不":{"docs":{},"同":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},"e":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"e":{"docs":{},"_":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"_":{"docs":{},"a":{"docs":{},"g":{"docs":{},"o":{"docs":{},"(":{"docs":{},")":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}},"j":{"docs":{},"d":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.003693444136657433}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{},"可":{"docs":{},"用":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"原":{"docs":{},"生":{"docs":{},"的":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{},"支":{"docs":{},"持":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"比":{"docs":{},"j":{"docs":{},"d":{"docs":{},"k":{"docs":{},"引":{"docs":{},"擎":{"docs":{},"更":{"docs":{},"好":{"docs":{},"的":{"docs":{},"性":{"docs":{},"能":{"docs":{},"和":{"docs":{},"c":{"docs":{},"p":{"docs":{},"u":{"docs":{},"使":{"docs":{},"用":{"docs":{},"率":{"docs":{},"、":{"docs":{},"以":{"docs":{},"及":{"docs":{},"j":{"docs":{},"d":{"docs":{},"k":{"docs":{},"版":{"docs":{},"本":{"docs":{},"独":{"docs":{},"立":{"docs":{},"性":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"需":{"docs":{},"要":{"docs":{},"配":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"h":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"3":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}},"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"cloud/OpenShiftCartridge.html":{"ref":"cloud/OpenShiftCartridge.html","tf":5.333333333333333},"cloud/OpenShiftUsingDIYCartridge.html":{"ref":"cloud/OpenShiftUsingDIYCartridge.html","tf":2.7}},"_":{"docs":{},"k":{"docs":{},"u":{"docs":{},"b":{"docs":{},"e":{"docs":{},"_":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"：":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.006316767301439851},"web/Web.html":{"ref":"web/Web.html","tf":0.0019474196689386564},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.002742230347349177},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.002742230347349177},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"*":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"设":{"docs":{},"置":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"受":{"docs":{},"信":{"docs":{},"存":{"docs":{},"储":{"docs":{},"位":{"docs":{},"置":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"在":{"docs":{},"连":{"docs":{},"接":{"docs":{},"期":{"docs":{},"间":{"docs":{},"提":{"docs":{},"供":{"docs":{},"不":{"docs":{},"在":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"受":{"docs":{},"信":{"docs":{},"存":{"docs":{},"储":{"docs":{},"中":{"docs":{},"的":{"docs":{},"证":{"docs":{},"书":{"docs":{},"，":{"docs":{},"则":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"连":{"docs":{},"接":{"docs":{},"将":{"docs":{},"不":{"docs":{},"会":{"docs":{},"成":{"docs":{},"功":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"路":{"docs":{},"径":{"docs":{},"设":{"docs":{},"置":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"密":{"docs":{},"钥":{"docs":{},"库":{"docs":{},"位":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"，":{"docs":{},"作":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"时":{"docs":{},"候":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"成":{"docs":{},"选":{"docs":{},"项":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"来":{"docs":{},"配":{"docs":{},"置":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"（":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"调":{"docs":{},"试":{"docs":{},"器":{"docs":{},"。":{"docs":{},"每":{"docs":{},"次":{"docs":{},"重":{"docs":{},"新":{"docs":{},"部":{"docs":{},"署":{"docs":{},"后":{"docs":{},"，":{"docs":{},"请":{"docs":{},"勿":{"docs":{},"忘":{"docs":{},"记":{"docs":{},"重":{"docs":{},"新":{"docs":{},"插":{"docs":{},"入":{"docs":{},"(":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"虚":{"docs":{},"拟":{"docs":{},"机":{"docs":{},"选":{"docs":{},"项":{"docs":{},"，":{"docs":{},"若":{"docs":{},"未":{"docs":{},"设":{"docs":{},"置":{"docs":{},"，":{"docs":{},"则":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"环":{"docs":{},"境":{"docs":{},"变":{"docs":{},"量":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"g":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.007352941176470588}}}},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}},"u":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.005471956224350205}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"：":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{},"进":{"docs":{},"程":{"docs":{},"输":{"docs":{},"出":{"docs":{},"和":{"docs":{},"错":{"docs":{},"误":{"docs":{},"流":{"docs":{},"到":{"docs":{},"父":{"docs":{},"进":{"docs":{},"程":{"docs":{},"流":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"1":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"2":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"docs":{}}}}}}}}}}}}}}},")":{"docs":{},"）":{"docs":{},"：":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"_":{"docs":{},"o":{"docs":{},"f":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"：":{"docs":{},"服":{"docs":{},"务":{"docs":{},"目":{"docs":{},"前":{"docs":{},"不":{"docs":{},"可":{"docs":{},"用":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"过":{"docs":{},"段":{"docs":{},"时":{"docs":{},"间":{"docs":{},"会":{"docs":{},"继":{"docs":{},"续":{"docs":{},"提":{"docs":{},"供":{"docs":{},"服":{"docs":{},"务":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"：":{"docs":{},"故":{"docs":{},"障":{"docs":{},"转":{"docs":{},"移":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"：":{"docs":{},"重":{"docs":{},"载":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0038948393378773127},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.03305785123966942}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.01652892561983471}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.01652892561983471}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.011570247933884297}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},")":{"docs":{},";":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"/":{"docs":{"auth/Auth.html":{"ref":"auth/Auth.html","tf":0.041666666666666664},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}},":":{"3":{"docs":{},".":{"2":{"docs":{},".":{"1":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":5.001652892561983},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"l":{"docs":{},"d":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0064794816414686825}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}},"c":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}}},"r":{"4":{"docs":{},".":{"2":{"docs":{},"+":{"docs":{},"环":{"docs":{},"境":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"如":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"docs":{}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0017649790989317231},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.014256619144602852},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0064794816414686825},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.016666666666666666},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.02631578947368421},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.014778325123152709},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.02040816326530612},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.008264462809917356},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"q":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{},"/":{"docs":{},"/":{"docs":{},"要":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{},"连":{"docs":{},"接":{"docs":{},"很":{"docs":{},"快":{"docs":{},"会":{"docs":{},"被":{"docs":{},"占":{"docs":{},"满":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}},"“":{"docs":{},"”":{"docs":{},"+":{"docs":{},"i":{"docs":{},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0013005109150023223},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.0037243947858473},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}}}}}}}}},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"8":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"8":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"/":{"docs":{},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"m":{"docs":{},"y":{"docs":{},"b":{"docs":{},"i":{"docs":{},"g":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"4":{"0":{"0":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001207617278216442},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"2":{"docs":{},"\"":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}}},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"3":{"docs":{},"\"":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"方":{"docs":{},"法":{"docs":{},"都":{"docs":{},"不":{"docs":{},"会":{"docs":{},"立":{"docs":{},"即":{"docs":{},"发":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"指":{"docs":{},"定":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"s":{"docs":{},"（":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"请":{"docs":{},"求":{"docs":{},"）":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}},"i":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"s":{"1":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}},"2":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.004073319755600814},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0027155465037338763}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"docs":{}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"$":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"$":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"$":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"$":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}},"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},"e":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}},"l":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001207617278216442},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},"e":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"a":{"docs":{},"a":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"c":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"m":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"p":{"docs":{},"t":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"s":{"docs":{},"r":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"core/Core.html":{"ref":"core/Core.html","tf":0.0059451927542963304},"web/Web.html":{"ref":"web/Web.html","tf":0.0038948393378773127},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.0223463687150838},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.014705882352941176}},"e":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}},"a":{"docs":{},"s":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"4":{"0":{"0":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"r":{"docs":{},"y":{"docs":{},"!":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.002793296089385475}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0015791918253599629},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00931098696461825}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"1":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}},"2":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}},"3":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}},"docs":{}}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"w":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{},"任":{"docs":{},"意":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.014256619144602852},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.016666666666666666}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},")":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0009289363678588017},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.005431093007467753},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.01094391244870041},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.016666666666666666},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.02631578947368421},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.014778325123152709},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.02040816326530612},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677},"core/Core.html":{"ref":"core/Core.html","tf":0.0010218300046446818},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.012311901504787962},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.003693444136657433},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.003693444136657433}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.015047879616963064}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}},"，":{"docs":{},"此":{"docs":{},"时":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"会":{"docs":{},"被":{"docs":{},"转":{"docs":{},"成":{"docs":{},"纯":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}},")":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406}}}}}}}}}}}}}}}}}}},";":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}}}},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"(":{"docs":{},"b":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"(":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}},"m":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"e":{"docs":{},"：":{"docs":{},"恢":{"docs":{},"复":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"若":{"docs":{},"任":{"docs":{},"何":{"docs":{},"项":{"docs":{},"到":{"docs":{},"达":{"docs":{},"则":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"将":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},":":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"c":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},":":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"c":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},":":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"c":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}},"y":{"docs":{},")":{"docs":{},"的":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.01592356687898089}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"y":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}},".":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.006369426751592357}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0033944331296673455}},"e":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}},"即":{"docs":{},"多":{"docs":{},"反":{"docs":{},"应":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"：":{"docs":{},"反":{"docs":{},"应":{"docs":{},"器":{"docs":{},"，":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"i":{"docs":{},"v":{"docs":{"reactive/Reactive.html":{"ref":"reactive/Reactive.html","tf":10.25},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":5.1022727272727275}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.011363636363636364}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.011363636363636364}},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"已":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"校":{"docs":{},"对":{"docs":{},"完":{"docs":{},"成":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.011363636363636364}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001207617278216442},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0046168051708217915},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.011363636363636364}},"（":{"docs":{},"可":{"docs":{},"读":{"docs":{},"流":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"例":{"docs":{},"如":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"）":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"中":{"docs":{},"一":{"docs":{},"样":{"docs":{},"读":{"docs":{},"取":{"docs":{},"数":{"docs":{},"据":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"m":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}},")":{"docs":{},";":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}},"从":{"docs":{},"一":{"docs":{},"个":{"docs":{},"l":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"获":{"docs":{},"取":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}},"对":{"docs":{},"象":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"的":{"docs":{},"。":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}},"里":{"docs":{},"。":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}},"：":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.00823529411764706}},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603}}}}}},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.007153806847215125},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.018281535648994516}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"中":{"docs":{},"增":{"docs":{},"加":{"docs":{},"以":{"docs":{},"下":{"docs":{},"代":{"docs":{},"码":{"docs":{},"片":{"docs":{},"段":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.009554140127388535}},"e":{"docs":{},"d":{"1":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},".":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}},"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},".":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"r":{"docs":{},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"：":{"docs":{},"接":{"docs":{},"收":{"docs":{},"者":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"d":{"1":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}},"2":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001207617278216442},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.021461420541645376}},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.003976143141153081}},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"4":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}}}}}}}}}}}},"s":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"原":{"docs":{},"生":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"。":{"docs":{},"目":{"docs":{},"前":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"只":{"docs":{},"支":{"docs":{},"持":{"docs":{},"将":{"docs":{},"服":{"docs":{},"务":{"docs":{},"从":{"docs":{},"k":{"docs":{},"u":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"中":{"docs":{},"导":{"docs":{},"入":{"docs":{},"到":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"（":{"docs":{},"反":{"docs":{},"过":{"docs":{},"来":{"docs":{},"不":{"docs":{},"行":{"docs":{},"）":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"6":{"4":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}},"docs":{}},"docs":{}}}},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}},"\"":{"docs":{},"选":{"docs":{},"项":{"docs":{},"指":{"docs":{},"定":{"docs":{},"在":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"后":{"docs":{},"和":{"docs":{},"重":{"docs":{},"新":{"docs":{},"启":{"docs":{},"动":{"docs":{},"之":{"docs":{},"前":{"docs":{},"调":{"docs":{},"用":{"docs":{},"的":{"docs":{},"命":{"docs":{},"令":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"更":{"docs":{},"新":{"docs":{},"某":{"docs":{},"些":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"工":{"docs":{},"作":{"docs":{},"，":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"钩":{"docs":{},"住":{"docs":{},"构":{"docs":{},"建":{"docs":{},"工":{"docs":{},"具":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"启":{"docs":{},"动":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},"或":{"docs":{},"g":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"来":{"docs":{},"更":{"docs":{},"新":{"docs":{},"您":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"=":{"docs":{},"\"":{"docs":{},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"y":{"docs":{},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},",":{"docs":{},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"r":{"docs":{},"b":{"docs":{},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"m":{"docs":{},"v":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"'":{"docs":{},".":{"docs":{},"/":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"i":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":5.084233261339093},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.007153806847215125},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.006398537477148081},"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"docs":{}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"1":{"docs":{},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}},"docs":{}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.008639308855291577},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.008639308855291577}}}}}}}}}}}}}}}},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}},"，":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"同":{"docs":{},"时":{"docs":{},"提":{"docs":{},"供":{"docs":{},"：":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"位":{"docs":{},"置":{"docs":{},"信":{"docs":{},"息":{"docs":{},"、":{"docs":{},"元":{"docs":{},"数":{"docs":{},"据":{"docs":{},"以":{"docs":{},"及":{"docs":{},"服":{"docs":{},"务":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},")":{"docs":{},";":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0064794816414686825}}}}}}}}}}}}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"docs":{}}},"docs":{}}},"docs":{}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"(":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"存":{"docs":{},"储":{"docs":{},"后":{"docs":{},"端":{"docs":{},"是":{"docs":{},"基":{"docs":{},"于":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"（":{"docs":{},"该":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"将":{"docs":{},"从":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"、":{"docs":{},"元":{"docs":{},"数":{"docs":{},"据":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"中":{"docs":{},"获":{"docs":{},"取":{"docs":{},"）":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"e":{"docs":{},"r":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.007664793050587634}},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"：":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"o":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"1":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}},"2":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"(":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}},"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"a":{"docs":{},"s":{"docs":{},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.004087889626980072}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}}}}}}}}}}}}},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.005109862033725089}}}}}},"m":{"docs":{},"o":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"（":{"docs":{},"远":{"docs":{},"程":{"docs":{},"）":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"名":{"docs":{},"称":{"docs":{},"（":{"docs":{},"默":{"docs":{},"认":{"docs":{},"读":{"docs":{},"取":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}},"v":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0027155465037338763}}}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"u":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"u":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"o":{"docs":{},"k":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}},"u":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0189873417721519},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.019704433497536946}},"e":{"1":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0019474196689386564}},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"2":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0021908471275559884}},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"3":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243}},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.010954235637779941},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}},".":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"t":{"docs":{},"x":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"j":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"j":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"/":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"5":{"0":{"0":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"t":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"j":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"j":{"docs":{},"w":{"docs":{},"t":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}},"docs":{}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"t":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"r":{"docs":{},"c":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0021908471275559884}}}}}}}}}}}}}}}}}}}}}}}}}}},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},".":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"*":{"docs":{},"/":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"/":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0021908471275559884}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"\\":{"docs":{},"\\":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"f":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"c":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"*":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},".":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},")":{"docs":{},".":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"(":{"docs":{},"\"":{"docs":{},".":{"docs":{},"*":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"/":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"/":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},".":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}},"u":{"docs":{},"t":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"r":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0034079844206426485},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"(":{"docs":{},"\"":{"docs":{},".":{"docs":{},"*":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"t":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"/":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"/":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"c":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"/":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"/":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"c":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"1":{"docs":{},"/":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"2":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"docs":{}}}}}}}}}}}}}},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}},")":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"t":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"(":{"docs":{},"\"":{"docs":{},".":{"docs":{},"*":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"+":{"docs":{},"\\":{"docs":{},"\\":{"docs":{},".":{"docs":{},"h":{"docs":{},"b":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"/":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"t":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"若":{"docs":{},"干":{"docs":{},"级":{"docs":{},"别":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"在":{"docs":{},"这":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"没":{"docs":{},"有":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"条":{"docs":{},"件":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"也":{"docs":{},"有":{"docs":{},"利":{"docs":{},"于":{"docs":{},"您":{"docs":{},"在":{"docs":{},"多":{"docs":{},"个":{"docs":{},"不":{"docs":{},"用":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"中":{"docs":{},"通":{"docs":{},"过":{"docs":{},"设":{"docs":{},"置":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"根":{"docs":{},"路":{"docs":{},"径":{"docs":{},"来":{"docs":{},"复":{"docs":{},"用":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"。":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"例":{"docs":{},"如":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"路":{"docs":{},"由":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"f":{"docs":{},"r":{"docs":{},"c":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0024342745861733205}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"\\":{"docs":{},"\\":{"docs":{},"/":{"docs":{},"(":{"docs":{},"[":{"docs":{},"^":{"docs":{},"\\":{"docs":{},"\\":{"docs":{},"/":{"docs":{},"]":{"docs":{},"+":{"docs":{},")":{"docs":{},"\\":{"docs":{},"\\":{"docs":{},"/":{"docs":{},"(":{"docs":{},"[":{"docs":{},"^":{"docs":{},"\\":{"docs":{},"\\":{"docs":{},"/":{"docs":{},"]":{"docs":{},"+":{"docs":{},")":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"停":{"docs":{},"用":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"正":{"docs":{},"则":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"来":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"但":{"docs":{},"更":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"是":{"docs":{},"在":{"docs":{},"声":{"docs":{},"明":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"流":{"docs":{},"程":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"会":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"参":{"docs":{},"数":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}},"然":{"docs":{},"后":{"docs":{},"将":{"docs":{},"请":{"docs":{},"求":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"：":{"docs":{},"路":{"docs":{},"由":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.002677702044790652}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"(":{"4":{"0":{"3":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"docs":{}},"docs":{}},"docs":{}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0019474196689386564}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"0":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"1":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"docs":{}}}}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603}}}}}}}}},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0029211295034079843}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"5":{"0":{"0":{"0":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"会":{"docs":{},"被":{"docs":{},"传":{"docs":{},"递":{"docs":{},"到":{"docs":{},"所":{"docs":{},"有":{"docs":{},"处":{"docs":{},"理":{"docs":{},"这":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"上":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"：":{"docs":{},"轮":{"docs":{},"询":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},")":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{},"对":{"docs":{},"应":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}},"w":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.005471956224350205}},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"_":{"docs":{},"f":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"_":{"docs":{},"s":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"3":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"docs":{},"\"":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"1":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"2":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"docs":{},"\"":{"docs":{},"f":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},")":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}},":":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}},"e":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},"：":{"docs":{},"角":{"docs":{},"色":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}},"{":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"}":{"docs":{},"=":{"docs":{},"{":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"1":{"docs":{},"}":{"docs":{},",":{"docs":{},"{":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"2":{"docs":{},"}":{"docs":{},",":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},",":{"docs":{},"{":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"}":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.003994426381792847},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}},"命":{"docs":{},"令":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"几":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"是":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}}}},"b":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"]":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"f":{"docs":{},"c":{"6":{"7":{"5":{"0":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"建":{"docs":{},"议":{"docs":{},"推":{"docs":{},"荐":{"docs":{},"值":{"docs":{},"为":{"1":{"0":{"0":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"r":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"s":{"2":{"5":{"6":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}},"docs":{}},"docs":{}},"3":{"8":{"4":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}},"docs":{}},"docs":{}},"5":{"1":{"2":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}},"docs":{}},"docs":{}},"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.008086253369272238}},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.008086253369272238}}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}},"w":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},".":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"n":{"docs":{},"j":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"á":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}},"t":{"docs":{},"o":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":5.001846722068329}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.01662049861495845}},"的":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"f":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"f":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"f":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}}}}}}},"*":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}},".":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"（":{"docs":{},"r":{"docs":{},"x":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}},".":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},",":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"(":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"l":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}}}}}}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},"e":{"docs":{},"d":{"docs":{},"：":{"docs":{},"r":{"docs":{},"x":{"docs":{},"化":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}},"化":{"docs":{},"的":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.00554016620498615}},"辅":{"docs":{},"助":{"docs":{},"类":{"docs":{},"也":{"docs":{},"能":{"docs":{},"做":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"事":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}},".":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.009504412763068567}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}},"s":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"i":{"docs":{},"t":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}},"：":{"docs":{},"待":{"docs":{},"认":{"docs":{},"领":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}},"计":{"docs":{},"划":{"docs":{},"中":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"：":{"docs":{},"撤":{"docs":{},"销":{"docs":{},"（":{"docs":{},"反":{"docs":{},"部":{"docs":{},"署":{"docs":{},"，":{"docs":{},"对":{"docs":{},"应":{"docs":{},"部":{"docs":{},"署":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"w":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"：":{"docs":{},"注":{"docs":{},"销":{"docs":{},"（":{"docs":{},"反":{"docs":{},"注":{"docs":{},"册":{"docs":{},"，":{"docs":{},"对":{"docs":{},"应":{"docs":{},"注":{"docs":{},"册":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"：":{"docs":{},"重":{"docs":{},"组":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.02425876010781671},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"devops/MetricsUsingDropwizard.html":{"ref":"devops/MetricsUsingDropwizard.html","tf":3.583333333333333},"devops/MetricsUsingHawkular.html":{"ref":"devops/MetricsUsingHawkular.html","tf":3.583333333333333},"cloud/OpenShiftUsingDIYCartridge.html":{"ref":"cloud/OpenShiftUsingDIYCartridge.html","tf":2.7}},"e":{"docs":{},"r":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.016666666666666666},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.017543859649122806},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.014778325123152709},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.013605442176870748},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"1":{"2":{"3":{"4":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},":":{"1":{"3":{"docs":{},"\"":{"docs":{},",":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}},"j":{"docs":{},"o":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}},"{":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"}":{"docs":{},"=":{"docs":{},"{":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"}":{"docs":{},",":{"docs":{},"{":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"1":{"docs":{},"}":{"docs":{},",":{"docs":{},"{":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"2":{"docs":{},"}":{"docs":{},",":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},",":{"docs":{},"{":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"}":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},"e":{"docs":{},"：":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"o":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}},":":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}},"：":{"docs":{},"用":{"docs":{},"户":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"。":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"想":{"docs":{},"要":{"docs":{},"改":{"docs":{},"变":{"docs":{},"这":{"docs":{},"个":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"配":{"docs":{},"置":{"docs":{},"元":{"docs":{},"素":{"docs":{},"来":{"docs":{},"定":{"docs":{},"义":{"docs":{},"属":{"docs":{},"性":{"docs":{},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{},"路":{"docs":{},"径":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"值":{"docs":{},"是":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"a":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}},"e":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"p":{"docs":{},"是":{"docs":{},"无":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"传":{"docs":{},"输":{"docs":{},"，":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"您":{"docs":{},"与":{"docs":{},"远":{"docs":{},"程":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"没":{"docs":{},"有":{"docs":{},"建":{"docs":{},"立":{"docs":{},"持":{"docs":{},"续":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.006788866259334691},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}},"e":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}},".":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}},"d":{"docs":{},":":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.005471956224350205}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{},"此":{"docs":{},"方":{"docs":{},"法":{"docs":{},"接":{"docs":{},"受":{"docs":{},"含":{"docs":{},"参":{"docs":{},"数":{"docs":{},"占":{"docs":{},"位":{"docs":{},"符":{"docs":{},"的":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"更":{"docs":{},"新":{"docs":{},"语":{"docs":{},"句":{"docs":{},"以":{"docs":{},"及":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"/":{"docs":{},"\"":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"s":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"e":{"docs":{},"d":{"docs":{},"。":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"（":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}},"：":{"docs":{},"服":{"docs":{},"务":{"docs":{},"已":{"docs":{},"经":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}},"\"":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.021415270018621976}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.004655493482309125}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0018578727357176034}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"它":{"docs":{},"只":{"docs":{},"会":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"路":{"docs":{},"径":{"docs":{},"和":{"docs":{},"该":{"docs":{},"路":{"docs":{},"径":{"docs":{},"一":{"docs":{},"致":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"由":{"docs":{},"于":{"docs":{},"我":{"docs":{},"们":{"docs":{},"创":{"docs":{},"建":{"docs":{},"的":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"是":{"docs":{},"以":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"，":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"，":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"?":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"1":{"docs":{},"=":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"1":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"&":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"2":{"docs":{},"=":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"2":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}}}}}}}}}},"docs":{}}}}}}}},"docs":{}}}}}}}}}}}}}},"docs":{}}}}}}}},"docs":{}}}}}}}},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"d":{"docs":{},"，":{"docs":{},"您":{"docs":{},"亦":{"docs":{},"可":{"docs":{},"将":{"docs":{},"其":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}},"。":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"用":{"docs":{},"法":{"docs":{},"很":{"docs":{},"简":{"docs":{},"单":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"为":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"路":{"docs":{},"由":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},")":{"docs":{},"，":{"docs":{},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"都":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"完":{"docs":{},"成":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"典":{"docs":{},"型":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"是":{"docs":{},"您":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"要":{"docs":{},"求":{"docs":{},"代":{"docs":{},"理":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"连":{"docs":{},"接":{"docs":{},"到":{"docs":{},"代":{"docs":{},"理":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"提":{"docs":{},"供":{"docs":{},"完":{"docs":{},"整":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"（":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"则":{"docs":{},"您":{"docs":{},"的":{"docs":{},"输":{"docs":{},"入":{"docs":{},"类":{"docs":{},"似":{"docs":{},"于":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"、":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"、":{"docs":{},"密":{"docs":{},"码":{"docs":{},"等":{"docs":{},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"属":{"docs":{},"性":{"docs":{},"既":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"于":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"也":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"于":{"docs":{},"所":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"，":{"docs":{},"如":{"docs":{},"：":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},":":{"8":{"0":{"8":{"0":{"docs":{},"/":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},"。":{"docs":{},"仪":{"docs":{},"表":{"docs":{},"板":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"的":{"docs":{},"指":{"docs":{},"标":{"docs":{},"。":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}},"（":{"docs":{},"地":{"docs":{},"址":{"docs":{},"）":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}},"必":{"docs":{},"填":{"docs":{},"）":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"t":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.007352941176470588}},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"它":{"docs":{},"是":{"docs":{},"无":{"docs":{},"法":{"docs":{},"推":{"docs":{},"测":{"docs":{},"的":{"docs":{},"(":{"6":{"docs":{},")":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"docs":{}}}}}}}}}}},"可":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"所":{"docs":{},"有":{"docs":{},"都":{"docs":{},"支":{"docs":{},"持":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"说":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"!":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}},"。":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}},"啦":{"docs":{},"。":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"但":{"docs":{},"在":{"docs":{},"此":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"需":{"docs":{},"要":{"docs":{},"您":{"docs":{},"具":{"docs":{},"备":{"docs":{},"有":{"docs":{},"以":{"docs":{},"下":{"docs":{},"基":{"docs":{},"础":{"docs":{},"知":{"docs":{},"识":{"docs":{},"：":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"。":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}},"与":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"部":{"docs":{},"分":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"是":{"docs":{},"：":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}},"开":{"docs":{},"始":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"我":{"docs":{},"们":{"docs":{},"将":{"docs":{},"引":{"docs":{},"导":{"docs":{},"您":{"docs":{},"制":{"docs":{},"作":{"docs":{},"一":{"docs":{},"个":{"docs":{},"最":{"docs":{},"基":{"docs":{},"本":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"”":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},"e":{"docs":{},"r":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677},"core/Core.html":{"ref":"core/Core.html","tf":0.003994426381792847},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}},"：":{"docs":{},"此":{"docs":{},"选":{"docs":{},"项":{"docs":{},"可":{"docs":{},"确":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"是":{"docs":{},"否":{"docs":{},"为":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}},"e":{"docs":{},"b":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":10.015092502434275},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":5.011173184357542},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.005390835579514825},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0063025210084033615},"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00558659217877095},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}},",":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.002793296089385475}}}}}}}}}}}}}}}},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.002793296089385475}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"5":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"如":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"一":{"docs":{},"个":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"如":{"docs":{},"何":{"docs":{},"将":{"docs":{},"根":{"docs":{},"路":{"docs":{},"径":{"docs":{},"对":{"docs":{},"应":{"docs":{},"到":{"docs":{},"某":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"文":{"docs":{},"件":{"docs":{},"？":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.002693915466790525},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},".":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"o":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"1":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"2":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"3":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"e":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}}},"、":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"2":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"实":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"等":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"，":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"、":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"、":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"、":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"p":{"docs":{},"、":{"docs":{},"x":{"docs":{},"h":{"docs":{},"r":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}},"对":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"的":{"docs":{},"路":{"docs":{},"径":{"docs":{},"进":{"docs":{},"行":{"docs":{},"了":{"docs":{},"规":{"docs":{},"范":{"docs":{},"，":{"docs":{},"以":{"docs":{},"防":{"docs":{},"止":{"docs":{},"恶":{"docs":{},"意":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"通":{"docs":{},"过":{"docs":{},"伪":{"docs":{},"造":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"来":{"docs":{},"访":{"docs":{},"问":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"根":{"docs":{},"目":{"docs":{},"录":{"docs":{},"以":{"docs":{},"外":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"场":{"docs":{},"中":{"docs":{},"的":{"docs":{},"会":{"docs":{},"话":{"docs":{},"状":{"docs":{},"态":{"docs":{},"存":{"docs":{},"储":{"docs":{},"非":{"docs":{},"常":{"docs":{},"有":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"上":{"docs":{},"传":{"docs":{},"到":{"docs":{},"磁":{"docs":{},"盘":{"docs":{},"上":{"docs":{},"已":{"docs":{},"知":{"docs":{},"位":{"docs":{},"置":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"且":{"docs":{},"不":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"名":{"docs":{},"，":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"名":{"docs":{},"可":{"docs":{},"被":{"docs":{},"恶":{"docs":{},"意":{"docs":{},"伪":{"docs":{},"装":{"docs":{},"成":{"docs":{},"上":{"docs":{},"传":{"docs":{},"到":{"docs":{},"硬":{"docs":{},"盘":{"docs":{},"上":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"位":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"替":{"docs":{},"代":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"而":{"docs":{},"非":{"docs":{},"直":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},":":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"/":{"docs":{},"c":{"docs":{},"s":{"docs":{},"s":{"docs":{},"/":{"docs":{},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"s":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"静":{"docs":{},"态":{"docs":{},"资":{"docs":{},"源":{"docs":{},"打":{"docs":{},"包":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"已":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"校":{"docs":{},"对":{"docs":{},"完":{"docs":{},"成":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}},"项":{"docs":{},"目":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"若":{"docs":{},"要":{"docs":{},"在":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"项":{"docs":{},"目":{"docs":{},"中":{"docs":{},"运":{"docs":{},"用":{"docs":{},"它":{"docs":{},"，":{"docs":{},"则":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"构":{"docs":{},"建":{"docs":{},"描":{"docs":{},"述":{"docs":{},"信":{"docs":{},"息":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"节":{"docs":{},"点":{"docs":{},"中":{"docs":{},"添":{"docs":{},"加":{"docs":{},"如":{"docs":{},"下":{"docs":{},"信":{"docs":{},"息":{"docs":{},"：":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.012104283054003724}}}},"’":{"docs":{},"l":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"i":{"docs":{},"y":{"docs":{},"i":{"docs":{},"y":{"docs":{},"s":{"docs":{},"w":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"i":{"docs":{},"t":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"m":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}},"i":{"docs":{},"b":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}},"d":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"r":{"docs":{},"e":{"docs":{},"：":{"docs":{},"报":{"docs":{},"文":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0013934045517882026},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.011363636363636364}},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"：":{"docs":{},"若":{"docs":{},"写":{"docs":{},"队":{"docs":{},"列":{"docs":{},"被":{"docs":{},"认":{"docs":{},"为":{"docs":{},"已":{"docs":{},"满":{"docs":{},"，":{"docs":{},"则":{"docs":{},"返":{"docs":{},"回":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0014862981885740826},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"（":{"docs":{},"可":{"docs":{},"写":{"docs":{},"流":{"docs":{},"）":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"类":{"docs":{},"包":{"docs":{},"括":{"docs":{},"：":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"启":{"docs":{},"动":{"docs":{},"它":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"该":{"docs":{},"方":{"docs":{},"法":{"docs":{},"将":{"docs":{},"永":{"docs":{},"远":{"docs":{},"不":{"docs":{},"会":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"，":{"docs":{},"内":{"docs":{},"部":{"docs":{},"是":{"docs":{},"排":{"docs":{},"队":{"docs":{},"写":{"docs":{},"入":{"docs":{},"并":{"docs":{},"且":{"docs":{},"底":{"docs":{},"层":{"docs":{},"资":{"docs":{},"源":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"写":{"docs":{},"入":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"往":{"docs":{},"其":{"docs":{},"中":{"docs":{},"写":{"docs":{},"入":{"docs":{},"数":{"docs":{},"据":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"。":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"：":{"docs":{},"写":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"g":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"：":{"docs":{},"编":{"docs":{},"写":{"docs":{},"（":{"docs":{},"有":{"docs":{},"些":{"docs":{},"地":{"docs":{},"方":{"docs":{},"译":{"docs":{},"为":{"docs":{},"开":{"docs":{},"发":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.012104283054003724}},"!":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}}}}}}},"w":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"s":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"{":{"1":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.03508771929824561},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.06569343065693431},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.023554603854389723},"core/Core.html":{"ref":"core/Core.html","tf":0.03204830469112866},"web/Web.html":{"ref":"web/Web.html","tf":0.025803310613437196},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.0595903165735568},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.05974202308214528},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.014705882352941176},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.06566347469220246},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.028077753779697623},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.009950248756218905},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.04440026507620941},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.075},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.07894736842105263},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.04433497536945813},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.07482993197278912},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.03140495867768595},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.040627885503231764},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.040878896269800714},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.06512605042016807},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.010054844606946984},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.019193857965451054},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.018480492813141684},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.022058823529411766},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.01749271137026239},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.014778325123152709},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.056074766355140186},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.05529411764705883}},"\"":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},"_":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"\"":{"docs":{},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}},"}":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},")":{"docs":{},";":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.00186219739292365}}}},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{},"}":{"docs":{},",":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789}}}}}}},"a":{"docs":{},":":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"2":{"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"docs":{},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}},"}":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.06569343065693431},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.021413276231263382},"core/Core.html":{"ref":"core/Core.html","tf":0.01616349280074315},"web/Web.html":{"ref":"web/Web.html","tf":0.005355404089581304},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.03165735567970205},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.03937542430414121},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.00980392156862745},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.04103967168262654},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.017278617710583154},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.007462686567164179},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.024519549370444003},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.058333333333333334},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.05263157894736842},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.029556650246305417},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.047619047619047616},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.01818181818181818},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.019390581717451522},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.021972406745017884},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.018907563025210083},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.003656307129798903},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.015355086372360844},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.012320328542094456},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.014705882352941176},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.011661807580174927},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.009852216748768473},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.04672897196261682},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.05176470588235294}},")":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"8":{"0":{"8":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677},"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}}}}},"1":{"docs":{},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"v":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"t":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.005847953216374269},"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.017130620985010708},"core/Core.html":{"ref":"core/Core.html","tf":0.014212726428239666},"web/Web.html":{"ref":"web/Web.html","tf":0.0189873417721519},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.024208566108007448},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.019008825526137134},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.02188782489740082},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.008639308855291577},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.02253147779986746},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.016666666666666666},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.02631578947368421},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.014778325123152709},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.02040816326530612},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.013223140495867768},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.014773776546629732},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.01788451711803781},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.03571428571428571},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.004570383912248629},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}}},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"8":{"0":{"8":{"0":{"docs":{},",":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},"e":{"docs":{},"{":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.002793296089385475},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.00554016620498615},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}},"\"":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.004103967168262654}}}},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"选":{"docs":{},"择":{"docs":{},"使":{"docs":{},"用":{"docs":{},"占":{"docs":{},"位":{"docs":{},"符":{"docs":{},"传":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{},"{":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}},"│":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.02046783625730994},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.025547445255474453}}},"└":{"docs":{},"─":{"docs":{},"─":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.008771929824561403},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.010948905109489052}}}}},"├":{"docs":{},"─":{"docs":{},"─":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.011695906432748537},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.01824817518248175}}}}},"下":{"docs":{},"面":{"docs":{},"我":{"docs":{},"们":{"docs":{},"将":{"docs":{},"会":{"docs":{},"介":{"docs":{},"绍":{"docs":{},"测":{"docs":{},"试":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"首":{"docs":{},"先":{"docs":{},"引":{"docs":{},"入":{"docs":{},"两":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"测":{"docs":{},"试":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"，":{"docs":{},"修":{"docs":{},"改":{"docs":{},"后":{"docs":{},"的":{"docs":{},"p":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"来":{"docs":{},"看":{"docs":{},"一":{"docs":{},"下":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"有":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"的":{"docs":{},"失":{"docs":{},"败":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"只":{"docs":{},"会":{"docs":{},"在":{"docs":{},"路":{"docs":{},"由":{"docs":{},"路":{"docs":{},"径":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"如":{"docs":{},"何":{"docs":{},"允":{"docs":{},"许":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"向":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"发":{"docs":{},"送":{"docs":{},"消":{"docs":{},"息":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"些":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"将":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"作":{"docs":{},"为":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"展":{"docs":{},"示":{"docs":{},"了":{"docs":{},"如":{"docs":{},"何":{"docs":{},"配":{"docs":{},"置":{"docs":{},"并":{"docs":{},"处":{"docs":{},"理":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"过":{"docs":{},"程":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"超":{"docs":{},"时":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"所":{"docs":{},"有":{"docs":{},"以":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"，":{"docs":{},"文":{"docs":{},"档":{"docs":{},"已":{"docs":{},"有":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"代":{"docs":{},"码":{"docs":{},"也":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"的":{"docs":{},"（":{"docs":{},"直":{"docs":{},"接":{"docs":{},"基":{"docs":{},"于":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}},"片":{"docs":{},"段":{"docs":{},"，":{"docs":{},"展":{"docs":{},"示":{"docs":{},"了":{"docs":{},"如":{"docs":{},"何":{"docs":{},"通":{"docs":{},"过":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}},"这":{"docs":{},"些":{"docs":{},"配":{"docs":{},"置":{"docs":{},"参":{"docs":{},"数":{"docs":{},"同":{"docs":{},"样":{"docs":{},"有":{"docs":{},"效":{"docs":{},"：":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}},"边":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"值":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"是":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"基":{"docs":{},"于":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"添":{"docs":{},"加":{"docs":{},"文":{"docs":{},"件":{"docs":{},"c":{"3":{"docs":{},"p":{"0":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}},"共":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"互":{"docs":{},"联":{"docs":{},"网":{"docs":{},"的":{"docs":{},"基":{"docs":{},"础":{"docs":{},"知":{"docs":{},"识":{"docs":{},"，":{"docs":{},"知":{"docs":{},"道":{"docs":{},"什":{"docs":{},"么":{"docs":{},"是":{"docs":{},"网":{"docs":{},"络":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"尤":{"docs":{},"其":{"docs":{},"是":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{},"，":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"协":{"docs":{},"议":{"docs":{},"。":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"便":{"docs":{},"可":{"docs":{},"看":{"docs":{},"到":{"docs":{},"熟":{"docs":{},"悉":{"docs":{},"的":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"启":{"docs":{},"动":{"docs":{},"器":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502},"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"和":{"docs":{},"退":{"docs":{},"出":{"docs":{},"代":{"docs":{},"码":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"子":{"docs":{},"类":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"会":{"docs":{},"耗":{"docs":{},"费":{"docs":{},"一":{"docs":{},"些":{"docs":{},"时":{"docs":{},"间":{"docs":{},"，":{"docs":{},"您":{"docs":{},"想":{"docs":{},"要":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"过":{"docs":{},"程":{"docs":{},"做":{"docs":{},"一":{"docs":{},"些":{"docs":{},"事":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"您":{"docs":{},"做":{"docs":{},"的":{"docs":{},"这":{"docs":{},"些":{"docs":{},"事":{"docs":{},"并":{"docs":{},"不":{"docs":{},"想":{"docs":{},"等":{"docs":{},"到":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"部":{"docs":{},"署":{"docs":{},"完":{"docs":{},"成":{"docs":{},"过":{"docs":{},"后":{"docs":{},"再":{"docs":{},"发":{"docs":{},"生":{"docs":{},"。":{"docs":{},"如":{"docs":{},"：":{"docs":{},"您":{"docs":{},"想":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"此":{"docs":{},"设":{"docs":{},"置":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"注":{"docs":{},"册":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"监":{"docs":{},"听":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"和":{"docs":{},"停":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"开":{"docs":{},"始":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"使":{"docs":{},"用":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":10}}}},"的":{"docs":{},"h":{"2":{"docs":{},"c":{"docs":{},"直":{"docs":{},"接":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"docs":{}}},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}},"发":{"docs":{},"人":{"docs":{},"员":{"docs":{},"遵":{"docs":{},"循":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"者":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}},"启":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"监":{"docs":{},"听":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"日":{"docs":{},"志":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}},"头":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"）":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"消":{"docs":{},"息":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"会":{"docs":{},"被":{"docs":{},"保":{"docs":{},"护":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}},"路":{"docs":{},"由":{"docs":{},"到":{"docs":{},"模":{"docs":{},"板":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"上":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"过":{"docs":{},"程":{"docs":{},"中":{"docs":{},"发":{"docs":{},"生":{"docs":{},"错":{"docs":{},"误":{"docs":{},"，":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"都":{"docs":{},"会":{"docs":{},"对":{"docs":{},"应":{"docs":{},"到":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"调":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"处":{"docs":{},"理":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"，":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"会":{"docs":{},"被":{"docs":{},"依":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"，":{"docs":{},"`":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"该":{"docs":{},"测":{"docs":{},"试":{"docs":{},"案":{"docs":{},"例":{"docs":{},"便":{"docs":{},"可":{"docs":{},"得":{"docs":{},"到":{"docs":{},"期":{"docs":{},"望":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"，":{"docs":{},"理":{"docs":{},"解":{"docs":{},"测":{"docs":{},"试":{"docs":{},"代":{"docs":{},"码":{"docs":{},"并":{"docs":{},"不":{"docs":{},"难":{"docs":{},"，":{"docs":{},"留":{"docs":{},"给":{"docs":{},"读":{"docs":{},"者":{"docs":{},"作":{"docs":{},"为":{"docs":{},"练":{"docs":{},"习":{"docs":{},"。":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"计":{"docs":{},"算":{"docs":{},"，":{"docs":{},"占":{"docs":{},"用":{"docs":{},"了":{"docs":{},"可":{"docs":{},"感":{"docs":{},"知":{"docs":{},"的":{"docs":{},"时":{"docs":{},"长":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"长":{"docs":{},"时":{"docs":{},"间":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"操":{"docs":{},"作":{"docs":{},"并":{"docs":{},"等":{"docs":{},"待":{"docs":{},"其":{"docs":{},"结":{"docs":{},"果":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"其":{"docs":{},"他":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"任":{"docs":{},"务":{"docs":{},"。":{"docs":{},"那":{"docs":{},"您":{"docs":{},"该":{"docs":{},"怎":{"docs":{},"么":{"docs":{},"做":{"docs":{},"？":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"操":{"docs":{},"作":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}},"周":{"docs":{},"期":{"docs":{},"性":{"docs":{},"/":{"docs":{},"延":{"docs":{},"迟":{"docs":{},"性":{"docs":{},"操":{"docs":{},"作":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"失":{"docs":{},"败":{"docs":{},"时":{"docs":{},"，":{"docs":{},"得":{"docs":{},"到":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"，":{"docs":{},"则":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"打":{"docs":{},"包":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"这":{"docs":{},"种":{"docs":{},"请":{"docs":{},"求":{"docs":{},"最":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"加":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"上":{"docs":{},"传":{"docs":{},"处":{"docs":{},"理":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"面":{"docs":{},"的":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"，":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}},"某":{"docs":{},"些":{"docs":{},"同":{"docs":{},"步":{"docs":{},"的":{"docs":{},"耗":{"docs":{},"时":{"docs":{},"操":{"docs":{},"作":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"处":{"docs":{},"理":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"操":{"docs":{},"作":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}},".":{"docs":{},".":{"docs":{},".":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"阻":{"docs":{},"塞":{"docs":{},"操":{"docs":{},"作":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"查":{"docs":{},"询":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"命":{"docs":{},"令":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}},"请":{"docs":{},"求":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"块":{"docs":{},"中":{"docs":{},"接":{"docs":{},"收":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}},"模":{"docs":{},"型":{"docs":{},"。":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"欢":{"docs":{},"迎":{"docs":{},"来":{"docs":{},"到":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"世":{"docs":{},"界":{"docs":{},"，":{"docs":{},"相":{"docs":{},"信":{"docs":{},"您":{"docs":{},"在":{"docs":{},"接":{"docs":{},"触":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"同":{"docs":{},"时":{"docs":{},"，":{"docs":{},"迫":{"docs":{},"不":{"docs":{},"及":{"docs":{},"待":{"docs":{},"想":{"docs":{},"动":{"docs":{},"手":{"docs":{},"试":{"docs":{},"一":{"docs":{},"试":{"docs":{},"，":{"docs":{},"如":{"docs":{},"您":{"docs":{},"在":{"docs":{},"学":{"docs":{},"习":{"docs":{},"计":{"docs":{},"算":{"docs":{},"机":{"docs":{},"其":{"docs":{},"它":{"docs":{},"知":{"docs":{},"识":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"总":{"docs":{},"是":{"docs":{},"从":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"页":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}},"测":{"docs":{},"试":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}},"然":{"docs":{},"后":{"docs":{},"在":{"docs":{},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"/":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"/":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"目":{"docs":{},"录":{"docs":{},"下":{"docs":{},"新":{"docs":{},"增":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"代":{"docs":{},"码":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"在":{"docs":{},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"/":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"/":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"目":{"docs":{},"录":{"docs":{},"下":{"docs":{},"新":{"docs":{},"建":{"docs":{},"两":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"分":{"docs":{},"别":{"docs":{},"是":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"和":{"docs":{},"m":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"，":{"docs":{},"代":{"docs":{},"码":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"是":{"docs":{},"的":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"新":{"docs":{},"建":{"docs":{},"i":{"docs":{},"o":{"docs":{},"和":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"两":{"docs":{},"级":{"docs":{},"文":{"docs":{},"件":{"docs":{},"夹":{"docs":{},"）":{"docs":{},"下":{"docs":{},"新":{"docs":{},"建":{"docs":{},"两":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"分":{"docs":{},"别":{"docs":{},"是":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"和":{"docs":{},"m":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"，":{"docs":{},"代":{"docs":{},"码":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"的":{"docs":{},"m":{"docs":{},"v":{"docs":{},"n":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}},"重":{"docs":{},"新":{"docs":{},"打":{"docs":{},"包":{"docs":{},"后":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"便":{"docs":{},"可":{"docs":{},"再":{"docs":{},"次":{"docs":{},"看":{"docs":{},"到":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}},"启":{"docs":{},"动":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"j":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"，":{"docs":{},"将":{"docs":{},"包":{"docs":{},"含":{"docs":{},"该":{"docs":{},"命":{"docs":{},"令":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"放":{"docs":{},"入":{"docs":{},"f":{"docs":{},"a":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"按":{"docs":{},"下":{"docs":{},"边":{"docs":{},"方":{"docs":{},"式":{"docs":{},"获":{"docs":{},"取":{"docs":{},"转":{"docs":{},"换":{"docs":{},"的":{"docs":{},"值":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"样":{"docs":{},"注":{"docs":{},"册":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"设":{"docs":{},"置":{"docs":{},"系":{"docs":{},"统":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"确":{"docs":{},"保":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}},"结":{"docs":{},"束":{"docs":{},"了":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"您":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"执":{"docs":{},"行":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"事":{"docs":{},"务":{"docs":{},"中":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"在":{"docs":{},"需":{"docs":{},"要":{"docs":{},"提":{"docs":{},"交":{"docs":{},"事":{"docs":{},"务":{"docs":{},"时":{"docs":{},"，":{"docs":{},"调":{"docs":{},"用":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"覆":{"docs":{},"盖":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}},"至":{"docs":{},"此":{"docs":{},"，":{"docs":{},"大":{"docs":{},"功":{"docs":{},"告":{"docs":{},"成":{"docs":{},"，":{"docs":{},"欢":{"docs":{},"迎":{"docs":{},"来":{"docs":{},"到":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"世":{"docs":{},"界":{"docs":{},"。":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343},"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}},"少":{"docs":{},"一":{"docs":{},"个":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}},"失":{"docs":{},"败":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"成":{"docs":{},"功":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"重":{"docs":{},"新":{"docs":{},"打":{"docs":{},"包":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"能":{"docs":{},"需":{"docs":{},"要":{"docs":{},"清":{"docs":{},"除":{"docs":{},"之":{"docs":{},"前":{"docs":{},"编":{"docs":{},"译":{"docs":{},"后":{"docs":{},"留":{"docs":{},"下":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"用":{"docs":{},"m":{"docs":{},"v":{"docs":{},"n":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"中":{"docs":{},"绝":{"docs":{},"大":{"docs":{},"多":{"docs":{},"数":{"docs":{},"涉":{"docs":{},"及":{"docs":{},"i":{"docs":{},"o":{"docs":{},"操":{"docs":{},"作":{"docs":{},"除":{"docs":{},"非":{"docs":{},"有":{"docs":{},"明":{"docs":{},"确":{"docs":{},"说":{"docs":{},"明":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"以":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"后":{"docs":{},"缀":{"docs":{},"命":{"docs":{},"名":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{},"均":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"另":{"docs":{},"外":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"，":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},"的":{"docs":{},"相":{"docs":{},"关":{"docs":{},"操":{"docs":{},"作":{"docs":{},"也":{"docs":{},"被":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"涉":{"docs":{},"及":{"docs":{},"i":{"docs":{},"o":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"般":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"用":{"docs":{},"了":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"原":{"docs":{},"则":{"docs":{},"上":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"，":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"，":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"d":{"docs":{},"k":{"docs":{},"需":{"docs":{},"要":{"docs":{},"支":{"docs":{},"持":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"快":{"docs":{},"速":{"docs":{},"编":{"docs":{},"译":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"编":{"docs":{},"译":{"docs":{},"（":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"即":{"docs":{},"使":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"只":{"docs":{},"有":{"docs":{},"当":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"大":{"docs":{},"部":{"docs":{},"分":{"docs":{},"应":{"docs":{},"用":{"docs":{},"将":{"docs":{},"只":{"docs":{},"会":{"docs":{},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"但":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"有":{"docs":{},"需":{"docs":{},"要":{"docs":{},"也":{"docs":{},"可":{"docs":{},"创":{"docs":{},"建":{"docs":{},"多":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"如":{"docs":{},"：":{"docs":{},"隔":{"docs":{},"离":{"docs":{},"的":{"docs":{},"事":{"docs":{},"件":{"docs":{},"总":{"docs":{},"线":{"docs":{},"或":{"docs":{},"不":{"docs":{},"同":{"docs":{},"组":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"当":{"docs":{},"加":{"docs":{},"载":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"时":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{},"将":{"docs":{},"被":{"docs":{},"评":{"docs":{},"估":{"docs":{},"一":{"docs":{},"次":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"在":{"docs":{},"加":{"docs":{},"载":{"docs":{},"此":{"docs":{},"类":{"docs":{},"之":{"docs":{},"前":{"docs":{},"应":{"docs":{},"该":{"docs":{},"设":{"docs":{},"置":{"docs":{},"这":{"docs":{},"些":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"在":{"docs":{},"启":{"docs":{},"动":{"docs":{},"它":{"docs":{},"时":{"docs":{},"作":{"docs":{},"为":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{},"来":{"docs":{},"设":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"前":{"docs":{},"版":{"docs":{},"本":{"docs":{},"并":{"docs":{},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{},"分":{"docs":{},"块":{"docs":{},"文":{"docs":{},"件":{"docs":{},"编":{"docs":{},"码":{"docs":{},"（":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"有":{"docs":{},"时":{"docs":{},"可":{"docs":{},"能":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"内":{"docs":{},"置":{"docs":{},"解":{"docs":{},"析":{"docs":{},"器":{"docs":{},"。":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"启":{"docs":{},"动":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"加":{"docs":{},"上":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"本":{"docs":{},"文":{"docs":{},"大":{"docs":{},"部":{"docs":{},"分":{"docs":{},"内":{"docs":{},"容":{"docs":{},"专":{"docs":{},"用":{"docs":{},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"此":{"docs":{},"功":{"docs":{},"能":{"docs":{},"仅":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"/":{"2":{"docs":{},"协":{"docs":{},"议":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"docs":{}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"配":{"docs":{},"置":{"docs":{},"信":{"docs":{},"息":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"上":{"docs":{},"面":{"docs":{},"提":{"docs":{},"到":{"docs":{},"的":{"docs":{},"各":{"docs":{},"类":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"，":{"docs":{},"都":{"docs":{},"是":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}},"删":{"docs":{},"除":{"docs":{},"一":{"docs":{},"个":{"docs":{},"集":{"docs":{},"合":{"docs":{},"将":{"docs":{},"会":{"docs":{},"删":{"docs":{},"除":{"docs":{},"集":{"docs":{},"合":{"docs":{},"中":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"文":{"docs":{},"档":{"docs":{},"！":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"果":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"此":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"将":{"docs":{},"会":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"所":{"docs":{},"有":{"docs":{},"配":{"docs":{},"置":{"docs":{},"选":{"docs":{},"项":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"输":{"docs":{},"入":{"docs":{},"输":{"docs":{},"出":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"下":{"docs":{},"标":{"docs":{},"必":{"docs":{},"须":{"docs":{},"匹":{"docs":{},"配":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}},"上":{"docs":{},"述":{"docs":{},"代":{"docs":{},"码":{"docs":{},"直":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"仅":{"docs":{},"仅":{"docs":{},"只":{"docs":{},"有":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"类":{"docs":{},"会":{"docs":{},"被":{"docs":{},"隔":{"docs":{},"离":{"docs":{},"，":{"docs":{},"其":{"docs":{},"他":{"docs":{},"任":{"docs":{},"意":{"docs":{},"类":{"docs":{},"会":{"docs":{},"被":{"docs":{},"当":{"docs":{},"前":{"docs":{},"类":{"docs":{},"加":{"docs":{},"载":{"docs":{},"器":{"docs":{},"加":{"docs":{},"载":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"仅":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"某":{"docs":{},"些":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"和":{"docs":{},"内":{"docs":{},"核":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"请":{"docs":{},"检":{"docs":{},"查":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"文":{"docs":{},"档":{"docs":{},"看":{"docs":{},"是":{"docs":{},"它":{"docs":{},"是":{"docs":{},"否":{"docs":{},"支":{"docs":{},"持":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"会":{"docs":{},"寻":{"docs":{},"找":{"docs":{},"s":{"docs":{},"l":{"docs":{},"f":{"4":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}}}}}}}}}}}},"列":{"docs":{},"表":{"docs":{},"将":{"docs":{},"包":{"docs":{},"含":{"docs":{},"按":{"docs":{},"照":{"docs":{},"它":{"docs":{},"们":{"docs":{},"优":{"docs":{},"先":{"docs":{},"级":{"docs":{},"排":{"docs":{},"序":{"docs":{},"的":{"docs":{},"m":{"docs":{},"x":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"，":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"列":{"docs":{},"表":{"docs":{},"中":{"docs":{},"优":{"docs":{},"先":{"docs":{},"级":{"docs":{},"低":{"docs":{},"的":{"docs":{},"m":{"docs":{},"x":{"docs":{},"记":{"docs":{},"录":{"docs":{},"会":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"优":{"docs":{},"先":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"列":{"docs":{},"表":{"docs":{},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"v":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"，":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"优":{"docs":{},"先":{"docs":{},"级":{"docs":{},"低":{"docs":{},"的":{"docs":{},"记":{"docs":{},"录":{"docs":{},"会":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"优":{"docs":{},"先":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"列":{"docs":{},"表":{"docs":{},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"传":{"docs":{},"入":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"4":{"docs":{},"j":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}},"这":{"docs":{},"些":{"docs":{},"请":{"docs":{},"求":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"从":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"指":{"docs":{},"标":{"docs":{},"量":{"docs":{},"是":{"docs":{},"由":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}},"是":{"docs":{},"在":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"输":{"docs":{},"出":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"的":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"必":{"docs":{},"须":{"docs":{},"能":{"docs":{},"够":{"docs":{},"访":{"docs":{},"问":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"当":{"docs":{},"前":{"docs":{},"版":{"docs":{},"本":{"docs":{},"还":{"docs":{},"处":{"docs":{},"于":{"docs":{},"预":{"docs":{},"览":{"docs":{},"版":{"docs":{},"，":{"docs":{},"请":{"docs":{},"慎":{"docs":{},"重":{"docs":{},"在":{"docs":{},"生":{"docs":{},"产":{"docs":{},"环":{"docs":{},"境":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}}}}}}}},"求":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"/":{"docs":{},"响":{"docs":{},"应":{"docs":{},"模":{"docs":{},"型":{"docs":{},"的":{"docs":{},"具":{"docs":{},"有":{"docs":{},"各":{"docs":{},"种":{"docs":{},"帧":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"帧":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"该":{"docs":{},"协":{"docs":{},"议":{"docs":{},"允":{"docs":{},"许":{"docs":{},"发":{"docs":{},"送":{"docs":{},"和":{"docs":{},"接":{"docs":{},"收":{"docs":{},"其":{"docs":{},"他":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"帧":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"包":{"docs":{},"含":{"docs":{},"各":{"docs":{},"种":{"docs":{},"帧":{"docs":{},"的":{"docs":{},"一":{"docs":{},"种":{"docs":{},"帧":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"该":{"docs":{},"协":{"docs":{},"议":{"docs":{},"允":{"docs":{},"许":{"docs":{},"发":{"docs":{},"送":{"docs":{},"和":{"docs":{},"接":{"docs":{},"收":{"docs":{},"其":{"docs":{},"他":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"帧":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"、":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"它":{"docs":{},"还":{"docs":{},"将":{"docs":{},"接":{"docs":{},"受":{"docs":{},"以":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"当":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"头":{"docs":{},"信":{"docs":{},"息":{"docs":{},"被":{"docs":{},"完":{"docs":{},"全":{"docs":{},"读":{"docs":{},"取":{"docs":{},"时":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"该":{"docs":{},"请":{"docs":{},"求":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"若":{"docs":{},"要":{"docs":{},"执":{"docs":{},"行":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"中":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"通":{"docs":{},"常":{"docs":{},"是":{"docs":{},"相":{"docs":{},"对":{"docs":{},"的":{"docs":{},"，":{"docs":{},"若":{"docs":{},"您":{"docs":{},"想":{"docs":{},"要":{"docs":{},"读":{"docs":{},"取":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"和":{"docs":{},"相":{"docs":{},"对":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"绝":{"docs":{},"对":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"，":{"docs":{},"可":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"际":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"，":{"docs":{},"它":{"docs":{},"总":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"相":{"docs":{},"对":{"docs":{},"的":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"输":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"的":{"docs":{},"主":{"docs":{},"机":{"docs":{},"名":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"部":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"包":{"docs":{},"含":{"docs":{},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"主":{"docs":{},"机":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"体":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{},"数":{"docs":{},"据":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"，":{"docs":{},"如":{"docs":{},"下":{"docs":{},"所":{"docs":{},"示":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"很":{"docs":{},"大":{"docs":{},"并":{"docs":{},"填":{"docs":{},"满":{"docs":{},"了":{"docs":{},"内":{"docs":{},"存":{"docs":{},"，":{"docs":{},"任":{"docs":{},"何":{"docs":{},"时":{"docs":{},"候":{"docs":{},"它":{"docs":{},"依":{"docs":{},"旧":{"docs":{},"会":{"docs":{},"工":{"docs":{},"作":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"完":{"docs":{},"全":{"docs":{},"读":{"docs":{},"取":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"直":{"docs":{},"接":{"docs":{},"读":{"docs":{},"取":{"docs":{},"表":{"docs":{},"单":{"docs":{},"属":{"docs":{},"性":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"在":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"比":{"docs":{},"较":{"docs":{},"大":{"docs":{},"需":{"docs":{},"要":{"docs":{},"流":{"docs":{},"式":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"，":{"docs":{},"或":{"docs":{},"预":{"docs":{},"先":{"docs":{},"不":{"docs":{},"知":{"docs":{},"道":{"docs":{},"大":{"docs":{},"小":{"docs":{},"时":{"docs":{},"很":{"docs":{},"常":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"除":{"docs":{},"非":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"则":{"docs":{},"返":{"docs":{},"回":{"docs":{},"伪":{"docs":{},"头":{"docs":{},"中":{"docs":{},"的":{"docs":{},":":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"在":{"docs":{},"请":{"docs":{},"求":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"多":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"结":{"docs":{},"束":{"docs":{},"。":{"docs":{},"无":{"docs":{},"参":{"docs":{},"简":{"docs":{},"单":{"docs":{},"结":{"docs":{},"束":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"能":{"docs":{},"会":{"docs":{},"成":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"和":{"docs":{},"响":{"docs":{},"应":{"docs":{},"和":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"之":{"docs":{},"间":{"docs":{},"传":{"docs":{},"递":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"做":{"docs":{},"细":{"docs":{},"微":{"docs":{},"粒":{"docs":{},"度":{"docs":{},"控":{"docs":{},"制":{"docs":{},"时":{"docs":{},"，":{"docs":{},"您":{"docs":{},"应":{"docs":{},"当":{"docs":{},"使":{"docs":{},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}},"泵":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"会":{"docs":{},"话":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"关":{"docs":{},"系":{"docs":{},"，":{"docs":{},"并":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"置":{"docs":{},"会":{"docs":{},"话":{"docs":{},"范":{"docs":{},"围":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"的":{"docs":{},"能":{"docs":{},"力":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"一":{"docs":{},"个":{"docs":{},"购":{"docs":{},"物":{"docs":{},"篮":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"头":{"docs":{},"部":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"，":{"docs":{},"除":{"docs":{},"非":{"docs":{},"您":{"docs":{},"已":{"docs":{},"经":{"docs":{},"设":{"docs":{},"置":{"docs":{},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"头":{"docs":{},"（":{"docs":{},"包":{"docs":{},"括":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"对":{"docs":{},"象":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"并":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"升":{"docs":{},"级":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"异":{"docs":{},"常":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"或":{"docs":{},"者":{"docs":{},"直":{"docs":{},"接":{"docs":{},"建":{"docs":{},"立":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"方":{"docs":{},"法":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"查":{"docs":{},"询":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"版":{"docs":{},"本":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"准":{"docs":{},"备":{"docs":{},"工":{"docs":{},"作":{"docs":{},"，":{"docs":{},"您":{"docs":{},"必":{"docs":{},"须":{"docs":{},"调":{"docs":{},"用":{"docs":{},"其":{"docs":{},"中":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"超":{"docs":{},"时":{"docs":{},"时":{"docs":{},"间":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"响":{"docs":{},"应":{"docs":{},"里":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{},"独":{"docs":{},"一":{"docs":{},"无":{"docs":{},"二":{"docs":{},"的":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"作":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"路":{"docs":{},"径":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"来":{"docs":{},"调":{"docs":{},"用":{"docs":{},"模":{"docs":{},"板":{"docs":{},"引":{"docs":{},"擎":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"成":{"docs":{},"分":{"docs":{},"块":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"超":{"docs":{},"时":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"路":{"docs":{},"径":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"返":{"docs":{},"回":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"中":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"提":{"docs":{},"供":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"，":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"必":{"docs":{},"须":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"，":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"将":{"docs":{},"执":{"docs":{},"行":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"被":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"将":{"docs":{},"升":{"docs":{},"级":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"你":{"docs":{},"必":{"docs":{},"须":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"则":{"docs":{},"必":{"docs":{},"须":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"并":{"docs":{},"在":{"docs":{},"单":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"调":{"docs":{},"用":{"docs":{},"中":{"docs":{},"发":{"docs":{},"送":{"docs":{},"它":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"当":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"查":{"docs":{},"找":{"docs":{},"首":{"docs":{},"个":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"该":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"很":{"docs":{},"明":{"docs":{},"显":{"docs":{},"的":{"docs":{},"是":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"处":{"docs":{},"理":{"docs":{},"时":{"docs":{},"间":{"docs":{},"不":{"docs":{},"可":{"docs":{},"以":{"docs":{},"超":{"docs":{},"过":{"0":{"docs":{},".":{"1":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"您":{"docs":{},"不":{"docs":{},"能":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"任":{"docs":{},"何":{"docs":{},"过":{"docs":{},"多":{"docs":{},"（":{"docs":{},"大":{"docs":{},"于":{"0":{"docs":{},".":{"1":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"）":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}},"必":{"docs":{},"须":{"docs":{},"使":{"docs":{},"用":{"docs":{},"应":{"docs":{},"用":{"docs":{},"层":{"docs":{},"协":{"docs":{},"议":{"docs":{},"协":{"docs":{},"商":{"docs":{},"(":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{},")":{"docs":{},"启":{"docs":{},"用":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"通":{"docs":{},"常":{"docs":{},"如":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"失":{"docs":{},"败":{"docs":{},"时":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"日":{"docs":{},"志":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"时":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"在":{"docs":{},"该":{"docs":{},"日":{"docs":{},"期":{"docs":{},"之":{"docs":{},"后":{"docs":{},"没":{"docs":{},"有":{"docs":{},"修":{"docs":{},"改":{"docs":{},"过":{"docs":{},"，":{"docs":{},"则":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{},"没":{"docs":{},"办":{"docs":{},"法":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"都":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922}}}}}}}}}}},"以":{"docs":{},"及":{"docs":{},"从":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"需":{"docs":{},"求":{"docs":{},"，":{"docs":{},"利":{"docs":{},"用":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"泵":{"docs":{},"入":{"docs":{},"可":{"docs":{},"写":{"docs":{},"流":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}},"记":{"docs":{},"住":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"和":{"docs":{},"私":{"docs":{},"钥":{"docs":{},"是":{"docs":{},"不":{"docs":{},"加":{"docs":{},"密":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"将":{"docs":{},"会":{"docs":{},"定":{"docs":{},"期":{"docs":{},"触":{"docs":{},"发":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"的":{"docs":{},"定":{"docs":{},"时":{"docs":{},"任":{"docs":{},"务":{"docs":{},"会":{"docs":{},"花":{"docs":{},"费":{"docs":{},"大":{"docs":{},"量":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"，":{"docs":{},"则":{"docs":{},"您":{"docs":{},"的":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"事":{"docs":{},"件":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"连":{"docs":{},"续":{"docs":{},"执":{"docs":{},"行":{"docs":{},"甚":{"docs":{},"至":{"docs":{},"发":{"docs":{},"生":{"docs":{},"更":{"docs":{},"坏":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"：":{"docs":{},"重":{"docs":{},"叠":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"您":{"docs":{},"应":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"阅":{"docs":{},"读":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"访":{"docs":{},"问":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"跟":{"docs":{},"其":{"docs":{},"它":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"项":{"docs":{},"目":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"首":{"docs":{},"先":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"项":{"docs":{},"目":{"docs":{},"的":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"i":{"docs":{},"d":{"docs":{},"，":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{},"以":{"docs":{},"及":{"docs":{},"版":{"docs":{},"本":{"docs":{},"号":{"docs":{},"，":{"docs":{},"随":{"docs":{},"后":{"docs":{},"我":{"docs":{},"们":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"分":{"docs":{},"别":{"docs":{},"是":{"docs":{},"：":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"版":{"docs":{},"本":{"docs":{},"号":{"docs":{},"，":{"docs":{},"此":{"docs":{},"处":{"docs":{},"我":{"docs":{},"们":{"docs":{},"使":{"docs":{},"用":{"docs":{},"最":{"docs":{},"新":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"；":{"docs":{},"以":{"docs":{},"及":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"我":{"docs":{},"们":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"包":{"docs":{},"含":{"docs":{},"有":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"主":{"docs":{},"类":{"docs":{},"。":{"docs":{},"之":{"docs":{},"后":{"docs":{},"我":{"docs":{},"们":{"docs":{},"引":{"docs":{},"入":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"插":{"docs":{},"件":{"docs":{},"，":{"docs":{},"分":{"docs":{},"别":{"docs":{},"是":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"首":{"docs":{},"先":{"docs":{},"新":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"项":{"docs":{},"目":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"基":{"docs":{},"本":{"docs":{},"的":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"项":{"docs":{},"目":{"docs":{},"目":{"docs":{},"录":{"docs":{},"结":{"docs":{},"构":{"docs":{},"如":{"docs":{},"下":{"docs":{},"所":{"docs":{},"示":{"docs":{},"：":{"docs":{"start/Start.html":{"ref":"start/Start.html","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"去":{"docs":{},"j":{"docs":{},"e":{"docs":{},"t":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"官":{"docs":{},"方":{"docs":{},"网":{"docs":{},"站":{"docs":{},"：":{"docs":{},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"j":{"docs":{},"e":{"docs":{},"t":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}},"来":{"docs":{},"看":{"docs":{},"些":{"docs":{},"基":{"docs":{},"本":{"docs":{},"概":{"docs":{},"念":{"docs":{},"和":{"docs":{},"理":{"docs":{},"论":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"你":{"docs":{},"的":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"中":{"docs":{},"。":{"docs":{},"详":{"docs":{},"细":{"docs":{},"信":{"docs":{},"息":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{},"页":{"docs":{},"面":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"添":{"docs":{},"加":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}},"'":{"1":{"docs":{},".":{"0":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}},"docs":{}}},"4":{"docs":{},".":{"1":{"2":{"docs":{},"'":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}}},"docs":{}},"docs":{}}},"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"'":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}},"/":{"docs":{},"/":{"docs":{},"对":{"docs":{},"应":{"docs":{},"刚":{"docs":{},"刚":{"docs":{},"向":{"docs":{},"导":{"docs":{},"中":{"docs":{},"输":{"docs":{},"入":{"docs":{},"的":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},":":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0025549310168625446},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.013711151736745886},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"'":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"'":{"docs":{},",":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.014598540145985401}}}}}}}},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},"'":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"'":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"x":{"docs":{},"y":{"docs":{},"z":{"docs":{},"'":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"'":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"'":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"'":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}},"s":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"'":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"'":{"docs":{},"]":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"'":{"docs":{},",":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"'":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}},":":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.027155465037338764},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.01990049751243781},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}},"?":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"）":{"docs":{},"，":{"docs":{},"您":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"逗":{"docs":{},"号":{"docs":{},"（":{"docs":{},",":{"docs":{},"）":{"docs":{},"分":{"docs":{},"隔":{"docs":{},"它":{"docs":{},"们":{"docs":{},"来":{"docs":{},"指":{"docs":{},"定":{"docs":{},"多":{"docs":{},"个":{"docs":{},"集":{"docs":{},"合":{"docs":{},"。":{"docs":{},"模":{"docs":{},"式":{"docs":{},"相":{"docs":{},"当":{"docs":{},"于":{"docs":{},"当":{"docs":{},"前":{"docs":{},"工":{"docs":{},"作":{"docs":{},"目":{"docs":{},"录":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},")":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.004103967168262654}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},"t":{"docs":{},")":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0072992700729927005}}}}}}}}}}}},"x":{"docs":{},"v":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0064794816414686825}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.007312614259597806},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":5.040816326530612}},"e":{"docs":{},"r":{"docs":{},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635}}}},"docs":{}}},"docs":{}}},"docs":{}},"（":{"docs":{},"预":{"docs":{},"览":{"docs":{},"版":{"docs":{},"）":{"docs":{"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353}}}}}}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.026239067055393587}}}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.011661807580174927}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{},"/":{"docs":{},"/":{"docs":{},"创":{"docs":{},"建":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}},"z":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}},"k":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},",":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}},"z":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"点":{"docs":{},"知":{"docs":{},"识":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"/":{"docs":{},"进":{"docs":{},"程":{"docs":{},"内":{"docs":{},"有":{"docs":{},"多":{"docs":{},"个":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"和":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"每":{"docs":{},"个":{"docs":{},"线":{"docs":{},"程":{"docs":{},"会":{"docs":{},"部":{"docs":{},"署":{"docs":{},"多":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"对":{"docs":{},"象":{"docs":{},"并":{"docs":{},"对":{"docs":{},"应":{"docs":{},"执":{"docs":{},"行":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"内":{"docs":{},"的":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"每":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"内":{"docs":{},"有":{"docs":{},"多":{"docs":{},"个":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"普":{"docs":{},"通":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"会":{"docs":{},"跟":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"，":{"docs":{},"而":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"复":{"docs":{},"杂":{"docs":{},"一":{"docs":{},"点":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}},"简":{"docs":{},"单":{"docs":{},"粗":{"docs":{},"暴":{"docs":{},"的":{"docs":{},"判":{"docs":{},"断":{"docs":{},"标":{"docs":{},"准":{"docs":{},"：":{"docs":{},"任":{"docs":{},"何":{"docs":{},"涉":{"docs":{},"及":{"docs":{},"到":{"docs":{},"i":{"docs":{},"o":{"docs":{},"操":{"docs":{},"作":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"可":{"docs":{},"能":{"docs":{},"造":{"docs":{},"成":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"纯":{"docs":{},"粹":{"docs":{},"内":{"docs":{},"存":{"docs":{},"操":{"docs":{},"作":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"执":{"docs":{},"行":{"docs":{},"时":{"docs":{},"间":{"docs":{},"没":{"docs":{},"有":{"docs":{},"明":{"docs":{},"显":{"docs":{},"超":{"docs":{},"长":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"执":{"docs":{},"行":{"docs":{},"循":{"docs":{},"环":{"docs":{},"几":{"docs":{},"万":{"docs":{},"次":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"便":{"docs":{},"可":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"执":{"docs":{},"行":{"docs":{},"时":{"docs":{},"间":{"docs":{},"超":{"docs":{},"长":{"docs":{},"）":{"docs":{},"，":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"非":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"代":{"docs":{},"码":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"地":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"返":{"docs":{},"回":{"docs":{},"当":{"docs":{},"天":{"docs":{},"时":{"docs":{},"间":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"在":{"docs":{},"应":{"docs":{},"答":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"里":{"docs":{},"会":{"docs":{},"包":{"docs":{},"含":{"docs":{},"当":{"docs":{},"天":{"docs":{},"时":{"docs":{},"间":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"u":{"docs":{},"l":{"docs":{},"日":{"docs":{},"志":{"docs":{},"记":{"docs":{},"录":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"普":{"docs":{},"通":{"docs":{},"的":{"docs":{},"j":{"docs":{},"u":{"docs":{},"l":{"docs":{},"方":{"docs":{},"式":{"docs":{},"指":{"docs":{},"定":{"docs":{},"—":{"docs":{},"—":{"docs":{},"通":{"docs":{},"过":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"为":{"docs":{},"您":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{},"更":{"docs":{},"多":{"docs":{},"关":{"docs":{},"于":{"docs":{},"此":{"docs":{},"部":{"docs":{},"分":{"docs":{},"以":{"docs":{},"及":{"docs":{},"j":{"docs":{},"u":{"docs":{},"l":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"结":{"docs":{},"构":{"docs":{},"的":{"docs":{},"内":{"docs":{},"容":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{},"j":{"docs":{},"u":{"docs":{},"l":{"docs":{},"日":{"docs":{},"志":{"docs":{},"记":{"docs":{},"录":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"订":{"docs":{},"单":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"也":{"docs":{},"许":{"docs":{},"会":{"docs":{},"用":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"确":{"docs":{},"认":{"docs":{},"这":{"docs":{},"个":{"docs":{},"订":{"docs":{},"单":{"docs":{},"已":{"docs":{},"经":{"docs":{},"成":{"docs":{},"功":{"docs":{},"处":{"docs":{},"理":{"docs":{},"并":{"docs":{},"且":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"中":{"docs":{},"删":{"docs":{},"除":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"持":{"docs":{},"久":{"docs":{},"化":{"docs":{},"队":{"docs":{},"列":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"，":{"docs":{},"当":{"docs":{},"消":{"docs":{},"息":{"docs":{},"成":{"docs":{},"功":{"docs":{},"持":{"docs":{},"久":{"docs":{},"化":{"docs":{},"到":{"docs":{},"存":{"docs":{},"储":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"来":{"docs":{},"应":{"docs":{},"答":{"docs":{},"消":{"docs":{},"息":{"docs":{},"，":{"docs":{},"或":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"表":{"docs":{},"示":{"docs":{},"失":{"docs":{},"败":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"通":{"docs":{},"常":{"docs":{},"是":{"docs":{},"由":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"文":{"docs":{},"件":{"docs":{},"被":{"docs":{},"创":{"docs":{},"建":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"1":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}}}}},"最":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"直":{"docs":{},"接":{"docs":{},"获":{"docs":{},"取":{"docs":{},"已":{"docs":{},"经":{"docs":{},"读":{"docs":{},"取":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"并":{"docs":{},"立":{"docs":{},"即":{"docs":{},"将":{"docs":{},"其":{"docs":{},"写":{"docs":{},"入":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"泵":{"docs":{},"可":{"docs":{},"以":{"docs":{},"启":{"docs":{},"动":{"docs":{},"和":{"docs":{},"停":{"docs":{},"止":{"docs":{},"多":{"docs":{},"次":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"流":{"docs":{},"式":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"表":{"docs":{},"示":{"docs":{},"将":{"docs":{},"多":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"调":{"docs":{},"用":{"docs":{},"链":{"docs":{},"在":{"docs":{},"一":{"docs":{},"起":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"独":{"docs":{},"立":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"非":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"/":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"连":{"docs":{},"接":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"u":{"docs":{},"p":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"方":{"docs":{},"法":{"docs":{},"升":{"docs":{},"级":{"docs":{},"到":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"/":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"常":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"是":{"docs":{},"从":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"读":{"docs":{},"取":{"docs":{},"然":{"docs":{},"后":{"docs":{},"写":{"docs":{},"回":{"docs":{},"到":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"路":{"docs":{},"径":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"用":{"docs":{},"户":{"docs":{},"的":{"docs":{},"行":{"docs":{},"应":{"docs":{},"该":{"docs":{},"是":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"结":{"docs":{},"构":{"docs":{},"：":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}},"角":{"docs":{},"色":{"docs":{},"行":{"docs":{},"应":{"docs":{},"该":{"docs":{},"是":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"结":{"docs":{},"构":{"docs":{},"：":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}},"接":{"docs":{},"收":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"服":{"docs":{},"务":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"可":{"docs":{},"以":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"可":{"docs":{},"以":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}},"编":{"docs":{},"译":{"docs":{},"时":{"docs":{},"产":{"docs":{},"生":{"docs":{},"的":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}},"下":{"docs":{},"是":{"docs":{},"随":{"docs":{},"机":{"docs":{},"访":{"docs":{},"问":{"docs":{},"读":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"些":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"东":{"docs":{},"西":{"docs":{},"被":{"docs":{},"写":{"docs":{},"入":{"docs":{},"到":{"docs":{},"文":{"docs":{},"件":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"2":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}}}}}}}},"代":{"docs":{},"码":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"合":{"docs":{},"法":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"形":{"docs":{},"如":{"docs":{},"：":{"docs":{},"e":{"docs":{},"u":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"1":{"docs":{},"、":{"docs":{},"a":{"docs":{},"c":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"、":{"docs":{},"s":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"和":{"docs":{},"x":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"过":{"docs":{},"程":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"些":{"docs":{},"额":{"docs":{},"外":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"（":{"docs":{},"比":{"docs":{},"如":{"docs":{},"路":{"docs":{},"径":{"docs":{},"）":{"docs":{},"。":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"于":{"docs":{},"创":{"docs":{},"建":{"docs":{},"服":{"docs":{},"务":{"docs":{},"实":{"docs":{},"例":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"工":{"docs":{},"厂":{"docs":{},"方":{"docs":{},"法":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}}}}}}}}}}}}}}},"旦":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"在":{"docs":{},"后":{"docs":{},"台":{"docs":{},"启":{"docs":{},"动":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"命":{"docs":{},"令":{"docs":{},"停":{"docs":{},"止":{"docs":{},"它":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"完":{"docs":{},"成":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"以":{"docs":{},"上":{"docs":{},"步":{"docs":{},"骤":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"第":{"docs":{},"一":{"docs":{},"步":{"docs":{},"所":{"docs":{},"需":{"docs":{},"要":{"docs":{},"做":{"docs":{},"的":{"docs":{},"就":{"docs":{},"是":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"完":{"docs":{},"成":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"有":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"获":{"docs":{},"取":{"docs":{},"当":{"docs":{},"前":{"docs":{},"的":{"docs":{},"计":{"docs":{},"数":{"docs":{},"，":{"docs":{},"以":{"docs":{},"原":{"docs":{},"子":{"docs":{},"方":{"docs":{},"式":{"docs":{},"递":{"docs":{},"增":{"docs":{},"、":{"docs":{},"递":{"docs":{},"减":{"docs":{},"，":{"docs":{},"并":{"docs":{},"使":{"docs":{},"用":{"docs":{},"各":{"docs":{},"种":{"docs":{},"方":{"docs":{},"法":{"docs":{},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"实":{"docs":{},"例":{"docs":{},"配":{"docs":{},"置":{"docs":{},"好":{"docs":{},"后":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"生":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"，":{"docs":{},"您":{"docs":{},"将":{"docs":{},"发":{"docs":{},"现":{"docs":{},"e":{"docs":{},"c":{"docs":{},"h":{"docs":{},"o":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"在":{"docs":{},"功":{"docs":{},"能":{"docs":{},"上":{"docs":{},"与":{"docs":{},"之":{"docs":{},"前":{"docs":{},"相":{"docs":{},"同":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"核":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"利":{"docs":{},"用":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"可":{"docs":{},"以":{"docs":{},"处":{"docs":{},"理":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"工":{"docs":{},"作":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"获":{"docs":{},"取":{"docs":{},"到":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"用":{"docs":{},"完":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"连":{"docs":{},"接":{"docs":{},"后":{"docs":{},"，":{"docs":{},"请":{"docs":{},"确":{"docs":{},"保":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"它":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}},"你":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"户":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"过":{"docs":{},"后":{"docs":{},"，":{"docs":{},"你":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"它":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"对":{"docs":{},"这":{"docs":{},"个":{"docs":{},"用":{"docs":{},"户":{"docs":{},"进":{"docs":{},"行":{"docs":{},"授":{"docs":{},"权":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"后":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"按":{"docs":{},"下":{"docs":{},"边":{"docs":{},"代":{"docs":{},"码":{"docs":{},"创":{"docs":{},"建":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"实":{"docs":{},"例":{"docs":{},"：":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"后":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"按":{"docs":{},"照":{"docs":{},"下":{"docs":{},"边":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"创":{"docs":{},"建":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"实":{"docs":{},"例":{"docs":{},"：":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"使":{"docs":{},"用":{"docs":{},"完":{"docs":{},"后":{"docs":{},"释":{"docs":{},"放":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}},"成":{"docs":{},"功":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"添":{"docs":{},"加":{"docs":{},"完":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"就":{"docs":{},"需":{"docs":{},"要":{"docs":{},"配":{"docs":{},"置":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.002742230347349177}}}}}}},"需":{"docs":{},"要":{"docs":{},"配":{"docs":{},"置":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.003656307129798903}}}}}}}}}}}}}},"注":{"docs":{},"册":{"docs":{},"了":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"就":{"docs":{},"可":{"docs":{},"用":{"docs":{},"了":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{},"集":{"docs":{},"群":{"docs":{},"上":{"docs":{},"，":{"docs":{},"则":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"节":{"docs":{},"点":{"docs":{},"都":{"docs":{},"可":{"docs":{},"访":{"docs":{},"问":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"次":{"docs":{},"性":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"会":{"docs":{},"在":{"docs":{},"一":{"docs":{},"定":{"docs":{},"延":{"docs":{},"迟":{"docs":{},"后":{"docs":{},"调":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"般":{"docs":{},"来":{"docs":{},"说":{"docs":{},"，":{"docs":{},"不":{"docs":{},"应":{"docs":{},"该":{"docs":{},"在":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}},"起":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{},"选":{"docs":{},"项":{"docs":{},"可":{"docs":{},"以":{"docs":{},"获":{"docs":{},"取":{"docs":{},"用":{"docs":{},"法":{"docs":{},"中":{"docs":{},"显":{"docs":{},"示":{"docs":{},"的":{"docs":{},"描":{"docs":{},"述":{"docs":{},"（":{"docs":{},"见":{"docs":{},"下":{"docs":{},"文":{"docs":{},"）":{"docs":{},"。":{"docs":{},"选":{"docs":{},"项":{"docs":{},"可":{"docs":{},"以":{"docs":{},"接":{"docs":{},"受":{"0":{"docs":{},"、":{"1":{"docs":{},"或":{"docs":{},"几":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{},"接":{"docs":{},"受":{"0":{"docs":{},"值":{"docs":{},"的":{"docs":{},"选":{"docs":{},"项":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"标":{"docs":{},"志":{"docs":{},"(":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{},")":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"词":{"docs":{},"同":{"docs":{},"时":{"docs":{},"具":{"docs":{},"有":{"docs":{},"名":{"docs":{},"词":{"docs":{},"和":{"docs":{},"动":{"docs":{},"词":{"docs":{},"的":{"docs":{},"含":{"docs":{},"义":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"避":{"docs":{},"免":{"docs":{},"混":{"docs":{},"淆":{"docs":{},"，":{"docs":{},"原":{"docs":{},"文":{"docs":{},"中":{"docs":{},"所":{"docs":{},"有":{"docs":{},"使":{"docs":{},"用":{"docs":{},"名":{"docs":{},"词":{"docs":{},"的":{"docs":{},"地":{"docs":{},"方":{"docs":{},"都":{"docs":{},"统":{"docs":{},"一":{"docs":{},"按":{"docs":{},"照":{"docs":{},"专":{"docs":{},"有":{"docs":{},"名":{"docs":{},"词":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"没":{"docs":{},"有":{"docs":{},"找":{"docs":{},"到":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"，":{"docs":{},"译":{"docs":{},"为":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"节":{"docs":{},"）":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}},"定":{"docs":{},"要":{"docs":{},"保":{"docs":{},"持":{"docs":{},"一":{"docs":{},"个":{"docs":{},"指":{"docs":{},"向":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"个":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"会":{"docs":{},"带":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"免":{"docs":{},"费":{"docs":{},"下":{"docs":{},"载":{"docs":{},"集":{"docs":{},"成":{"docs":{},"开":{"docs":{},"发":{"docs":{},"环":{"docs":{},"境":{"docs":{},"（":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"）":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"j":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"果":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"您":{"docs":{},"是":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"新":{"docs":{},"手":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"感":{"docs":{},"到":{"docs":{},"发":{"docs":{},"怵":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"特":{"docs":{},"意":{"docs":{},"为":{"docs":{},"您":{"docs":{},"准":{"docs":{},"备":{"docs":{},"了":{"docs":{},"可":{"docs":{},"视":{"docs":{},"化":{"docs":{},"傻":{"docs":{},"瓜":{"docs":{},"化":{"docs":{},"入":{"docs":{},"门":{"docs":{},"教":{"docs":{},"程":{"docs":{},"，":{"docs":{},"以":{"docs":{},"降":{"docs":{},"低":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"入":{"docs":{},"门":{"docs":{},"门":{"docs":{},"槛":{"docs":{},"。":{"docs":{},"但":{"docs":{},"是":{"docs":{},"再":{"docs":{},"怎":{"docs":{},"么":{"docs":{},"傻":{"docs":{},"瓜":{"docs":{},"，":{"docs":{},"也":{"docs":{},"还":{"docs":{},"是":{"docs":{},"需":{"docs":{},"要":{"docs":{},"您":{"docs":{},"具":{"docs":{},"备":{"docs":{},"有":{"docs":{},"基":{"docs":{},"本":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"语":{"docs":{},"法":{"docs":{},"知":{"docs":{},"识":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"在":{"docs":{},"此":{"docs":{},"介":{"docs":{},"绍":{"docs":{},"任":{"docs":{},"何":{"docs":{},"关":{"docs":{},"于":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"的":{"docs":{},"语":{"docs":{},"法":{"docs":{},"知":{"docs":{},"识":{"docs":{},"，":{"docs":{},"尤":{"docs":{},"其":{"docs":{},"是":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":0.0036496350364963502}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},"不":{"docs":{},"希":{"docs":{},"望":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"u":{"docs":{},"l":{"docs":{},"记":{"docs":{},"录":{"docs":{},"日":{"docs":{},"志":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"其":{"docs":{},"配":{"docs":{},"置":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"日":{"docs":{},"志":{"docs":{},"记":{"docs":{},"录":{"docs":{},"框":{"docs":{},"架":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"4":{"docs":{},"j":{"docs":{},"或":{"docs":{},"s":{"docs":{},"l":{"docs":{},"f":{"4":{"docs":{},"j":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"事":{"docs":{},"件":{"docs":{},"继":{"docs":{},"续":{"docs":{},"处":{"docs":{},"理":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"参":{"docs":{},"数":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"想":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"，":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"实":{"docs":{},"例":{"docs":{},"时":{"docs":{},"传":{"docs":{},"入":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"关":{"docs":{},"心":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"不":{"docs":{},"介":{"docs":{},"意":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"以":{"docs":{},"并":{"docs":{},"行":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"里":{"docs":{},"结":{"docs":{},"束":{"docs":{},"这":{"docs":{},"个":{"docs":{},"响":{"docs":{},"应":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"调":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"能":{"docs":{},"够":{"docs":{},"保":{"docs":{},"证":{"docs":{},"这":{"docs":{},"一":{"docs":{},"点":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"不":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"存":{"docs":{},"储":{"docs":{},"。":{"docs":{},"这":{"docs":{},"会":{"docs":{},"导":{"docs":{},"致":{"docs":{},"请":{"docs":{},"求":{"docs":{},"被":{"docs":{},"派":{"docs":{},"发":{"docs":{},"到":{"docs":{},"无":{"docs":{},"法":{"docs":{},"识":{"docs":{},"别":{"docs":{},"这":{"docs":{},"个":{"docs":{},"会":{"docs":{},"话":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"为":{"docs":{},"隐":{"docs":{},"藏":{"docs":{},"文":{"docs":{},"件":{"docs":{},"提":{"docs":{},"供":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"行":{"docs":{},"为":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"手":{"docs":{},"动":{"docs":{},"调":{"docs":{},"用":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.004975124378109453}},"的":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{},"的":{"docs":{},"异":{"docs":{},"步":{"docs":{},"支":{"docs":{},"持":{"docs":{},"，":{"docs":{},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"不":{"docs":{},"会":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"线":{"docs":{},"程":{"docs":{},"中":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"执":{"docs":{},"行":{"docs":{},"前":{"docs":{},"保":{"docs":{},"留":{"docs":{},"对":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"（":{"docs":{},"使":{"docs":{},"用":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"只":{"docs":{},"有":{"docs":{},"单":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"关":{"docs":{},"心":{"docs":{},"用":{"docs":{},"户":{"docs":{},"偏":{"docs":{},"好":{"docs":{},"的":{"docs":{},"语":{"docs":{},"言":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"喜":{"docs":{},"欢":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"直":{"docs":{},"接":{"docs":{},"实":{"docs":{},"现":{"docs":{},"该":{"docs":{},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"通":{"docs":{},"常":{"docs":{},"直":{"docs":{},"接":{"docs":{},"从":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"类":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"想":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"要":{"docs":{},"在":{"docs":{},"部":{"docs":{},"署":{"docs":{},"完":{"docs":{},"成":{"docs":{},"时":{"docs":{},"被":{"docs":{},"通":{"docs":{},"知":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"完":{"docs":{},"成":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"让":{"docs":{},"一":{"docs":{},"个":{"docs":{},"路":{"docs":{},"由":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"不":{"docs":{},"止":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"覆":{"docs":{},"盖":{"docs":{},"路":{"docs":{},"由":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"让":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"用":{"docs":{},"嵌":{"docs":{},"入":{"docs":{},"方":{"docs":{},"式":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"，":{"docs":{},"可":{"docs":{},"通":{"docs":{},"过":{"docs":{},"以":{"docs":{},"下":{"docs":{},"代":{"docs":{},"码":{"docs":{},"创":{"docs":{},"建":{"docs":{},"实":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"没":{"docs":{},"有":{"docs":{},"响":{"docs":{},"应":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"这":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"迹":{"docs":{},"象":{"docs":{},"，":{"docs":{},"表":{"docs":{},"明":{"docs":{},"您":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{},"地":{"docs":{},"方":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"了":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"文":{"docs":{},"件":{"docs":{},"在":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"运":{"docs":{},"行":{"docs":{},"过":{"docs":{},"程":{"docs":{},"中":{"docs":{},"可":{"docs":{},"能":{"docs":{},"发":{"docs":{},"生":{"docs":{},"变":{"docs":{},"化":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"嵌":{"docs":{},"入":{"docs":{},"式":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"像":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"一":{"docs":{},"样":{"docs":{},"启":{"docs":{},"动":{"docs":{},"一":{"docs":{},"个":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"，":{"docs":{},"并":{"docs":{},"试":{"docs":{},"图":{"docs":{},"发":{"docs":{},"送":{"docs":{},"消":{"docs":{},"息":{"docs":{},"，":{"docs":{},"您":{"docs":{},"会":{"docs":{},"发":{"docs":{},"现":{"docs":{},"您":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"神":{"docs":{},"秘":{"docs":{},"地":{"docs":{},"失":{"docs":{},"踪":{"docs":{},"了":{"docs":{},"。":{"docs":{},"发":{"docs":{},"生":{"docs":{},"了":{"docs":{},"什":{"docs":{},"么":{"docs":{},"？":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"希":{"docs":{},"望":{"docs":{},"在":{"docs":{},"回":{"docs":{},"话":{"docs":{},"中":{"docs":{},"存":{"docs":{},"储":{"docs":{},"用":{"docs":{},"户":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"以":{"docs":{},"避":{"docs":{},"免":{"docs":{},"对":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"都":{"docs":{},"执":{"docs":{},"行":{"docs":{},"认":{"docs":{},"证":{"docs":{},"过":{"docs":{},"程":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"会":{"docs":{},"话":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"确":{"docs":{},"保":{"docs":{},"它":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"了":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"路":{"docs":{},"径":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"会":{"docs":{},"在":{"docs":{},"认":{"docs":{},"证":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"之":{"docs":{},"前":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"事":{"docs":{},"务":{"docs":{},"中":{"docs":{},"执":{"docs":{},"行":{"docs":{},"多":{"docs":{},"个":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"就":{"docs":{},"应":{"docs":{},"该":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"户":{"docs":{},"登":{"docs":{},"出":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"直":{"docs":{},"接":{"docs":{},"操":{"docs":{},"作":{"docs":{},"原":{"docs":{},"生":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}},"没":{"docs":{},"有":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"知":{"docs":{},"道":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"要":{"docs":{},"访":{"docs":{},"问":{"docs":{},"某":{"docs":{},"些":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"数":{"docs":{},"据":{"docs":{},"里":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"路":{"docs":{},"径":{"docs":{},"、":{"docs":{},"请":{"docs":{},"求":{"docs":{},"参":{"docs":{},"数":{"docs":{},"或":{"docs":{},"者":{"docs":{},"会":{"docs":{},"话":{"docs":{},"等":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"模":{"docs":{},"板":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"执":{"docs":{},"行":{"docs":{},"之":{"docs":{},"前":{"docs":{},"将":{"docs":{},"他":{"docs":{},"们":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"数":{"docs":{},"据":{"docs":{},"里":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"上":{"docs":{},"述":{"docs":{},"未":{"docs":{},"列":{"docs":{},"出":{"docs":{},"的":{"docs":{},"提":{"docs":{},"供":{"docs":{},"商":{"docs":{},"，":{"docs":{},"您":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"基":{"docs":{},"本":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"在":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"发":{"docs":{},"生":{"docs":{},"事":{"docs":{},"件":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"得":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"返":{"docs":{},"回":{"docs":{},"哪":{"docs":{},"些":{"docs":{},"域":{"docs":{},"，":{"docs":{},"又":{"docs":{},"或":{"docs":{},"者":{"docs":{},"需":{"docs":{},"要":{"docs":{},"指":{"docs":{},"定":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"条":{"docs":{},"数":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"以":{"docs":{},"上":{"docs":{},"三":{"docs":{},"步":{"docs":{},"全":{"docs":{},"都":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"则":{"docs":{},"同":{"docs":{},"样":{"docs":{},"执":{"docs":{},"行":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}},"任":{"docs":{},"何":{"docs":{},"一":{"docs":{},"步":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"则":{"docs":{},"不":{"docs":{},"会":{"docs":{},"继":{"docs":{},"续":{"docs":{},"执":{"docs":{},"行":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"异":{"docs":{},"步":{"docs":{},"流":{"docs":{},"程":{"docs":{},"，":{"docs":{},"直":{"docs":{},"接":{"docs":{},"执":{"docs":{},"行":{"docs":{},"最":{"docs":{},"终":{"docs":{},"的":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"第":{"docs":{},"一":{"docs":{},"步":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"则":{"docs":{},"发":{"docs":{},"送":{"docs":{},"第":{"docs":{},"一":{"docs":{},"步":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"到":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}},"二":{"docs":{},"步":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"则":{"docs":{},"发":{"docs":{},"送":{"docs":{},"第":{"docs":{},"二":{"docs":{},"部":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"到":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}},"上":{"docs":{},"述":{"docs":{},"任":{"docs":{},"何":{"docs":{},"一":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"停":{"docs":{},"止":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"不":{"docs":{},"指":{"docs":{},"定":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"将":{"docs":{},"根":{"docs":{},"据":{"docs":{},"提":{"docs":{},"供":{"docs":{},"名":{"docs":{},"字":{"docs":{},"后":{"docs":{},"缀":{"docs":{},"来":{"docs":{},"查":{"docs":{},"找":{"docs":{},"对":{"docs":{},"应":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"，":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"参":{"docs":{},"数":{"docs":{},"索":{"docs":{},"引":{"docs":{},"，":{"docs":{},"则":{"docs":{},"基":{"docs":{},"于":{"docs":{},"声":{"docs":{},"明":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"计":{"docs":{},"算":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"同":{"docs":{},"的":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"对":{"docs":{},"象":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}},"任":{"docs":{},"何":{"docs":{},"一":{"docs":{},"步":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"将":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"标":{"docs":{},"记":{"docs":{},"成":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"立":{"docs":{},"即":{"docs":{},"提":{"docs":{},"供":{"docs":{},"结":{"docs":{},"果":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"立":{"docs":{},"即":{"docs":{},"返":{"docs":{},"回":{"docs":{},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"来":{"docs":{},"接":{"docs":{},"收":{"docs":{},"稍":{"docs":{},"后":{"docs":{},"回":{"docs":{},"调":{"docs":{},"的":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"想":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"这":{"docs":{},"些":{"docs":{},"警":{"docs":{},"告":{"docs":{},"或":{"docs":{},"更":{"docs":{},"改":{"docs":{},"设":{"docs":{},"置":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"要":{"docs":{},"配":{"docs":{},"置":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}},"替":{"docs":{},"换":{"docs":{},"上":{"docs":{},"边":{"docs":{},"的":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"和":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"两":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"字":{"docs":{},"段":{"docs":{},"名":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"下":{"docs":{},"边":{"docs":{},"两":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"你":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"正":{"docs":{},"常":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"来":{"docs":{},"使":{"docs":{},"用":{"docs":{},"注":{"docs":{},"解":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"声":{"docs":{},"明":{"docs":{},"注":{"docs":{},"解":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"在":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"查":{"docs":{},"阅":{"docs":{},"更":{"docs":{},"详":{"docs":{},"细":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"或":{"docs":{},"实":{"docs":{},"现":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"日":{"docs":{},"志":{"docs":{},"后":{"docs":{},"端":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}}}}}}}},"注":{"docs":{},"销":{"docs":{},"这":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"需":{"docs":{},"要":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"认":{"docs":{},"证":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"当":{"docs":{},"连":{"docs":{},"接":{"docs":{},"时":{"docs":{},"，":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"必":{"docs":{},"须":{"docs":{},"向":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"提":{"docs":{},"供":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"证":{"docs":{},"书":{"docs":{},"。":{"docs":{},"可":{"docs":{},"通":{"docs":{},"过":{"docs":{},"以":{"docs":{},"下":{"docs":{},"几":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"配":{"docs":{},"置":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"终":{"docs":{},"端":{"1":{"docs":{},"中":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"被":{"docs":{},"杀":{"docs":{},"掉":{"docs":{},"，":{"docs":{},"则":{"docs":{},"它":{"docs":{},"将":{"docs":{},"故":{"docs":{},"障":{"docs":{},"转":{"docs":{},"移":{"docs":{},"到":{"docs":{},"终":{"docs":{},"端":{"2":{"docs":{},"中":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"具":{"docs":{},"有":{"docs":{},"不":{"docs":{},"同":{"docs":{},"组":{"docs":{},"的":{"docs":{},"终":{"docs":{},"端":{"3":{"docs":{},"中":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"docs":{}}},"编":{"docs":{},"写":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"缺":{"docs":{},"省":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"不":{"docs":{},"适":{"docs":{},"合":{"docs":{},"您":{"docs":{},"，":{"docs":{},"可":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"包":{"docs":{},"含":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"该":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"将":{"docs":{},"在":{"docs":{},"请":{"docs":{},"求":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"后":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"时":{"docs":{},"间":{"docs":{},"到":{"docs":{},"达":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"访":{"docs":{},"问":{"docs":{},"虚":{"docs":{},"机":{"docs":{},"主":{"docs":{},"机":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"了":{"docs":{},"m":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"在":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"下":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"注":{"docs":{},"册":{"docs":{},"到":{"docs":{},"当":{"docs":{},"前":{"docs":{},"节":{"docs":{},"点":{"docs":{},"的":{"docs":{},"e":{"docs":{},"v":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"三":{"docs":{},"个":{"docs":{},"步":{"docs":{},"骤":{"docs":{},"全":{"docs":{},"部":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"则":{"docs":{},"最":{"docs":{},"终":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"样":{"docs":{},"做":{"docs":{},"，":{"docs":{},"该":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"值":{"docs":{},"得":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"是":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"在":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"查":{"docs":{},"找":{"docs":{},"那":{"docs":{},"个":{"docs":{},"名":{"docs":{},"字":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"这":{"docs":{},"个":{"docs":{},"值":{"docs":{},"的":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"是":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{},"，":{"docs":{},"将":{"docs":{},"在":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"上":{"docs":{},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"这":{"docs":{},"个":{"docs":{},"值":{"docs":{},"得":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"是":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},":":{"docs":{},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"来":{"docs":{},"加":{"docs":{},"载":{"docs":{},"这":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"选":{"docs":{},"项":{"docs":{},"值":{"docs":{},"被":{"docs":{},"限":{"docs":{},"制":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"固":{"docs":{},"定":{"docs":{},"集":{"docs":{},"合":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"置":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"可":{"docs":{},"接":{"docs":{},"受":{"docs":{},"选":{"docs":{},"项":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"来":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"，":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"包":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}},"部":{"docs":{},"署":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"完":{"docs":{},"成":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"中":{"docs":{},"将":{"docs":{},"会":{"docs":{},"包":{"docs":{},"含":{"docs":{},"部":{"docs":{},"署":{"docs":{},"i":{"docs":{},"d":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"部":{"docs":{},"署":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"在":{"docs":{},"响":{"docs":{},"应":{"docs":{},"之":{"docs":{},"前":{"docs":{},"超":{"docs":{},"时":{"docs":{},"，":{"docs":{},"则":{"docs":{},"会":{"docs":{},"给":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"两":{"docs":{},"个":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"会":{"docs":{},"话":{"docs":{},"在":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"周":{"docs":{},"期":{"docs":{},"内":{"docs":{},"没":{"docs":{},"有":{"docs":{},"被":{"docs":{},"访":{"docs":{},"问":{"docs":{},"，":{"docs":{},"则":{"docs":{},"会":{"docs":{},"超":{"docs":{},"时":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}},"启":{"docs":{},"用":{"docs":{},"了":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"处":{"docs":{},"理":{"docs":{},"，":{"docs":{},"则":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152}},"处":{"docs":{},"理":{"docs":{},"路":{"docs":{},"径":{"docs":{},"以":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"随":{"docs":{},"后":{"docs":{},"调":{"docs":{},"用":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"尝":{"docs":{},"试":{"docs":{},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"个":{"docs":{},"大":{"docs":{},"于":{"docs":{},"最":{"docs":{},"大":{"docs":{},"值":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"，":{"docs":{},"则":{"docs":{},"会":{"docs":{},"得":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"已":{"docs":{},"经":{"docs":{},"有":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"网":{"docs":{},"站":{"docs":{},"包":{"docs":{},"含":{"docs":{},"以":{"docs":{},"下":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"存":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}},"的":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}},"读":{"docs":{},"到":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"0":{"docs":{},"的":{"docs":{},"第":{"5":{"docs":{},"个":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}},"docs":{}}}},"docs":{}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"是":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}},"没":{"docs":{},"有":{"docs":{},"为":{"docs":{},"请":{"docs":{},"求":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"任":{"docs":{},"何":{"docs":{},"路":{"docs":{},"由":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"提":{"docs":{},"供":{"docs":{},"错":{"docs":{},"误":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"用":{"docs":{},"户":{"docs":{},"没":{"docs":{},"有":{"docs":{},"提":{"docs":{},"供":{"docs":{},"，":{"docs":{},"则":{"docs":{},"返":{"docs":{},"回":{"docs":{},"空":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"以":{"docs":{},"第":{"docs":{},"三":{"docs":{},"方":{"docs":{},"应":{"docs":{},"用":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"访":{"docs":{},"问":{"docs":{},"想":{"docs":{},"要":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"，":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{},"可":{"docs":{},"以":{"docs":{},"对":{"docs":{},"这":{"docs":{},"些":{"docs":{},"用":{"docs":{},"户":{"docs":{},"进":{"docs":{},"行":{"docs":{},"授":{"docs":{},"权":{"docs":{},"，":{"docs":{},"任":{"docs":{},"何":{"docs":{},"时":{"docs":{},"候":{"docs":{},"可":{"docs":{},"以":{"docs":{},"根":{"docs":{},"据":{"docs":{},"用":{"docs":{},"户":{"docs":{},"想":{"docs":{},"要":{"docs":{},"都":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"启":{"docs":{},"用":{"docs":{},"或":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"它":{"docs":{},"的":{"docs":{},"访":{"docs":{},"问":{"docs":{},"权":{"docs":{},"限":{"docs":{},"。":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"集":{"docs":{},"群":{"docs":{},"会":{"docs":{},"话":{"docs":{},"存":{"docs":{},"储":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"确":{"docs":{},"保":{"docs":{},"您":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"认":{"docs":{},"证":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"认":{"docs":{},"证":{"docs":{},"信":{"docs":{},"息":{"docs":{},"中":{"docs":{},"用":{"docs":{},"了":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"和":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"字":{"docs":{},"段":{"docs":{},"进":{"docs":{},"行":{"docs":{},"表":{"docs":{},"述":{"docs":{},"：":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"限":{"docs":{},"制":{"docs":{},"请":{"docs":{},"求":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"的":{"docs":{},"大":{"docs":{},"小":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"了":{"docs":{},"解":{"docs":{},"期":{"docs":{},"望":{"docs":{},"的":{"docs":{},"特":{"docs":{},"定":{"docs":{},"认":{"docs":{},"证":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}},"对":{"docs":{},"用":{"docs":{},"户":{"docs":{},"进":{"docs":{},"行":{"docs":{},"认":{"docs":{},"证":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"的":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"你":{"docs":{},"首":{"docs":{},"先":{"docs":{},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"要":{"docs":{},"知":{"docs":{},"道":{"docs":{},"如":{"docs":{},"何":{"docs":{},"创":{"docs":{},"建":{"docs":{},"这":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"可":{"docs":{},"按":{"docs":{},"照":{"docs":{},"文":{"docs":{},"档":{"docs":{},"中":{"docs":{},"的":{"docs":{},"内":{"docs":{},"容":{"docs":{},"实":{"docs":{},"施":{"docs":{},"。":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"要":{"docs":{},"知":{"docs":{},"道":{"docs":{},"如":{"docs":{},"何":{"docs":{},"创":{"docs":{},"建":{"docs":{},"这":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"可":{"docs":{},"按":{"docs":{},"照":{"docs":{},"文":{"docs":{},"档":{"docs":{},"中":{"docs":{},"的":{"docs":{},"内":{"docs":{},"容":{"docs":{},"实":{"docs":{},"施":{"docs":{},"。":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"验":{"docs":{},"证":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"户":{"docs":{},"是":{"docs":{},"否":{"docs":{},"属":{"docs":{},"于":{"docs":{},"特":{"docs":{},"定":{"docs":{},"角":{"docs":{},"色":{"docs":{},"，":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"法":{"docs":{},"给":{"docs":{},"角":{"docs":{},"色":{"docs":{},"带":{"docs":{},"上":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"表":{"docs":{},"示":{"docs":{},"：":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"认":{"docs":{},"证":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"（":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"）":{"docs":{},"法":{"docs":{},"给":{"docs":{},"角":{"docs":{},"色":{"docs":{},"带":{"docs":{},"上":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"表":{"docs":{},"示":{"docs":{},"：":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"拥":{"docs":{},"有":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"许":{"docs":{},"可":{"docs":{},"，":{"docs":{},"则":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"许":{"docs":{},"可":{"docs":{},"信":{"docs":{},"息":{"docs":{},"传":{"docs":{},"递":{"docs":{},"到":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"中":{"docs":{},"：":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}}}}}}},"要":{"docs":{},"将":{"docs":{},"许":{"docs":{},"可":{"docs":{},"信":{"docs":{},"息":{"docs":{},"传":{"docs":{},"递":{"docs":{},"到":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"中":{"docs":{},"：":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"覆":{"docs":{},"盖":{"docs":{},"此":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}},"其":{"docs":{},"中":{"docs":{},"任":{"docs":{},"意":{"docs":{},"一":{"docs":{},"个":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}},"认":{"docs":{},"证":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"完":{"docs":{},"成":{"docs":{},"了":{"docs":{},"授":{"docs":{},"权":{"docs":{},"和":{"docs":{},"认":{"docs":{},"证":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"向":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"认":{"docs":{},"证":{"docs":{},"信":{"docs":{},"息":{"docs":{},"中":{"docs":{},"用":{"docs":{},"了":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"和":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"字":{"docs":{},"段":{"docs":{},"：":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"文":{"docs":{},"档":{"docs":{},"中":{"docs":{},"没":{"docs":{},"有":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"没":{"docs":{},"有":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"被":{"docs":{},"插":{"docs":{},"入":{"docs":{},"的":{"docs":{},"文":{"docs":{},"档":{"docs":{},"包":{"docs":{},"含":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"没":{"docs":{},"有":{"docs":{},"包":{"docs":{},"含":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"了":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"使":{"docs":{},"用":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"实":{"docs":{},"现":{"docs":{},"类":{"docs":{},"（":{"docs":{},"c":{"3":{"docs":{},"p":{"0":{"docs":{},"实":{"docs":{},"现":{"docs":{},"）":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"要":{"docs":{},"把":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"新":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"重":{"docs":{},"启":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}},"希":{"docs":{},"望":{"docs":{},"将":{"docs":{},"消":{"docs":{},"息":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"分":{"docs":{},"区":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"指":{"docs":{},"定":{"docs":{},"分":{"docs":{},"区":{"docs":{},"的":{"docs":{},"标":{"docs":{},"识":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"或":{"docs":{},"者":{"docs":{},"设":{"docs":{},"定":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"组":{"docs":{},"内":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"挂":{"docs":{},"了":{"docs":{},"，":{"docs":{},"k":{"docs":{},"a":{"docs":{},"f":{"docs":{},"k":{"docs":{},"a":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}},"你":{"docs":{},"希":{"docs":{},"望":{"docs":{},"创":{"docs":{},"建":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"认":{"docs":{},"证":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}},"在":{"docs":{},"集":{"docs":{},"群":{"docs":{},"环":{"docs":{},"境":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"你":{"docs":{},"的":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"则":{"docs":{},"需":{"docs":{},"要":{"docs":{},"保":{"docs":{},"证":{"docs":{},"这":{"docs":{},"个":{"docs":{},"用":{"docs":{},"户":{"docs":{},"对":{"docs":{},"象":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"想":{"docs":{},"要":{"docs":{},"重":{"docs":{},"写":{"docs":{},"这":{"docs":{},"些":{"docs":{},"行":{"docs":{},"为":{"docs":{},"，":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"重":{"docs":{},"写":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"y":{"docs":{},"方":{"docs":{},"法":{"docs":{},"去":{"docs":{},"修":{"docs":{},"改":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"策":{"docs":{},"略":{"docs":{},"的":{"docs":{},"设":{"docs":{},"置":{"docs":{},"。":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"上":{"docs":{},"述":{"docs":{},"行":{"docs":{},"为":{"docs":{},"，":{"docs":{},"则":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"y":{"docs":{},"方":{"docs":{},"法":{"docs":{},"设":{"docs":{},"置":{"docs":{},"新":{"docs":{},"的":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"策":{"docs":{},"略":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"提":{"docs":{},"供":{"docs":{},"变":{"docs":{},"更":{"docs":{},"过":{"docs":{},"的":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"策":{"docs":{},"略":{"docs":{},"及":{"docs":{},"配":{"docs":{},"置":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"一":{"docs":{},"般":{"docs":{},"的":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}},"用":{"docs":{},"的":{"docs":{},"是":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"过":{"docs":{},"滤":{"docs":{},"器":{"docs":{},"未":{"docs":{},"设":{"docs":{},"置":{"docs":{},"（":{"docs":{},"为":{"docs":{},"空":{"docs":{},"或":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"）":{"docs":{},"，":{"docs":{},"获":{"docs":{},"取":{"docs":{},"时":{"docs":{},"将":{"docs":{},"获":{"docs":{},"取":{"docs":{},"到":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"。":{"docs":{},"当":{"docs":{},"使":{"docs":{},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{},"形":{"docs":{},"式":{"docs":{},"时":{"docs":{},"，":{"docs":{},"要":{"docs":{},"获":{"docs":{},"取":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"你":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"返":{"docs":{},"回":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"知":{"docs":{},"道":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"、":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"）":{"docs":{},"，":{"docs":{},"整":{"docs":{},"个":{"docs":{},"过":{"docs":{},"程":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"简":{"docs":{},"化":{"docs":{},"为":{"docs":{},"通":{"docs":{},"过":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"直":{"docs":{},"接":{"docs":{},"获":{"docs":{},"取":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"在":{"docs":{},"这":{"docs":{},"里":{"docs":{},"被":{"docs":{},"标":{"docs":{},"记":{"docs":{},"为":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"将":{"docs":{},"自":{"docs":{},"增":{"docs":{},"失":{"docs":{},"败":{"docs":{},"数":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}},"本":{"docs":{},"地":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}},"是":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}},"机":{"docs":{},"器":{"docs":{},"上":{"docs":{},"有":{"docs":{},"多":{"docs":{},"个":{"docs":{},"网":{"docs":{},"络":{"docs":{},"接":{"docs":{},"口":{"docs":{},"（":{"docs":{},"也":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}}}}}}},"上":{"docs":{},"有":{"docs":{},"多":{"docs":{},"个":{"docs":{},"网":{"docs":{},"络":{"docs":{},"接":{"docs":{},"口":{"docs":{},"（":{"docs":{},"也":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"v":{"docs":{},"p":{"docs":{},"n":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"）":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"j":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},"很":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"错":{"docs":{},"误":{"docs":{},"的":{"docs":{},"网":{"docs":{},"络":{"docs":{},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"组":{"docs":{},"播":{"docs":{},"配":{"docs":{},"置":{"docs":{},"不":{"docs":{},"能":{"docs":{},"正":{"docs":{},"常":{"docs":{},"运":{"docs":{},"行":{"docs":{},"，":{"docs":{},"通":{"docs":{},"常":{"docs":{},"有":{"docs":{},"以":{"docs":{},"下":{"docs":{},"原":{"docs":{},"因":{"docs":{},"：":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}},"多":{"docs":{},"播":{"docs":{},"配":{"docs":{},"置":{"docs":{},"不":{"docs":{},"能":{"docs":{},"正":{"docs":{},"常":{"docs":{},"运":{"docs":{},"行":{"docs":{},"，":{"docs":{},"通":{"docs":{},"常":{"docs":{},"有":{"docs":{},"以":{"docs":{},"下":{"docs":{},"原":{"docs":{},"因":{"docs":{},"：":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}},"系":{"docs":{},"统":{"docs":{},"变":{"docs":{},"量":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}},"需":{"docs":{},"要":{"docs":{},"覆":{"docs":{},"盖":{"docs":{},"此":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}},"生":{"docs":{},"成":{"docs":{},"不":{"docs":{},"同":{"docs":{},"语":{"docs":{},"言":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"添":{"docs":{},"加":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"语":{"docs":{},"言":{"docs":{},"支":{"docs":{},"持":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"实":{"docs":{},"现":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"返":{"docs":{},"回":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"向":{"docs":{},"e":{"docs":{},"v":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"异":{"docs":{},"步":{"docs":{},"结":{"docs":{},"果":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}},"s":{"docs":{},"l":{"docs":{},"f":{"4":{"docs":{},"j":{"docs":{},"可":{"docs":{},"见":{"docs":{},"，":{"docs":{},"则":{"docs":{},"优":{"docs":{},"先":{"docs":{},"使":{"docs":{},"用":{"docs":{},"该":{"docs":{},"库":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"docs":{}}}},"上":{"docs":{},"所":{"docs":{},"述":{"docs":{},"，":{"docs":{},"用":{"docs":{},"户":{"docs":{},"数":{"docs":{},"据":{"docs":{},"报":{"docs":{},"协":{"docs":{},"议":{"docs":{},"（":{"docs":{},"u":{"docs":{},"d":{"docs":{},"p":{"docs":{},"）":{"docs":{},"将":{"docs":{},"数":{"docs":{},"据":{"docs":{},"分":{"docs":{},"组":{"docs":{},"发":{"docs":{},"送":{"docs":{},"给":{"docs":{},"远":{"docs":{},"程":{"docs":{},"对":{"docs":{},"等":{"docs":{},"体":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"以":{"docs":{},"不":{"docs":{},"持":{"docs":{},"续":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"传":{"docs":{},"送":{"docs":{},"到":{"docs":{},"它":{"docs":{},"们":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"下":{"docs":{},"所":{"docs":{},"示":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"：":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}},"之":{"docs":{},"前":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"，":{"docs":{},"您":{"docs":{},"不":{"docs":{},"能":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"何":{"docs":{},"定":{"docs":{},"位":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"（":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"、":{"docs":{},"e":{"docs":{},"v":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"前":{"docs":{},"边":{"docs":{},"部":{"docs":{},"分":{"docs":{},"所":{"docs":{},"述":{"docs":{},"，":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"所":{"docs":{},"述":{"docs":{},"，":{"docs":{},"访":{"docs":{},"问":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"于":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"本":{"docs":{},"身":{"docs":{},"。":{"docs":{},"要":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}}}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"坚":{"docs":{},"持":{"docs":{},"使":{"docs":{},"用":{"docs":{},"标":{"docs":{},"准":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"已":{"docs":{},"在":{"docs":{},"程":{"docs":{},"序":{"docs":{},"中":{"docs":{},"创":{"docs":{},"建":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}},"知":{"docs":{},"流":{"docs":{},"的":{"docs":{},"大":{"docs":{},"小":{"docs":{},"，":{"docs":{},"可":{"docs":{},"在":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"协":{"docs":{},"议":{"docs":{},"头":{"docs":{},"中":{"docs":{},"设":{"docs":{},"置":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}},"要":{"docs":{},"发":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"，":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"并":{"docs":{},"在":{"docs":{},"最":{"docs":{},"后":{"docs":{},"加":{"docs":{},"上":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}},"简":{"docs":{},"易":{"docs":{},"教":{"docs":{},"程":{"docs":{"start/SimpleStart.html":{"ref":"start/SimpleStart.html","tf":10}}}}},"介":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}},"(":{"1":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}},"2":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},".":{"6":{"docs":{},".":{"0":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"2":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"docs":{}}},"docs":{}}},"3":{"docs":{},".":{"1":{"docs":{},".":{"0":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}},"4":{"docs":{},".":{"0":{"docs":{},"+":{"docs":{},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677}}}}},"docs":{}}},"docs":{}},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"4":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},".":{"0":{"docs":{},".":{"3":{"1":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413}}}}}}}}}},"docs":{}},"docs":{}}},"docs":{}}},"5":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"6":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"r":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"e":{"docs":{},"s":{"2":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}}}}}}}},"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.006611570247933884}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0019507663725034836},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.01493550577053632},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.015047879616963064},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0064794816414686825},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.016666666666666666},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.02631578947368421},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.014778325123152709},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.02040816326530612},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.005758157389635317},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.006160164271047228},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.008403361344537815}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}}}}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"1":{"0":{"0":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"m":{"docs":{},"y":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}},"c":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"/":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"!":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},".":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"9":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0035769034236075624}},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0020436600092893636},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.019553072625698324},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.005964214711729622},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.008175779253960144}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"2":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}},",":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"1":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}},"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}},"d":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"l":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"m":{"docs":{},"x":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"p":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.004103967168262654}}}}}}},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"x":{"docs":{},"m":{"docs":{},"l":{"docs":{},"文":{"docs":{},"件":{"docs":{},"中":{"docs":{},")":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"v":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"m":{"docs":{},"y":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},"p":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},".":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},":":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}},"在":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.004975124378109453},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.014625228519195612}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}}}}},"代":{"docs":{},"表":{"docs":{},"一":{"docs":{},"直":{"docs":{},"保":{"docs":{},"留":{"docs":{},")":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}},"'":{"docs":{},"j":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"'":{"docs":{},")":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}},"o":{"docs":{},"e":{"docs":{},"'":{"docs":{},")":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}},"?":{"docs":{},")":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}},"=":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}},"此":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},")":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}},")":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.006423982869379015},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"(":{"docs":{},"m":{"docs":{},"s":{"docs":{},"g":{"docs":{},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"v":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"v":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}},";":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.004282655246252677},"core/Core.html":{"ref":"core/Core.html","tf":0.0026010218300046447},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.013850415512465374},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.005620848237097598},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.008403361344537815},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.006398537477148081}}},")":{"docs":{},";":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}}}},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"在":{"docs":{},"回":{"docs":{},"调":{"docs":{},"中":{"docs":{},"，":{"docs":{},"执":{"docs":{},"行":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}},"应":{"docs":{},"该":{"docs":{},"在":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}},"以":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"上":{"docs":{},"是":{"docs":{},"未":{"docs":{},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"时":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"以":{"docs":{},"下":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"改":{"docs":{},"造":{"docs":{},"后":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"就":{"docs":{},"是":{"docs":{},"如":{"docs":{},"何":{"docs":{},"在":{"docs":{},"您":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"下":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"两":{"docs":{},"种":{"docs":{},"写":{"docs":{},"法":{"docs":{},"是":{"docs":{},"等":{"docs":{},"效":{"docs":{},"的":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"设":{"docs":{},"置":{"docs":{},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"获":{"docs":{},"取":{"docs":{},"它":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"查":{"docs":{},"询":{"docs":{},"和":{"docs":{},"添":{"docs":{},"加":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"路":{"docs":{},"由":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"些":{"docs":{},"事":{"docs":{},"件":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"创":{"docs":{},"建":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}},"二":{"docs":{},"进":{"docs":{},"制":{"docs":{},"帧":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"阻":{"docs":{},"塞":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"隔":{"docs":{},"离":{"docs":{},"组":{"docs":{},"隔":{"docs":{},"离":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"文":{"docs":{},"件":{"docs":{},"异":{"docs":{},"步":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}},":":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}},"操":{"docs":{},"作":{"docs":{},"会":{"docs":{},"话":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"应":{"docs":{},"用":{"docs":{},"，":{"docs":{},"该":{"docs":{},"应":{"docs":{},"用":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"部":{"docs":{},"分":{"docs":{},"需":{"docs":{},"要":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"权":{"docs":{},"限":{"docs":{},"。":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"权":{"docs":{},"限":{"docs":{},"的":{"docs":{},"含":{"docs":{},"义":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"您":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"可":{"docs":{},"供":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"路":{"docs":{},"径":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"都":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"便":{"docs":{},"更":{"docs":{},"轻":{"docs":{},"松":{"docs":{},"地":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"及":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"其":{"docs":{},"实":{"docs":{},"与":{"docs":{},"原":{"docs":{},"生":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}},"分":{"docs":{},"区":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"消":{"docs":{},"息":{"docs":{},"会":{"docs":{},"以":{"docs":{},"轮":{"docs":{},"询":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}},"信":{"docs":{},"息":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"配":{"docs":{},"的":{"docs":{},"偏":{"docs":{},"移":{"docs":{},"量":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{},"分":{"docs":{},"区":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"类":{"docs":{},"似":{"docs":{},"于":{"docs":{},"向":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"将":{"docs":{},"消":{"docs":{},"息":{"docs":{},"以":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}},"应":{"docs":{},"的":{"docs":{},"值":{"docs":{},"而":{"docs":{},"省":{"docs":{},"略":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"后":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"再":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"外":{"docs":{},"）":{"docs":{},"它":{"docs":{},"们":{"docs":{},"总":{"docs":{},"是":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"编":{"docs":{},"码":{"docs":{},"方":{"docs":{},"式":{"docs":{},"写":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"满":{"docs":{},"足":{"docs":{},"任":{"docs":{},"何":{"docs":{},"希":{"docs":{},"望":{"docs":{},"升":{"docs":{},"级":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"后":{"docs":{},"续":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"现":{"docs":{},"有":{"docs":{},"的":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}},"会":{"docs":{},"以":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}},"抛":{"docs":{},"出":{"docs":{},"一":{"docs":{},"些":{"docs":{},"异":{"docs":{},"常":{"docs":{},"（":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"以":{"docs":{},"下":{"docs":{},"代":{"docs":{},"码":{"docs":{},"只":{"docs":{},"是":{"docs":{},"同":{"docs":{},"步":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"，":{"docs":{},"和":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}},"从":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"读":{"docs":{},"取":{"docs":{},"它":{"docs":{},"，":{"docs":{},"将":{"docs":{},"其":{"docs":{},"复":{"docs":{},"制":{"docs":{},"到":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"目":{"docs":{},"录":{"docs":{},"并":{"docs":{},"从":{"docs":{},"中":{"docs":{},"提":{"docs":{},"供":{"docs":{},"。":{"docs":{},"不":{"docs":{},"要":{"docs":{},"在":{"docs":{},"生":{"docs":{},"产":{"docs":{},"环":{"docs":{},"境":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"设":{"docs":{},"置":{"docs":{},"，":{"docs":{},"它":{"docs":{},"很":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"影":{"docs":{},"响":{"docs":{},"性":{"docs":{},"能":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"轮":{"docs":{},"询":{"docs":{},"策":{"docs":{},"略":{"docs":{},"来":{"docs":{},"管":{"docs":{},"理":{"docs":{},"请":{"docs":{},"求":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"当":{"docs":{},"前":{"docs":{},"工":{"docs":{},"作":{"docs":{},"目":{"docs":{},"录":{"docs":{},"的":{"docs":{},"子":{"docs":{},"目":{"docs":{},"录":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"像":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"函":{"docs":{},"数":{"docs":{},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"写":{"docs":{},"入":{"docs":{},"一":{"docs":{},"定":{"docs":{},"量":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"创":{"docs":{},"建":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"将":{"docs":{},"事":{"docs":{},"件":{"docs":{},"传":{"docs":{},"给":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"文":{"docs":{},"件":{"docs":{},"复":{"docs":{},"制":{"docs":{},"到":{"docs":{},"其":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"目":{"docs":{},"录":{"docs":{},"中":{"docs":{},"，":{"docs":{},"并":{"docs":{},"随":{"docs":{},"后":{"docs":{},"读":{"docs":{},"取":{"docs":{},"该":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"行":{"docs":{},"为":{"docs":{},"也":{"docs":{},"可":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"状":{"docs":{},"态":{"docs":{},"消":{"docs":{},"息":{"docs":{},"替":{"docs":{},"换":{"docs":{},"为":{"docs":{},"状":{"docs":{},"态":{"docs":{},"码":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"资":{"docs":{},"源":{"docs":{},"的":{"docs":{},"最":{"docs":{},"后":{"docs":{},"修":{"docs":{},"改":{"docs":{},"日":{"docs":{},"期":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"在":{"docs":{},"内":{"docs":{},"存":{"docs":{},"里":{"docs":{},"，":{"docs":{},"以":{"docs":{},"此":{"docs":{},"来":{"docs":{},"避":{"docs":{},"免":{"docs":{},"频":{"docs":{},"繁":{"docs":{},"地":{"docs":{},"访":{"docs":{},"问":{"docs":{},"取":{"docs":{},"磁":{"docs":{},"盘":{"docs":{},"来":{"docs":{},"检":{"docs":{},"查":{"docs":{},"修":{"docs":{},"改":{"docs":{},"时":{"docs":{},"间":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"循":{"docs":{},"环":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"处":{"docs":{},"理":{"docs":{},"所":{"docs":{},"有":{"docs":{},"到":{"docs":{},"达":{"docs":{},"的":{"docs":{},"事":{"docs":{},"件":{"docs":{},"并":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"自":{"docs":{},"动":{"docs":{},"在":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"撤":{"docs":{},"销":{"docs":{},"任":{"docs":{},"何":{"docs":{},"子":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"设":{"docs":{},"置":{"docs":{},"响":{"docs":{},"应":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"关":{"docs":{},"闭":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"被":{"docs":{},"标":{"docs":{},"记":{"docs":{},"为":{"docs":{},"失":{"docs":{},"败":{"docs":{},"。":{"docs":{},"当":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"都":{"docs":{},"成":{"docs":{},"功":{"docs":{},"时":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"销":{"docs":{},"毁":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"传":{"docs":{},"递":{"docs":{},"到":{"docs":{},"失":{"docs":{},"败":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"里":{"docs":{},"，":{"docs":{},"失":{"docs":{},"败":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"获":{"docs":{},"取":{"docs":{},"到":{"docs":{},"的":{"docs":{},"错":{"docs":{},"误":{"docs":{},"或":{"docs":{},"错":{"docs":{},"误":{"docs":{},"编":{"docs":{},"码":{"docs":{},"来":{"docs":{},"构":{"docs":{},"造":{"docs":{},"失":{"docs":{},"败":{"docs":{},"的":{"docs":{},"响":{"docs":{},"应":{"docs":{},"内":{"docs":{},"容":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"其":{"docs":{},"被":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"一":{"docs":{},"步":{"docs":{},"一":{"docs":{},"步":{"docs":{},"检":{"docs":{},"查":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"直":{"docs":{},"被":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"住":{"docs":{},"，":{"docs":{},"而":{"docs":{},"内":{"docs":{},"核":{"docs":{},"线":{"docs":{},"程":{"docs":{},"不":{"docs":{},"会":{"docs":{},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}},"匹":{"docs":{},"配":{"docs":{},"任":{"docs":{},"何":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"所":{"docs":{},"有":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"到":{"docs":{},"达":{"docs":{},"这":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"个":{"docs":{},"基":{"docs":{},"本":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"变":{"docs":{},"得":{"docs":{},"很":{"docs":{},"麻":{"docs":{},"烦":{"docs":{},"。":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},"响":{"docs":{},"应":{"docs":{},"里":{"docs":{},"设":{"docs":{},"置":{"docs":{},"这":{"docs":{},"些":{"docs":{},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{},"：":{"docs":{},"c":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"每":{"docs":{},"次":{"docs":{},"从":{"docs":{},"某":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"查":{"docs":{},"找":{"docs":{},"模":{"docs":{},"板":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"检":{"docs":{},"查":{"docs":{},"每":{"docs":{},"一":{"docs":{},"条":{"docs":{},"输":{"docs":{},"入":{"docs":{},"许":{"docs":{},"可":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"存":{"docs":{},"在":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"，":{"docs":{},"则":{"docs":{},"消":{"docs":{},"息":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"出":{"docs":{},"许":{"docs":{},"可":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"存":{"docs":{},"在":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"，":{"docs":{},"则":{"docs":{},"消":{"docs":{},"息":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}},"每":{"docs":{},"隔":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"给":{"docs":{},"于":{"docs":{},"警":{"docs":{},"告":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"话":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"中":{"docs":{},"的":{"docs":{},"键":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"。":{"docs":{},"本":{"docs":{},"地":{"docs":{},"会":{"docs":{},"话":{"docs":{},"存":{"docs":{},"储":{"docs":{},"的":{"docs":{},"值":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"型":{"docs":{},"；":{"docs":{},"集":{"docs":{},"群":{"docs":{},"会":{"docs":{},"话":{"docs":{},"存":{"docs":{},"储":{"docs":{},"的":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"基":{"docs":{},"本":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"创":{"docs":{},"建":{"docs":{},"会":{"docs":{},"话":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"自":{"docs":{},"动":{"docs":{},"从":{"docs":{},"会":{"docs":{},"话":{"docs":{},"存":{"docs":{},"储":{"docs":{},"中":{"docs":{},"查":{"docs":{},"找":{"docs":{},"会":{"docs":{},"话":{"docs":{},"（":{"docs":{},"如":{"docs":{},"果":{"docs":{},"没":{"docs":{},"有":{"docs":{},"则":{"docs":{},"创":{"docs":{},"建":{"docs":{},"）":{"docs":{},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"执":{"docs":{},"行":{"docs":{},"之":{"docs":{},"前":{"docs":{},"设":{"docs":{},"置":{"docs":{},"在":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"中":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"存":{"docs":{},"储":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"持":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"伪":{"docs":{},"随":{"docs":{},"机":{"docs":{},"数":{"docs":{},"生":{"docs":{},"成":{"docs":{},"器":{"docs":{},"（":{"docs":{},"p":{"docs":{},"r":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"用":{"docs":{},"于":{"docs":{},"安":{"docs":{},"全":{"docs":{},"地":{"docs":{},"生":{"docs":{},"成":{"docs":{},"会":{"docs":{},"话":{"docs":{},"标":{"docs":{},"示":{"docs":{},"。":{"docs":{},"p":{"docs":{},"r":{"docs":{},"n":{"docs":{},"g":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"永":{"docs":{},"远":{"docs":{},"转":{"docs":{},"发":{"docs":{},"到":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"维":{"docs":{},"持":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"超":{"docs":{},"时":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"返":{"docs":{},"回":{"docs":{},"列":{"docs":{},"表":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"能":{"docs":{},"够":{"docs":{},"理":{"docs":{},"解":{"docs":{},"的":{"docs":{},"排":{"docs":{},"序":{"docs":{},"好":{"docs":{},"的":{"docs":{},"语":{"docs":{},"言":{"docs":{},"列":{"docs":{},"表":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"舍":{"docs":{},"弃":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"项":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"您":{"docs":{},"会":{"docs":{},"看":{"docs":{},"到":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}},"定":{"docs":{},"期":{"docs":{},"地":{"docs":{},"从":{"docs":{},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"处":{"docs":{},"读":{"docs":{},"取":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"读":{"docs":{},"取":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"和":{"docs":{},"当":{"docs":{},"前":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"不":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"应":{"docs":{},"用":{"docs":{},"就":{"docs":{},"会":{"docs":{},"重":{"docs":{},"新":{"docs":{},"进":{"docs":{},"行":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"刷":{"docs":{},"新":{"docs":{},"时":{"docs":{},"间":{"docs":{},"是":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"按":{"docs":{},"照":{"docs":{},"以":{"docs":{},"下":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"进":{"docs":{},"行":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}},"传":{"docs":{},"入":{"docs":{},"到":{"docs":{},"异":{"docs":{},"步":{"docs":{},"方":{"docs":{},"法":{"docs":{},"里":{"docs":{},"。":{"docs":{},"该":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"是":{"docs":{},"提":{"docs":{},"供":{"docs":{},"给":{"docs":{},"异":{"docs":{},"步":{"docs":{},"调":{"docs":{},"用":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"配":{"docs":{},"置":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"递":{"docs":{},"一":{"docs":{},"个":{"docs":{},"事":{"docs":{},"件":{"docs":{},"给":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"或":{"docs":{},"者":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"给":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}},"此":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"则":{"docs":{},"通":{"docs":{},"知":{"docs":{},"将":{"docs":{},"被":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"是":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"值":{"docs":{},"得":{"docs":{},"注":{"docs":{},"意":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"示":{"docs":{},"范":{"docs":{},"代":{"docs":{},"码":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"抛":{"docs":{},"出":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"当":{"docs":{},"操":{"docs":{},"作":{"docs":{},"失":{"docs":{},"败":{"docs":{},"时":{"docs":{},"，":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},"方":{"docs":{},"法":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"，":{"docs":{},"此":{"docs":{},"时":{"docs":{},"调":{"docs":{},"用":{"docs":{},".":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},"方":{"docs":{},"法":{"docs":{},"会":{"docs":{},"抛":{"docs":{},"出":{"docs":{},"空":{"docs":{},"指":{"docs":{},"针":{"docs":{},"异":{"docs":{},"常":{"docs":{},"，":{"docs":{},"在":{"docs":{},"生":{"docs":{},"产":{"docs":{},"环":{"docs":{},"境":{"docs":{},"中":{"docs":{},"正":{"docs":{},"确":{"docs":{},"写":{"docs":{},"法":{"docs":{},"应":{"docs":{},"该":{"docs":{},"是":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"或":{"docs":{},"者":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"权":{"docs":{},"重":{"docs":{},"。":{"docs":{},"q":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"确":{"docs":{},"定":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"（":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"传":{"docs":{},"入":{"docs":{},"存":{"docs":{},"储":{"docs":{},"过":{"docs":{},"程":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}},"时":{"docs":{},"，":{"docs":{},"有":{"docs":{},"其":{"docs":{},"他":{"docs":{},"一":{"docs":{},"些":{"docs":{},"更":{"docs":{},"简":{"docs":{},"洁":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"。":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}},"不":{"docs":{},"为":{"docs":{},"空":{"docs":{},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"覆":{"docs":{},"盖":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}},"假":{"docs":{},"设":{"docs":{},"我":{"docs":{},"们":{"docs":{},"拿":{"docs":{},"到":{"docs":{},"两":{"docs":{},"个":{"docs":{},"数":{"docs":{},"万":{"docs":{},"个":{"docs":{},"节":{"docs":{},"点":{"docs":{},"的":{"docs":{},"链":{"docs":{},"表":{"docs":{},"（":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"）":{"docs":{},"，":{"docs":{},"要":{"docs":{},"求":{"docs":{},"删":{"docs":{},"除":{"docs":{},"两":{"docs":{},"个":{"docs":{},"链":{"docs":{},"表":{"docs":{},"的":{"docs":{},"交":{"docs":{},"集":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"在":{"docs":{},"没":{"docs":{},"有":{"docs":{},"任":{"docs":{},"何":{"docs":{},"算":{"docs":{},"法":{"docs":{},"优":{"docs":{},"化":{"docs":{},"的":{"docs":{},"前":{"docs":{},"提":{"docs":{},"下":{"docs":{},"，":{"docs":{},"该":{"docs":{},"操":{"docs":{},"作":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"度":{"docs":{},"是":{"docs":{},"o":{"docs":{},"(":{"docs":{},"n":{"docs":{},"^":{"2":{"docs":{},")":{"docs":{},"，":{"docs":{},"又":{"docs":{},"因":{"docs":{},"为":{"docs":{},"内":{"docs":{},"存":{"docs":{},"中":{"docs":{},"该":{"docs":{},"链":{"docs":{},"表":{"docs":{},"节":{"docs":{},"点":{"docs":{},"数":{"docs":{},"庞":{"docs":{},"大":{"docs":{},"，":{"docs":{},"多":{"docs":{},"达":{"docs":{},"数":{"docs":{},"万":{"docs":{},"个":{"docs":{},"节":{"docs":{},"点":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"如":{"docs":{},"果":{"docs":{},"在":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"中":{"docs":{},"执":{"docs":{},"行":{"docs":{},"该":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"将":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"使":{"docs":{},"得":{"docs":{},"执":{"docs":{},"行":{"docs":{},"时":{"docs":{},"间":{"docs":{},"超":{"docs":{},"长":{"docs":{},"，":{"docs":{},"此":{"docs":{},"时":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"这":{"docs":{},"部":{"docs":{},"分":{"docs":{},"代":{"docs":{},"码":{"docs":{},"交":{"docs":{},"由":{"docs":{},"其":{"docs":{},"它":{"docs":{},"线":{"docs":{},"程":{"docs":{},"予":{"docs":{},"以":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"除":{"docs":{},"了":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"线":{"docs":{},"程":{"docs":{},"池":{"docs":{},"以":{"docs":{},"外":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"池":{"docs":{},"，":{"docs":{},"名":{"docs":{},"曰":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"线":{"docs":{},"程":{"docs":{},"池":{"docs":{},"。":{"docs":{},"此":{"docs":{},"时":{"docs":{},"就":{"docs":{},"需":{"docs":{},"要":{"docs":{},"用":{"docs":{},"户":{"docs":{},"自":{"docs":{},"行":{"docs":{},"将":{"docs":{},"该":{"docs":{},"部":{"docs":{},"分":{"docs":{},"代":{"docs":{},"码":{"docs":{},"包":{"docs":{},"装":{"docs":{},"成":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"线":{"docs":{},"程":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"并":{"docs":{},"交":{"docs":{},"给":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"线":{"docs":{},"程":{"docs":{},"予":{"docs":{},"以":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"成":{"docs":{},"之":{"docs":{},"后":{"docs":{},"再":{"docs":{},"由":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"线":{"docs":{},"程":{"docs":{},"执":{"docs":{},"行":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"处":{"docs":{},"理":{"docs":{},"其":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{},"注":{"docs":{},"意":{"docs":{},"：":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"将":{"docs":{},"代":{"docs":{},"码":{"docs":{},"交":{"docs":{},"给":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"线":{"docs":{},"程":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"有":{"docs":{},"两":{"docs":{},"种":{"docs":{},"，":{"docs":{},"一":{"docs":{},"种":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"函":{"docs":{},"数":{"docs":{},"包":{"docs":{},"装":{"docs":{},"，":{"docs":{},"另":{"docs":{},"外":{"docs":{},"一":{"docs":{},"种":{"docs":{},"是":{"docs":{},"写":{"docs":{},"入":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"到":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"直":{"docs":{},"接":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"目":{"docs":{},"前":{"docs":{},"为":{"docs":{},"止":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"上":{"docs":{},"述":{"docs":{},"的":{"docs":{},"路":{"docs":{},"由":{"docs":{},"机":{"docs":{},"制":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"地":{"docs":{},"处":{"docs":{},"理":{"docs":{},"您":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"但":{"docs":{},"某":{"docs":{},"些":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"您":{"docs":{},"可":{"docs":{},"能":{"docs":{},"需":{"docs":{},"要":{"docs":{},"回":{"docs":{},"退":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"是":{"docs":{},"动":{"docs":{},"态":{"docs":{},"的":{"docs":{},"，":{"docs":{},"路":{"docs":{},"由":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"暴":{"docs":{},"露":{"docs":{},"出":{"docs":{},"任":{"docs":{},"何":{"docs":{},"关":{"docs":{},"于":{"docs":{},"前":{"docs":{},"一":{"docs":{},"个":{"docs":{},"或":{"docs":{},"后":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"是":{"docs":{},"在":{"docs":{},"当":{"docs":{},"前":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"送":{"1":{"0":{"0":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}},"docs":{}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"消":{"docs":{},"息":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243}},"给":{"docs":{},"接":{"docs":{},"收":{"docs":{},"者":{"docs":{},"并":{"docs":{},"等":{"docs":{},"待":{"docs":{},"回":{"docs":{},"复":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},"到":{"docs":{},"某":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"到":{"docs":{},"多":{"docs":{},"播":{"docs":{},"地":{"docs":{},"址":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"请":{"docs":{},"求":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"请":{"docs":{},"求":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"响":{"docs":{},"应":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"帧":{"docs":{},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"次":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"并":{"docs":{},"处":{"docs":{},"理":{"docs":{},"其":{"docs":{},"响":{"docs":{},"应":{"docs":{},"，":{"docs":{},"r":{"docs":{},"x":{"docs":{},"通":{"docs":{},"常":{"docs":{},"通":{"docs":{},"过":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"触":{"docs":{},"发":{"docs":{},"各":{"docs":{},"种":{"docs":{},"响":{"docs":{},"应":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}}}},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"）":{"docs":{},"，":{"docs":{},"当":{"docs":{},"消":{"docs":{},"息":{"docs":{},"到":{"docs":{},"达":{"docs":{},"时":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"多":{"docs":{},"播":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"失":{"docs":{},"败":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"包":{"docs":{},"很":{"docs":{},"容":{"docs":{},"易":{"docs":{},"，":{"docs":{},"如":{"docs":{},"下":{"docs":{},"所":{"docs":{},"示":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"报":{"docs":{},"包":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"文":{"docs":{},"件":{"docs":{},"或":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"段":{"docs":{},"时":{"docs":{},"间":{"docs":{},"后":{"docs":{},"才":{"docs":{},"能":{"docs":{},"完":{"docs":{},"成":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"要":{"docs":{},"在":{"docs":{},"文":{"docs":{},"件":{"docs":{},"写":{"docs":{},"入":{"docs":{},"时":{"docs":{},"收":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"由":{"docs":{},"单":{"docs":{},"个":{"docs":{},"最":{"docs":{},"终":{"docs":{},"二":{"docs":{},"进":{"docs":{},"制":{"docs":{},"帧":{"docs":{},"组":{"docs":{},"成":{"docs":{},"的":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"消":{"docs":{},"息":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"者":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"请":{"docs":{},"求":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"内":{"docs":{},"容":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"通":{"docs":{},"用":{"docs":{},"请":{"docs":{},"求":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"缓":{"docs":{},"冲":{"docs":{},"区":{"docs":{},"大":{"docs":{},"小":{"docs":{},"（":{"docs":{},"s":{"docs":{},"o":{"docs":{},"_":{"docs":{},"s":{"docs":{},"n":{"docs":{},"d":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"）":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}},"出":{"docs":{},"请":{"docs":{},"求":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"回":{"docs":{},"响":{"docs":{},"应":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"布":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}},"/":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"模":{"docs":{},"式":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"消":{"docs":{},"息":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"消":{"docs":{},"息":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"很":{"docs":{},"简":{"docs":{},"单":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"的":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}},"：":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}},"源":{"docs":{},"服":{"docs":{},"务":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"载":{"docs":{},"体":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}},"／":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"模":{"docs":{},"式":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"队":{"docs":{},"列":{"docs":{},"相":{"docs":{},"关":{"docs":{},"命":{"docs":{},"令":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}},"者":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"来":{"docs":{},"自":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"一":{"docs":{},"个":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"服":{"docs":{},"务":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"记":{"docs":{},"录":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"这":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}},"条":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}},"后":{"docs":{},"，":{"docs":{},"更":{"docs":{},"新":{"docs":{},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{},"文":{"docs":{},"档":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"。":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}}},"生":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"异":{"docs":{},"常":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"这":{"docs":{},"些":{"docs":{},"情":{"docs":{},"况":{"docs":{},"时":{"docs":{},"，":{"docs":{},"应":{"docs":{},"答":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"将":{"docs":{},"会":{"docs":{},"以":{"docs":{},"这":{"docs":{},"些":{"docs":{},"失":{"docs":{},"败":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"行":{"docs":{},"版":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"安":{"docs":{},"装":{"docs":{},"目":{"docs":{},"录":{"docs":{},"中":{"docs":{},"的":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"环":{"docs":{},"境":{"docs":{},"变":{"docs":{},"量":{"docs":{},"中":{"docs":{},"，":{"docs":{},"还":{"docs":{},"要":{"docs":{},"确":{"docs":{},"保":{"docs":{},"您":{"docs":{},"的":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"上":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"起":{"docs":{},"了":{"docs":{},"重":{"docs":{},"载":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"则":{"docs":{},"会":{"docs":{},"因":{"docs":{},"为":{"docs":{},"验":{"docs":{},"证":{"docs":{},"错":{"docs":{},"误":{"docs":{},"而":{"docs":{},"请":{"docs":{},"求":{"docs":{},"失":{"docs":{},"败":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"现":{"docs":{},"并":{"docs":{},"管":{"docs":{},"理":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"的":{"docs":{},"节":{"docs":{},"点":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}},"器":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588}}}}},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"使":{"docs":{},"代":{"docs":{},"码":{"docs":{},"更":{"docs":{},"为":{"docs":{},"简":{"docs":{},"洁":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}},"来":{"docs":{},"访":{"docs":{},"问":{"docs":{},"路":{"docs":{},"由":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603}}}}}}}}}}},"换":{"docs":{},"为":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}},"可":{"docs":{},"以":{"docs":{},"看":{"docs":{},"到":{"docs":{},"此":{"docs":{},"时":{"docs":{},"为":{"docs":{},"了":{"docs":{},"保":{"docs":{},"证":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"结":{"docs":{},"构":{"docs":{},"，":{"docs":{},"产":{"docs":{},"生":{"docs":{},"了":{"docs":{},"两":{"docs":{},"层":{"docs":{},"缩":{"docs":{},"进":{"docs":{},"，":{"docs":{},"回":{"docs":{},"调":{"docs":{},"金":{"docs":{},"字":{"docs":{},"塔":{"docs":{},"开":{"docs":{},"始":{"docs":{},"形":{"docs":{},"成":{"docs":{},"，":{"docs":{},"多":{"docs":{},"次":{"docs":{},"缩":{"docs":{},"进":{"docs":{},"之":{"docs":{},"后":{"docs":{},"便":{"docs":{},"会":{"docs":{},"出":{"docs":{},"现":{"docs":{},"所":{"docs":{},"谓":{"docs":{},"的":{"docs":{},"回":{"docs":{},"调":{"docs":{},"地":{"docs":{},"狱":{"docs":{},"，":{"docs":{},"这":{"docs":{},"便":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"开":{"docs":{},"发":{"docs":{},"中":{"docs":{},"为":{"docs":{},"了":{"docs":{},"保":{"docs":{},"证":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"所":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"遇":{"docs":{},"到":{"docs":{},"的":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"以":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"解":{"docs":{},"决":{"docs":{},"代":{"docs":{},"码":{"docs":{},"过":{"docs":{},"多":{"docs":{},"缩":{"docs":{},"进":{"docs":{},"的":{"docs":{},"问":{"docs":{},"题":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"原":{"docs":{},"先":{"docs":{},"的":{"docs":{},"两":{"docs":{},"层":{"docs":{},"缩":{"docs":{},"进":{"docs":{},"被":{"docs":{},"抽":{"docs":{},"取":{"docs":{},"出":{"docs":{},"来":{"docs":{},"，":{"docs":{},"变":{"docs":{},"成":{"docs":{},"了":{"docs":{},"最":{"docs":{},"多":{"docs":{},"单":{"docs":{},"层":{"docs":{},"的":{"docs":{},"缩":{"docs":{},"进":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"使":{"docs":{},"得":{"docs":{},"代":{"docs":{},"码":{"docs":{},"可":{"docs":{},"读":{"docs":{},"性":{"docs":{},"更":{"docs":{},"强":{"docs":{},"，":{"docs":{},"更":{"docs":{},"加":{"docs":{},"美":{"docs":{},"观":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"为":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"用":{"docs":{},"途":{"docs":{},"创":{"docs":{},"建":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"池":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"您":{"docs":{},"处":{"docs":{},"理":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"。":{"docs":{},"在":{"docs":{},"与":{"docs":{},"现":{"docs":{},"有":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"主":{"docs":{},"机":{"docs":{},"和":{"docs":{},"端":{"docs":{},"口":{"docs":{},"上":{"docs":{},"部":{"docs":{},"署":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"时":{"docs":{},"，":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"创":{"docs":{},"建":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"主":{"docs":{},"机":{"docs":{},"/":{"docs":{},"端":{"docs":{},"口":{"docs":{},"上":{"docs":{},"监":{"docs":{},"听":{"docs":{},"的":{"docs":{},"新":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"，":{"docs":{},"它":{"docs":{},"只":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"一":{"docs":{},"次":{"docs":{},"到":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"，":{"docs":{},"当":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"按":{"docs":{},"照":{"docs":{},"轮":{"docs":{},"询":{"docs":{},"策":{"docs":{},"略":{"docs":{},"调":{"docs":{},"用":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"处":{"docs":{},"理":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"从":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"或":{"docs":{},"字":{"docs":{},"节":{"docs":{},"数":{"docs":{},"组":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"直":{"docs":{},"接":{"docs":{},"创":{"docs":{},"建":{"docs":{},"空":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"静":{"docs":{},"态":{"docs":{},"方":{"docs":{},"法":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"默":{"docs":{},"认":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"创":{"docs":{},"建":{"docs":{},"空":{"docs":{},"的":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"事":{"docs":{},"件":{"docs":{},"到":{"docs":{},"达":{"docs":{},"时":{"docs":{},"快":{"docs":{},"速":{"docs":{},"地":{"docs":{},"分":{"docs":{},"发":{"docs":{},"到":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"会":{"docs":{},"话":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"时":{"docs":{},"配":{"docs":{},"置":{"docs":{},"超":{"docs":{},"时":{"docs":{},"时":{"docs":{},"间":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"超":{"docs":{},"时":{"docs":{},"时":{"docs":{},"间":{"docs":{},"是":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"接":{"docs":{},"收":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"推":{"docs":{},"送":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"/":{"docs":{},"响":{"docs":{},"应":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"上":{"docs":{},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{},"推":{"docs":{},"送":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"设":{"docs":{},"置":{"docs":{},"连":{"docs":{},"接":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"任":{"docs":{},"意":{"docs":{},"连":{"docs":{},"接":{"docs":{},"传":{"docs":{},"入":{"docs":{},"时":{"docs":{},"可":{"docs":{},"得":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"上":{"docs":{},"设":{"docs":{},"置":{"docs":{},"连":{"docs":{},"接":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"在":{"docs":{},"连":{"docs":{},"接":{"docs":{},"发":{"docs":{},"生":{"docs":{},"时":{"docs":{},"通":{"docs":{},"知":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"部":{"docs":{},"署":{"docs":{},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"中":{"docs":{},"指":{"docs":{},"定":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"集":{"docs":{},"群":{"docs":{},"环":{"docs":{},"境":{"docs":{},"中":{"docs":{},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"通":{"docs":{},"过":{"docs":{},"设":{"docs":{},"置":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"以":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"在":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"将":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"配":{"docs":{},"置":{"docs":{},"为":{"docs":{},"在":{"docs":{},"无":{"docs":{},"法":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"自":{"docs":{},"动":{"docs":{},"重":{"docs":{},"试":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"嵌":{"docs":{},"套":{"docs":{},"在":{"docs":{},"非":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"用":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"来":{"docs":{},"协":{"docs":{},"调":{"docs":{},"多":{"docs":{},"个":{"docs":{},"异":{"docs":{},"步":{"docs":{},"操":{"docs":{},"作":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{},"它":{"docs":{},"支":{"docs":{},"持":{"docs":{},"并":{"docs":{},"发":{"docs":{},"组":{"docs":{},"合":{"docs":{},"（":{"docs":{},"并":{"docs":{},"行":{"docs":{},"执":{"docs":{},"行":{"docs":{},"多":{"docs":{},"个":{"docs":{},"异":{"docs":{},"步":{"docs":{},"调":{"docs":{},"用":{"docs":{},"）":{"docs":{},"和":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"组":{"docs":{},"合":{"docs":{},"（":{"docs":{},"依":{"docs":{},"次":{"docs":{},"执":{"docs":{},"行":{"docs":{},"异":{"docs":{},"步":{"docs":{},"调":{"docs":{},"用":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"以":{"docs":{},"下":{"docs":{},"几":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"为":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"配":{"docs":{},"置":{"docs":{},"证":{"docs":{},"书":{"docs":{},"/":{"docs":{},"密":{"docs":{},"钥":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"配":{"docs":{},"置":{"docs":{},"证":{"docs":{},"书":{"docs":{},"吊":{"docs":{},"销":{"docs":{},"列":{"docs":{},"表":{"docs":{},"（":{"docs":{},"c":{"docs":{},"r":{"docs":{},"l":{"docs":{},"）":{"docs":{},"来":{"docs":{},"吊":{"docs":{},"销":{"docs":{},"不":{"docs":{},"再":{"docs":{},"被":{"docs":{},"信":{"docs":{},"任":{"docs":{},"的":{"docs":{},"证":{"docs":{},"书":{"docs":{},"机":{"docs":{},"构":{"docs":{},"。":{"docs":{},"c":{"docs":{},"r":{"docs":{},"l":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"配":{"docs":{},"置":{"docs":{},"了":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"c":{"docs":{},"r":{"docs":{},"l":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"占":{"docs":{},"位":{"docs":{},"符":{"docs":{},"声":{"docs":{},"明":{"docs":{},"路":{"docs":{},"径":{"docs":{},"参":{"docs":{},"数":{"docs":{},"并":{"docs":{},"在":{"docs":{},"处":{"docs":{},"理":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}},"提":{"docs":{},"供":{"docs":{},"值":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"设":{"docs":{},"置":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}},"非":{"docs":{},"常":{"docs":{},"迅":{"docs":{},"速":{"docs":{},"地":{"docs":{},"处":{"docs":{},"理":{"docs":{},"数":{"docs":{},"千":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"发":{"docs":{},"送":{"docs":{},"或":{"docs":{},"发":{"docs":{},"布":{"docs":{},"消":{"docs":{},"息":{"docs":{},"，":{"docs":{},"或":{"docs":{},"注":{"docs":{},"册":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"接":{"docs":{},"收":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}},"把":{"docs":{},"它":{"docs":{},"想":{"docs":{},"象":{"docs":{},"成":{"docs":{},"一":{"docs":{},"把":{"docs":{},"构":{"docs":{},"建":{"docs":{},"现":{"docs":{},"代":{"docs":{},"的":{"docs":{},"、":{"docs":{},"可":{"docs":{},"伸":{"docs":{},"缩":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"持":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"与":{"docs":{},"之":{"docs":{},"关":{"docs":{},"联":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"用":{"docs":{},"于":{"docs":{},"接":{"docs":{},"收":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"对":{"docs":{},"请":{"docs":{},"求":{"docs":{},"做":{"docs":{},"一":{"docs":{},"些":{"docs":{},"事":{"docs":{},"情":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"结":{"docs":{},"束":{"docs":{},"响":{"docs":{},"应":{"docs":{},"或":{"docs":{},"者":{"docs":{},"把":{"docs":{},"请":{"docs":{},"求":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"哪":{"docs":{},"些":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"根":{"docs":{},"据":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"访":{"docs":{},"问":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"自":{"docs":{},"动":{"docs":{},"转":{"docs":{},"换":{"docs":{},"。":{"docs":{},"需":{"docs":{},"要":{"docs":{},"注":{"docs":{},"意":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"选":{"docs":{},"择":{"docs":{},"性":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}}}}},"阅":{"docs":{},"读":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}},"这":{"docs":{},"样":{"docs":{},"注":{"docs":{},"册":{"docs":{},"一":{"docs":{},"个":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"者":{"docs":{},"：":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}},"对":{"docs":{},"消":{"docs":{},"息":{"docs":{},"流":{"docs":{},"进":{"docs":{},"行":{"docs":{},"流":{"docs":{},"量":{"docs":{},"控":{"docs":{},"制":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"我":{"docs":{},"们":{"docs":{},"读":{"docs":{},"到":{"docs":{},"一":{"docs":{},"批":{"docs":{},"消":{"docs":{},"息":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"花":{"docs":{},"点":{"docs":{},"时":{"docs":{},"间":{"docs":{},"进":{"docs":{},"行":{"docs":{},"处":{"docs":{},"理":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"暂":{"docs":{},"时":{"docs":{},"暂":{"docs":{},"停":{"docs":{},"（":{"docs":{},"p":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"）":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"流":{"docs":{},"入":{"docs":{},"（":{"docs":{},"这":{"docs":{},"里":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"是":{"docs":{},"把":{"docs":{},"消":{"docs":{},"息":{"docs":{},"全":{"docs":{},"部":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"到":{"docs":{},"内":{"docs":{},"存":{"docs":{},"里":{"docs":{},"了":{"docs":{},"）":{"docs":{},"；":{"docs":{},"等":{"docs":{},"我":{"docs":{},"们":{"docs":{},"处":{"docs":{},"理":{"docs":{},"了":{"docs":{},"差":{"docs":{},"不":{"docs":{},"多":{"docs":{},"了":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"再":{"docs":{},"继":{"docs":{},"续":{"docs":{},"消":{"docs":{},"费":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"起":{"docs":{},"来":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"）":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"映":{"docs":{},"射":{"docs":{},"为":{"docs":{},"单":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"适":{"docs":{},"配":{"docs":{},"为":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"有":{"docs":{},"多":{"docs":{},"种":{"docs":{},"风":{"docs":{},"格":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"回":{"docs":{},"调":{"docs":{},"、":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"和":{"docs":{},"r":{"docs":{},"x":{"docs":{},"风":{"docs":{},"格":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"让":{"docs":{},"你":{"docs":{},"在":{"docs":{},"熟":{"docs":{},"悉":{"docs":{},"的":{"docs":{},"同":{"docs":{},"步":{"docs":{},"风":{"docs":{},"格":{"docs":{},"下":{"docs":{},"继":{"docs":{},"续":{"docs":{},"使":{"docs":{},"用":{"docs":{},"异":{"docs":{},"步":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}},"用":{"docs":{},"同":{"docs":{},"步":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"得":{"docs":{},"到":{"docs":{},"这":{"docs":{},"种":{"docs":{},"一":{"docs":{},"次":{"docs":{},"性":{"docs":{},"的":{"docs":{},"异":{"docs":{},"步":{"docs":{},"操":{"docs":{},"作":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"调":{"docs":{},"用":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"在":{"docs":{},"生":{"docs":{},"效":{"docs":{},"之":{"docs":{},"前":{"docs":{},"的":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"次":{"docs":{},"数":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}},"快":{"docs":{},"速":{"docs":{},"、":{"docs":{},"无":{"docs":{},"需":{"docs":{},"“":{"docs":{},"等":{"docs":{},"待":{"docs":{},"”":{"docs":{},"地":{"docs":{},"获":{"docs":{},"得":{"docs":{},"最":{"docs":{},"近":{"docs":{},"一":{"docs":{},"次":{"docs":{},"获":{"docs":{},"取":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"内":{"docs":{},"容":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"另":{"docs":{},"一":{"docs":{},"种":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"所":{"docs":{},"以":{"docs":{},"一":{"docs":{},"个":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"可":{"docs":{},"以":{"docs":{},"作":{"docs":{},"为":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"的":{"docs":{},"工":{"docs":{},"厂":{"docs":{},"）":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612}},"j":{"docs":{},"d":{"docs":{},"k":{"docs":{},"随":{"docs":{},"附":{"docs":{},"的":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"实":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"来":{"docs":{},"管":{"docs":{},"理":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"剩":{"docs":{},"余":{"docs":{},"部":{"docs":{},"分":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"在":{"docs":{},"短":{"docs":{},"时":{"docs":{},"间":{"docs":{},"内":{"docs":{},"分":{"docs":{},"发":{"docs":{},"大":{"docs":{},"量":{"docs":{},"的":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"单":{"docs":{},"独":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"部":{"docs":{},"署":{"docs":{},"时":{"docs":{},"传":{"docs":{},"给":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"替":{"docs":{},"换":{"docs":{},"主":{"docs":{},"机":{"docs":{},"文":{"docs":{},"件":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"于":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"不":{"docs":{},"同":{"docs":{},"语":{"docs":{},"言":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"自":{"docs":{},"签":{"docs":{},"名":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"证":{"docs":{},"书":{"docs":{},"，":{"docs":{},"并":{"docs":{},"可":{"docs":{},"以":{"docs":{},"提":{"docs":{},"供":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"各":{"docs":{},"种":{"docs":{},"选":{"docs":{},"项":{"docs":{},"完":{"docs":{},"整":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"直":{"docs":{},"接":{"docs":{},"在":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"键":{"docs":{},"入":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}},"如":{"docs":{},"下":{"docs":{},"代":{"docs":{},"码":{"docs":{},"获":{"docs":{},"取":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}},"能":{"docs":{},"对":{"docs":{},"应":{"docs":{},"多":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"的":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"值":{"docs":{},"是":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"系":{"docs":{},"统":{"docs":{},"错":{"docs":{},"误":{"docs":{},"(":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}}}}}}}}}}}}},"选":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"通":{"docs":{},"过":{"docs":{},"设":{"docs":{},"置":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"强":{"docs":{},"制":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"使":{"docs":{},"用":{"docs":{},"某":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"与":{"docs":{},"其":{"docs":{},"它":{"docs":{},"r":{"docs":{},"x":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}},"被":{"docs":{},"多":{"docs":{},"次":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}},"调":{"docs":{},"用":{"docs":{},"语":{"docs":{},"句":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"。":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"标":{"docs":{},"准":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}},"读":{"docs":{},"流":{"docs":{},"支":{"docs":{},"持":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"转":{"docs":{},"换":{"docs":{},"为":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}},"的":{"docs":{},"背":{"docs":{},"压":{"docs":{},"时":{"docs":{},"，":{"docs":{},"你":{"docs":{},"会":{"docs":{},"用":{"docs":{},"到":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}},"各":{"docs":{},"个":{"docs":{},"组":{"docs":{},"件":{"docs":{},"的":{"docs":{},"常":{"docs":{},"见":{"docs":{},"问":{"docs":{},"题":{"docs":{},"以":{"docs":{},"及":{"docs":{},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{},"注":{"docs":{},"意":{"docs":{},"事":{"docs":{},"项":{"docs":{},"和":{"docs":{},"解":{"docs":{},"决":{"docs":{},"方":{"docs":{},"案":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}},"路":{"docs":{},"径":{"docs":{},"作":{"docs":{},"用":{"docs":{},"为":{"docs":{},"：":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}},"复":{"docs":{},"杂":{"docs":{},"一":{"docs":{},"点":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}},"制":{"docs":{},"了":{"docs":{},"类":{"docs":{},"似":{"docs":{},"的":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"并":{"docs":{},"冠":{"docs":{},"以":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"由":{"docs":{},"此":{"docs":{},"可":{"docs":{},"以":{"docs":{},"避":{"docs":{},"免":{"docs":{},"为":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"的":{"docs":{},"多":{"docs":{},"个":{"docs":{},"异":{"docs":{},"步":{"docs":{},"操":{"docs":{},"作":{"docs":{},"定":{"docs":{},"义":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}},"它":{"docs":{},"像":{"docs":{},"一":{"docs":{},"个":{"docs":{},"普":{"docs":{},"通":{"docs":{},"的":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"或":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"它":{"docs":{},"还":{"docs":{},"允":{"docs":{},"许":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"键":{"docs":{},"支":{"docs":{},"持":{"docs":{},"多":{"docs":{},"个":{"docs":{},"值":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"此":{"docs":{},"实":{"docs":{},"例":{"docs":{},"在":{"docs":{},"启":{"docs":{},"动":{"docs":{},"时":{"docs":{},"未":{"docs":{},"部":{"docs":{},"署":{"docs":{},"任":{"docs":{},"何":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"但":{"docs":{},"它":{"docs":{},"若":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"若":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"节":{"docs":{},"点":{"docs":{},"死":{"docs":{},"亡":{"docs":{},"，":{"docs":{},"则":{"docs":{},"会":{"docs":{},"在":{"docs":{},"此":{"docs":{},"节":{"docs":{},"点":{"docs":{},"运":{"docs":{},"行":{"docs":{},"之":{"docs":{},"前":{"docs":{},"挂":{"docs":{},"掉":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"如":{"docs":{},"需":{"docs":{},"要":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"代":{"docs":{},"表":{"docs":{},"了":{"docs":{},"实":{"docs":{},"际":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"套":{"docs":{},"接":{"docs":{},"字":{"docs":{},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"它":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"读":{"docs":{},"取":{"docs":{},"和":{"docs":{},"写":{"docs":{},"入":{"docs":{},"数":{"docs":{},"据":{"docs":{},"、":{"docs":{},"以":{"docs":{},"及":{"docs":{},"执":{"docs":{},"行":{"docs":{},"各":{"docs":{},"种":{"docs":{},"其":{"docs":{},"他":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"如":{"docs":{},"关":{"docs":{},"闭":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"些":{"docs":{},"实":{"docs":{},"例":{"docs":{},"通":{"docs":{},"过":{"docs":{},"底":{"docs":{},"层":{"docs":{},"的":{"docs":{},"分":{"docs":{},"布":{"docs":{},"式":{"docs":{},"数":{"docs":{},"据":{"docs":{},"结":{"docs":{},"构":{"docs":{},"来":{"docs":{},"协":{"docs":{},"同":{"docs":{},"保":{"docs":{},"持":{"docs":{},"服":{"docs":{},"务":{"docs":{},"集":{"docs":{},"合":{"docs":{},"的":{"docs":{},"同":{"docs":{},"步":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"当":{"docs":{},"您":{"docs":{},"完":{"docs":{},"成":{"docs":{},"了":{"docs":{},"对":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"参":{"docs":{},"数":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"x":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}},"关":{"docs":{},"于":{"docs":{},"此":{"docs":{},"部":{"docs":{},"分":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"可":{"docs":{},"以":{"docs":{},"参":{"docs":{},"考":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}},"不":{"docs":{},"会":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"到":{"docs":{},"特":{"docs":{},"定":{"docs":{},"端":{"docs":{},"口":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"只":{"docs":{},"想":{"docs":{},"发":{"docs":{},"送":{"docs":{},"数":{"docs":{},"据":{"docs":{},"（":{"docs":{},"如":{"docs":{},"作":{"docs":{},"为":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"）":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"这":{"docs":{},"是":{"docs":{},"没":{"docs":{},"问":{"docs":{},"题":{"docs":{},"的":{"docs":{},"，":{"docs":{},"但":{"docs":{},"更":{"docs":{},"多":{"docs":{},"详":{"docs":{},"细":{"docs":{},"的":{"docs":{},"内":{"docs":{},"容":{"docs":{},"在":{"docs":{},"下":{"docs":{},"一":{"docs":{},"节":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"我":{"docs":{},"们":{"docs":{},"称":{"docs":{},"这":{"docs":{},"个":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"详":{"docs":{},"细":{"docs":{},"说":{"docs":{},"明":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"您":{"docs":{},"在":{"docs":{},"网":{"docs":{},"络":{"docs":{},"上":{"docs":{},"将":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"同":{"docs":{},"时":{"docs":{},"运":{"docs":{},"行":{"docs":{},"的":{"docs":{},"许":{"docs":{},"多":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"向":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"或":{"docs":{},"在":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"不":{"docs":{},"同":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"之":{"docs":{},"间":{"docs":{},"或":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"所":{"docs":{},"有":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"设":{"docs":{},"置":{"docs":{},"异":{"docs":{},"常":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"发":{"docs":{},"生":{"docs":{},"的":{"docs":{},"异":{"docs":{},"常":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"重":{"docs":{},"新":{"docs":{},"部":{"docs":{},"署":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"里":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"有":{"docs":{},"多":{"docs":{},"个":{"docs":{},"应":{"docs":{},"用":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"希":{"docs":{},"望":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"使":{"docs":{},"用":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"之":{"docs":{},"间":{"docs":{},"安":{"docs":{},"全":{"docs":{},"地":{"docs":{},"共":{"docs":{},"享":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"共":{"docs":{},"享":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}},"也":{"docs":{},"是":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"和":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"仍":{"docs":{},"然":{"docs":{},"严":{"docs":{},"格":{"docs":{},"使":{"docs":{},"用":{"docs":{},"单":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"您":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"像":{"docs":{},"编":{"docs":{},"写":{"docs":{},"负":{"docs":{},"载":{"docs":{},"均":{"docs":{},"衡":{"docs":{},"器":{"docs":{},"那":{"docs":{},"样":{"docs":{},"使":{"docs":{},"用":{"docs":{},"任":{"docs":{},"何":{"docs":{},"特":{"docs":{},"殊":{"docs":{},"技":{"docs":{},"巧":{"docs":{},"去":{"docs":{},"编":{"docs":{},"写":{"docs":{},"，":{"docs":{},"以":{"docs":{},"便":{"docs":{},"在":{"docs":{},"多":{"docs":{},"核":{"docs":{},"机":{"docs":{},"器":{"docs":{},"上":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{},"任":{"docs":{},"意":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"访":{"docs":{},"问":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"失":{"docs":{},"败":{"docs":{},"或":{"docs":{},"挂":{"docs":{},"掉":{"docs":{},"，":{"docs":{},"则":{"docs":{},"此":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"将":{"docs":{},"自":{"docs":{},"动":{"docs":{},"重":{"docs":{},"新":{"docs":{},"部":{"docs":{},"署":{"docs":{},"到":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"将":{"docs":{},"数":{"docs":{},"据":{"docs":{},"泵":{"docs":{},"入":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"自":{"docs":{},"动":{"docs":{},"重":{"docs":{},"新":{"docs":{},"部":{"docs":{},"署":{"docs":{},"m":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"复":{"docs":{},"用":{"docs":{},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"（":{"docs":{},"如":{"docs":{},"线":{"docs":{},"程":{"docs":{},"、":{"docs":{},"连":{"docs":{},"接":{"docs":{},"等":{"docs":{},"）":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"完":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"部":{"docs":{},"署":{"docs":{},"好":{"docs":{},"（":{"docs":{},"状":{"docs":{},"态":{"docs":{},"不":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{},"请":{"docs":{},"求":{"docs":{},"处":{"docs":{},"理":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"此":{"docs":{},"对":{"docs":{},"象":{"docs":{},"表":{"docs":{},"示":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"数":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"时":{"docs":{},"也":{"docs":{},"可":{"docs":{},"配":{"docs":{},"置":{"docs":{},"d":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"指":{"docs":{},"示":{"docs":{},"它":{"docs":{},"在":{"docs":{},"部":{"docs":{},"署":{"docs":{},"任":{"docs":{},"何":{"docs":{},"h":{"docs":{},"a":{"docs":{},"部":{"docs":{},"署":{"docs":{},"之":{"docs":{},"前":{"docs":{},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"个":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"r":{"docs":{},"u":{"docs":{},"m":{"docs":{},"。":{"docs":{},"该":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"环":{"docs":{},"境":{"docs":{},"中":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"传":{"docs":{},"入":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"认":{"docs":{},"证":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"说":{"docs":{},"它":{"docs":{},"是":{"docs":{},"单":{"docs":{},"例":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"使":{"docs":{},"用":{"docs":{},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"模":{"docs":{},"块":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}},"正":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"两":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"现":{"docs":{},"在":{"docs":{},"死":{"docs":{},"了":{"docs":{},"（":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"执":{"docs":{},"行":{"docs":{},"k":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"数":{"docs":{},"量":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"据":{"docs":{},"库":{"docs":{},"名":{"docs":{},"称":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"您":{"docs":{},"正":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"docs":{},"粘":{"docs":{},"性":{"docs":{},"会":{"docs":{},"话":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"配":{"docs":{},"置":{"docs":{},"您":{"docs":{},"的":{"docs":{},"负":{"docs":{},"载":{"docs":{},"均":{"docs":{},"衡":{"docs":{},"器":{"docs":{},"来":{"docs":{},"确":{"docs":{},"保":{"docs":{},"所":{"docs":{},"有":{"docs":{},"请":{"docs":{},"求":{"docs":{},"（":{"docs":{},"来":{"docs":{},"自":{"docs":{},"同":{"docs":{},"一":{"docs":{},"用":{"docs":{},"户":{"docs":{},"的":{"docs":{},"）":{"docs":{},"永":{"docs":{},"远":{"docs":{},"被":{"docs":{},"派":{"docs":{},"发":{"docs":{},"到":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"候":{"docs":{},"传":{"docs":{},"入":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}},"组":{"docs":{},"合":{"docs":{},"而":{"docs":{},"成":{"docs":{},"。":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"集":{"docs":{},"群":{"docs":{},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"些":{"docs":{},"时":{"docs":{},"间":{"docs":{},"（":{"docs":{},"也":{"docs":{},"许":{"docs":{},"是":{"docs":{},"几":{"docs":{},"秒":{"docs":{},"钟":{"docs":{},"）":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"段":{"docs":{},"时":{"docs":{},"间":{"docs":{},"内":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"不":{"docs":{},"想":{"docs":{},"去":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"调":{"docs":{},"用":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"我":{"docs":{},"们":{"docs":{},"将":{"docs":{},"结":{"docs":{},"果":{"docs":{},"异":{"docs":{},"步":{"docs":{},"返":{"docs":{},"回":{"docs":{},"给":{"docs":{},"您":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"给":{"docs":{},"它":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"绝":{"docs":{},"对":{"docs":{},"不":{"docs":{},"会":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"维":{"docs":{},"护":{"docs":{},"了":{"docs":{},"n":{"docs":{},"（":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"多":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"的":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"线":{"docs":{},"程":{"docs":{},"不":{"docs":{},"是":{"docs":{},"守":{"docs":{},"护":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"它":{"docs":{},"们":{"docs":{},"会":{"docs":{},"阻":{"docs":{},"止":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"退":{"docs":{},"出":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"能":{"docs":{},"够":{"docs":{},"让":{"docs":{},"您":{"docs":{},"读":{"docs":{},"取":{"docs":{},"在":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"共":{"docs":{},"享":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"单":{"docs":{},"独":{"docs":{},"为":{"docs":{},"每":{"docs":{},"个":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"向":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"都":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"单":{"docs":{},"独":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"好":{"docs":{},"后":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"解":{"docs":{},"析":{"docs":{},"用":{"docs":{},"户":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"来":{"docs":{},"解":{"docs":{},"析":{"docs":{},"每":{"docs":{},"个":{"docs":{},"选":{"docs":{},"项":{"docs":{},"和":{"docs":{},"参":{"docs":{},"数":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"成":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"的":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"销":{"docs":{},"毁":{"docs":{},"的":{"docs":{},"同":{"docs":{},"时":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"集":{"docs":{},"群":{"docs":{},"在":{"docs":{},"一":{"docs":{},"起":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"形":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"单":{"docs":{},"一":{"docs":{},"的":{"docs":{},"、":{"docs":{},"分":{"docs":{},"布":{"docs":{},"式":{"docs":{},"的":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"）":{"docs":{},"，":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"将":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"）":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"了":{"docs":{},"多":{"docs":{},"次":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"这":{"docs":{},"些":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"来":{"docs":{},"返":{"docs":{},"回":{"docs":{},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"任":{"docs":{},"意":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"则":{"docs":{},"最":{"docs":{},"好":{"docs":{},"始":{"docs":{},"终":{"docs":{},"从":{"docs":{},"该":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"e":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"因":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"可":{"docs":{},"以":{"docs":{},"有":{"docs":{},"多":{"docs":{},"个":{"docs":{},"具":{"docs":{},"有":{"docs":{},"相":{"docs":{},"同":{"docs":{},"名":{"docs":{},"称":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"此":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"任":{"docs":{},"何":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"在":{"docs":{},"其":{"docs":{},"中":{"docs":{},"去":{"docs":{},"处":{"docs":{},"理":{"docs":{},"它":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"用":{"docs":{},"来":{"docs":{},"写":{"docs":{},"数":{"docs":{},"据":{"docs":{},"到":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"和":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"所":{"docs":{},"以":{"docs":{},"假":{"docs":{},"设":{"docs":{},"您":{"docs":{},"已":{"docs":{},"经":{"docs":{},"有":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"已":{"docs":{},"经":{"docs":{},"启":{"docs":{},"动":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"以":{"docs":{},"下":{"docs":{},"命":{"docs":{},"令":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"无":{"docs":{},"论":{"docs":{},"您":{"docs":{},"是":{"docs":{},"要":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"发":{"docs":{},"送":{"docs":{},"数":{"docs":{},"据":{"docs":{},"或":{"docs":{},"者":{"docs":{},"收":{"docs":{},"发":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"这":{"docs":{},"都":{"docs":{},"是":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"些":{"docs":{},"选":{"docs":{},"项":{"docs":{},"描":{"docs":{},"述":{"docs":{},"了":{"docs":{},"访":{"docs":{},"问":{"docs":{},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{},"您":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"泵":{"docs":{},"送":{"docs":{},"数":{"docs":{},"据":{"docs":{},"到":{"docs":{},"任":{"docs":{},"何":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"用":{"docs":{},"于":{"docs":{},"指":{"docs":{},"定":{"docs":{},"要":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"发":{"docs":{},"布":{"docs":{},"服":{"docs":{},"务":{"docs":{},"了":{"docs":{},"。":{"docs":{},"发":{"docs":{},"布":{"docs":{},"的":{"docs":{},"流":{"docs":{},"程":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}},"并":{"docs":{},"且":{"docs":{},"已":{"docs":{},"经":{"docs":{},"配":{"docs":{},"置":{"docs":{},"好":{"docs":{},"了":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"和":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"这":{"docs":{},"里":{"docs":{},"配":{"docs":{},"置":{"docs":{},"消":{"docs":{},"息":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{},"相":{"docs":{},"关":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"如":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}},"上":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"是":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"的":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"作":{"docs":{},"为":{"docs":{},"副":{"docs":{},"本":{"docs":{},"集":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"监":{"docs":{},"听":{"docs":{},"的":{"docs":{},"端":{"docs":{},"口":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}},"时":{"docs":{},"重":{"docs":{},"部":{"docs":{},"署":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"现":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"完":{"docs":{},"整":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"这":{"docs":{},"种":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"并":{"docs":{},"发":{"docs":{},"组":{"docs":{},"合":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"配":{"docs":{},"置":{"docs":{},"内":{"docs":{},"容":{"docs":{},"和":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}},"中":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}},"拿":{"docs":{},"到":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"者":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"将":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"泵":{"docs":{},"入":{"docs":{},"其":{"docs":{},"中":{"docs":{},"。":{"docs":{},"其":{"docs":{},"间":{"docs":{},"背":{"docs":{},"压":{"docs":{},"机":{"docs":{},"制":{"docs":{},"将":{"docs":{},"自":{"docs":{},"动":{"docs":{},"运":{"docs":{},"行":{"docs":{},"。":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"依":{"docs":{},"赖":{"docs":{},"：":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},":":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"参":{"docs":{},"考":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"。":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"同":{"docs":{},"时":{"docs":{},"也":{"docs":{},"支":{"docs":{},"持":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}},"由":{"docs":{},"于":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}},"，":{"docs":{},"这":{"docs":{},"网":{"docs":{},"络":{"docs":{},"发":{"docs":{},"现":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"开":{"docs":{},"启":{"docs":{},"组":{"docs":{},"播":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"组":{"docs":{},"播":{"docs":{},"被":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"采":{"docs":{},"用":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"已":{"docs":{},"经":{"docs":{},"由":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"来":{"docs":{},"管":{"docs":{},"理":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"密":{"docs":{},"钥":{"docs":{},"存":{"docs":{},"储":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"际":{"docs":{},"写":{"docs":{},"入":{"docs":{},"操":{"docs":{},"作":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"能":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"段":{"docs":{},"时":{"docs":{},"间":{"docs":{},"后":{"docs":{},"才":{"docs":{},"发":{"docs":{},"生":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"也":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"也":{"docs":{},"许":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"匹":{"docs":{},"配":{"docs":{},"过":{"docs":{},"程":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"方":{"docs":{},"法":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}},"上":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"将":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}},"会":{"docs":{},"看":{"docs":{},"到":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"计":{"docs":{},"数":{"docs":{},"。":{"docs":{},"同":{"docs":{},"理":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"i":{"docs":{},"替":{"docs":{},"换":{"docs":{},"成":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"等":{"docs":{},"线":{"docs":{},"程":{"docs":{},"不":{"docs":{},"安":{"docs":{},"全":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"或":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"可":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"内":{"docs":{},"部":{"docs":{},"安":{"docs":{},"全":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"匹":{"docs":{},"配":{"docs":{},"所":{"docs":{},"有":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"发":{"docs":{},"生":{"docs":{},"什":{"docs":{},"么":{"docs":{},"？":{"docs":{},"如":{"docs":{},"果":{"docs":{},"两":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"成":{"docs":{},"功":{"docs":{},"完":{"docs":{},"成":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"自":{"docs":{},"动":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"这":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"被":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"，":{"docs":{},"其":{"docs":{},"内":{"docs":{},"容":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"用":{"docs":{},"于":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}},"作":{"docs":{},"为":{"docs":{},"原":{"docs":{},"生":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"）":{"docs":{},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}},"得":{"docs":{},"到":{"docs":{},"新":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"，":{"docs":{},"若":{"docs":{},"没":{"docs":{},"有":{"docs":{},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"结":{"docs":{},"束":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"写":{"docs":{},"入":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"或":{"docs":{},"其":{"docs":{},"他":{"docs":{},"类":{"docs":{},"似":{"docs":{},"位":{"docs":{},"置":{"docs":{},"后":{"docs":{},"，":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"就":{"docs":{},"不":{"docs":{},"可":{"docs":{},"被":{"docs":{},"重":{"docs":{},"用":{"docs":{},"了":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"为":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"发":{"docs":{},"送":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"y":{"docs":{},"的":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"保":{"docs":{},"证":{"docs":{},"用":{"docs":{},"与":{"docs":{},"调":{"docs":{},"用":{"docs":{},"该":{"docs":{},"方":{"docs":{},"法":{"docs":{},"时":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"其":{"docs":{},"发":{"docs":{},"回":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"连":{"docs":{},"接":{"docs":{},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{},"直":{"docs":{},"接":{"docs":{},"将":{"docs":{},"请":{"docs":{},"求":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"队":{"docs":{},"列":{"docs":{},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"出":{"docs":{},"通":{"docs":{},"知":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"向":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"它":{"docs":{},"之":{"docs":{},"前":{"docs":{},"对":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"数":{"docs":{},"据":{"docs":{},"刷":{"docs":{},"新":{"docs":{},"到":{"docs":{},"底":{"docs":{},"层":{"docs":{},"存":{"docs":{},"储":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"放":{"docs":{},"入":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"回":{"docs":{},"写":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"从":{"docs":{},"可":{"docs":{},"读":{"docs":{},"流":{"docs":{},"泵":{"docs":{},"入":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}},"组":{"docs":{},"项":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"数":{"docs":{},"组":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"添":{"docs":{},"加":{"docs":{},"以":{"docs":{},"下":{"docs":{},"头":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"自":{"docs":{},"动":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"非":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"发":{"docs":{},"送":{"docs":{},"确":{"docs":{},"认":{"docs":{},"，":{"docs":{},"可":{"docs":{},"设":{"docs":{},"置":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"当":{"docs":{},"收":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"计":{"docs":{},"算":{"docs":{},"并":{"docs":{},"设":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"覆":{"docs":{},"盖":{"docs":{},"默":{"docs":{},"认":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"设":{"docs":{},"置":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"委":{"docs":{},"托":{"docs":{},"给":{"docs":{},"其":{"docs":{},"中":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"放":{"docs":{},"入":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"配":{"docs":{},"置":{"docs":{},"成":{"docs":{},"加":{"docs":{},"密":{"docs":{},"的":{"docs":{},"或":{"docs":{},"强":{"docs":{},"制":{"docs":{},"安":{"docs":{},"全":{"docs":{},"的":{"docs":{},"。":{"docs":{},"参":{"docs":{},"考":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"文":{"docs":{},"档":{"docs":{},"获":{"docs":{},"取":{"docs":{},"更":{"docs":{},"多":{"docs":{},"细":{"docs":{},"节":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"以":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"规":{"docs":{},"则":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"映":{"docs":{},"射":{"docs":{},"成":{"docs":{},"p":{"docs":{},"o":{"docs":{},"j":{"docs":{},"o":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"定":{"docs":{},"制":{"docs":{},"成":{"docs":{},"以":{"docs":{},"下":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"结":{"docs":{},"果":{"docs":{},"解":{"docs":{},"码":{"docs":{},"为":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}},"无":{"docs":{},"法":{"docs":{},"得":{"docs":{},"知":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"是":{"docs":{},"否":{"docs":{},"已":{"docs":{},"写":{"docs":{},"入":{"docs":{},"）":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"挪":{"docs":{},"到":{"docs":{},"分":{"docs":{},"区":{"docs":{},"末":{"docs":{},"端":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},"起":{"docs":{},"始":{"docs":{},"端":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}},"已":{"docs":{},"经":{"docs":{},"发":{"docs":{},"布":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"注":{"docs":{},"销":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}},"第":{"docs":{},"一":{"docs":{},"步":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"、":{"docs":{},"第":{"docs":{},"二":{"docs":{},"步":{"docs":{},"第":{"docs":{},"三":{"docs":{},"步":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"类":{"docs":{},"以":{"docs":{},"及":{"docs":{},"第":{"docs":{},"四":{"docs":{},"步":{"docs":{},"中":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"描":{"docs":{},"述":{"docs":{},"文":{"docs":{},"件":{"docs":{},"打":{"docs":{},"包":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"包":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"将":{"docs":{},"这":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"包":{"docs":{},"放":{"docs":{},"到":{"docs":{},"你":{"docs":{},"应":{"docs":{},"用":{"docs":{},"的":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"指":{"docs":{},"标":{"docs":{},"推":{"docs":{},"送":{"docs":{},"到":{"docs":{},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}},"目":{"docs":{},"标":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}},"就":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"会":{"docs":{},"使":{"docs":{},"计":{"docs":{},"数":{"docs":{},"器":{"docs":{},"加":{"1":{"docs":{},"，":{"docs":{},"访":{"docs":{},"问":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}},"docs":{}}}}}},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"变":{"docs":{},"成":{"docs":{},"已":{"docs":{},"停":{"docs":{},"止":{"docs":{},"状":{"docs":{},"态":{"docs":{},"了":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"启":{"docs":{},"动":{"docs":{},"状":{"docs":{},"态":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"是":{"docs":{},"失":{"docs":{},"败":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"能":{"docs":{},"跑":{"docs":{},"起":{"docs":{},"来":{"docs":{},"！":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"建":{"docs":{},"议":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}},"接":{"docs":{},"口":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},"处":{"docs":{},"理":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"实":{"docs":{},"现":{"docs":{},"类":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.011363636363636364}}}}}},"的":{"docs":{},"辅":{"docs":{},"助":{"docs":{},"方":{"docs":{},"法":{"docs":{},"直":{"docs":{},"接":{"docs":{},"获":{"docs":{},"取":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"泵":{"docs":{},"将":{"docs":{},"数":{"docs":{},"据":{"docs":{},"与":{"docs":{},"其":{"docs":{},"他":{"docs":{},"读":{"docs":{},"取":{"docs":{},"和":{"docs":{},"写":{"docs":{},"入":{"docs":{},"流":{"docs":{},"进":{"docs":{},"行":{"docs":{},"数":{"docs":{},"据":{"docs":{},"泵":{"docs":{},"送":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"这":{"docs":{},"会":{"docs":{},"将":{"docs":{},"内":{"docs":{},"容":{"docs":{},"复":{"docs":{},"制":{"docs":{},"到":{"docs":{},"另":{"docs":{},"外":{"docs":{},"一":{"docs":{},"个":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"操":{"docs":{},"作":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"任":{"docs":{},"何":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"和":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"实":{"docs":{},"现":{"docs":{},"类":{"docs":{},"包":{"docs":{},"括":{"docs":{},"：":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"同":{"docs":{},"步":{"docs":{},"地":{"docs":{},"接":{"docs":{},"收":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}},"辅":{"docs":{},"助":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"查":{"docs":{},"询":{"docs":{},"和":{"docs":{},"获":{"docs":{},"取":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}},"获":{"docs":{},"得":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}},"，":{"docs":{},"来":{"docs":{},"查":{"docs":{},"询":{"docs":{},"和":{"docs":{},"获":{"docs":{},"取":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}},"继":{"docs":{},"承":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"它":{"docs":{},"套":{"docs":{},"用":{"docs":{},"（":{"docs":{},"p":{"docs":{},"u":{"docs":{},"m":{"docs":{},"p":{"docs":{},"）":{"docs":{},"到":{"docs":{},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{},"读":{"docs":{},"写":{"docs":{},"流":{"docs":{},"上":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"文":{"docs":{},"件":{"docs":{},"和":{"docs":{},"其":{"docs":{},"他":{"docs":{},"流":{"docs":{},"对":{"docs":{},"象":{"docs":{},"配":{"docs":{},"合":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"读":{"docs":{},"取":{"docs":{},"到":{"docs":{},"任":{"docs":{},"何":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"写":{"docs":{},"入":{"docs":{},"之":{"docs":{},"前":{"docs":{},"检":{"docs":{},"查":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{},"，":{"docs":{},"任":{"docs":{},"何":{"docs":{},"可":{"docs":{},"控":{"docs":{},"制":{"docs":{},"的":{"docs":{},"读":{"docs":{},"取":{"docs":{},"流":{"docs":{},"对":{"docs":{},"象":{"docs":{},"都":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"任":{"docs":{},"何":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"代":{"docs":{},"码":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"将":{"docs":{},"两":{"docs":{},"步":{"docs":{},"合":{"docs":{},"并":{"docs":{},"成":{"docs":{},"一":{"docs":{},"次":{"docs":{},"方":{"docs":{},"法":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}},"然":{"docs":{},"后":{"docs":{},"再":{"docs":{},"使":{"docs":{},"用":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"数":{"docs":{},"量":{"docs":{},"的":{"docs":{},"增":{"docs":{},"长":{"docs":{},"，":{"docs":{},"设":{"docs":{},"置":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"操":{"docs":{},"作":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"连":{"docs":{},"接":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"此":{"docs":{},"接":{"docs":{},"口":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"各":{"docs":{},"种":{"docs":{},"基":{"docs":{},"本":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"方":{"docs":{},"法":{"docs":{},"）":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"辅":{"docs":{},"助":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"完":{"docs":{},"成":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"查":{"docs":{},"找":{"docs":{},"和":{"docs":{},"获":{"docs":{},"取":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}},"或":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"者":{"docs":{},"第":{"docs":{},"一":{"docs":{},"步":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"类":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"类":{"docs":{},"必":{"docs":{},"须":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}},"条":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}}}}}}}},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"了":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"还":{"docs":{},"通":{"docs":{},"过":{"docs":{},"实":{"docs":{},"现":{"docs":{},"该":{"docs":{},"接":{"docs":{},"口":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"基":{"docs":{},"于":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{},"后":{"docs":{},"端":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"如":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"获":{"docs":{},"得":{"docs":{},"代":{"docs":{},"理":{"docs":{},"对":{"docs":{},"象":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"数":{"docs":{},"据":{"docs":{},"结":{"docs":{},"构":{"docs":{},")":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}},"将":{"docs":{},"被":{"docs":{},"选":{"docs":{},"择":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}}}}}},"下":{"docs":{},"来":{"docs":{},"讨":{"docs":{},"论":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"一":{"docs":{},"起":{"docs":{},"来":{"docs":{},"看":{"docs":{},"下":{"docs":{},"创":{"docs":{},"建":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}},"的":{"docs":{},"这":{"docs":{},"些":{"docs":{},"配":{"docs":{},"置":{"docs":{},"属":{"docs":{},"性":{"docs":{},"是":{"docs":{},"用":{"docs":{},"来":{"docs":{},"配":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{},"l":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}},"收":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"传":{"docs":{},"入":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"通":{"docs":{},"知":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"到":{"docs":{},"数":{"docs":{},"据":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"以":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"的":{"docs":{},"是":{"docs":{},"事":{"docs":{},"件":{"docs":{},"流":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}},"多":{"docs":{},"播":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"数":{"docs":{},"据":{"docs":{},"报":{"docs":{},"包":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"者":{"docs":{},"调":{"docs":{},"用":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"和":{"docs":{},"解":{"docs":{},"析":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"缓":{"docs":{},"冲":{"docs":{},"区":{"docs":{},"大":{"docs":{},"小":{"docs":{},"（":{"docs":{},"s":{"docs":{},"o":{"docs":{},"_":{"docs":{},"r":{"docs":{},"c":{"docs":{},"v":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"）":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"种":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"是":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"了":{"docs":{},"一":{"docs":{},"种":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"操":{"docs":{},"作":{"docs":{},"中":{"docs":{},"将":{"docs":{},"文":{"docs":{},"件":{"docs":{},"从":{"docs":{},"磁":{"docs":{},"盘":{"docs":{},"或":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{},"并":{"docs":{},"提":{"docs":{},"供":{"docs":{},"给":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}},"个":{"docs":{},"内":{"docs":{},"置":{"docs":{},"的":{"docs":{},"叫":{"docs":{},"做":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}},"开":{"docs":{},"箱":{"docs":{},"即":{"docs":{},"用":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"来":{"docs":{},"提":{"docs":{},"供":{"docs":{},"静":{"docs":{},"态":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"用":{"docs":{},"于":{"docs":{},"记":{"docs":{},"录":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"超":{"docs":{},"时":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"处":{"docs":{},"理":{"docs":{},"时":{"docs":{},"间":{"docs":{},"过":{"docs":{},"长":{"docs":{},"时":{"docs":{},"将":{"docs":{},"请":{"docs":{},"求":{"docs":{},"超":{"docs":{},"时":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"的":{"docs":{},"基":{"docs":{},"础":{"docs":{},"组":{"docs":{},"件":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"发":{"docs":{},"布":{"docs":{},"和":{"docs":{},"发":{"docs":{},"现":{"docs":{},"各":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"、":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"端":{"docs":{},"点":{"docs":{},"（":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"、":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"（":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"系":{"docs":{},"列":{"docs":{},"底":{"docs":{},"层":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"用":{"docs":{},"于":{"docs":{},"操":{"docs":{},"作":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"存":{"docs":{},"储":{"docs":{},"支":{"docs":{},"持":{"docs":{},"和":{"docs":{},"格":{"docs":{},"式":{"docs":{},"支":{"docs":{},"持":{"docs":{},"。":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"种":{"docs":{},"类":{"docs":{},"支":{"docs":{},"持":{"docs":{},"以":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"组":{"docs":{},"件":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"提":{"docs":{},"供":{"docs":{},"，":{"docs":{},"当":{"docs":{},"然":{"docs":{},"你":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"实":{"docs":{},"现":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"组":{"docs":{},"件":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"下":{"docs":{},"列":{"docs":{},"功":{"docs":{},"能":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"两":{"docs":{},"种":{"docs":{},"开":{"docs":{},"箱":{"docs":{},"即":{"docs":{},"用":{"docs":{},"的":{"docs":{},"会":{"docs":{},"话":{"docs":{},"存":{"docs":{},"储":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"您":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"编":{"docs":{},"写":{"docs":{},"您":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"开":{"docs":{},"箱":{"docs":{},"即":{"docs":{},"用":{"docs":{},"的":{"docs":{},"会":{"docs":{},"话":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},"支":{"docs":{},"持":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"每":{"docs":{},"一":{"docs":{},"种":{"docs":{},"模":{"docs":{},"板":{"docs":{},"引":{"docs":{},"擎":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"若":{"docs":{},"干":{"docs":{},"开":{"docs":{},"箱":{"docs":{},"即":{"docs":{},"用":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"认":{"docs":{},"证":{"docs":{},"和":{"docs":{},"授":{"docs":{},"权":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"原":{"docs":{},"版":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"的":{"docs":{},"响":{"docs":{},"应":{"docs":{},"式":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"r":{"docs":{},"x":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"个":{"docs":{},"组":{"docs":{},"件":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"你":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"更":{"docs":{},"具":{"docs":{},"有":{"docs":{},"响":{"docs":{},"应":{"docs":{},"性":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"）":{"docs":{},"。":{"docs":{"reactive/Reactive.html":{"ref":"reactive/Reactive.html","tf":0.25}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"四":{"docs":{},"种":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"实":{"docs":{},"现":{"docs":{},"：":{"docs":{"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353}}}}}}}}}}}}},"不":{"docs":{},"止":{"docs":{},"一":{"docs":{},"种":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"商":{"docs":{},"会":{"docs":{},"需":{"docs":{},"要":{"docs":{},"您":{"docs":{},"来":{"docs":{},"提":{"docs":{},"供":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"作":{"docs":{},"出":{"docs":{},"少":{"docs":{},"许":{"docs":{},"的":{"docs":{},"修":{"docs":{},"改":{"docs":{},"。":{"docs":{},"为":{"docs":{},"此":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"网":{"docs":{},"页":{"docs":{},"图":{"docs":{},"标":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"性":{"docs":{},"质":{"docs":{},"（":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"、":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}},"流":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},")":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"去":{"docs":{},"获":{"docs":{},"取":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"流":{"docs":{},"是":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}},"倡":{"docs":{},"使":{"docs":{},"用":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"的":{"docs":{},"单":{"docs":{},"一":{"docs":{},"连":{"docs":{},"接":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"醒":{"docs":{},"：":{"docs":{},"不":{"docs":{},"要":{"docs":{},"在":{"docs":{},"生":{"docs":{},"产":{"docs":{},"设":{"docs":{},"置":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{},"密":{"docs":{},"钥":{"docs":{},"非":{"docs":{},"常":{"docs":{},"不":{"docs":{},"安":{"docs":{},"全":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"交":{"docs":{},"表":{"docs":{},"单":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"方":{"docs":{},"法":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"以":{"docs":{},"函":{"docs":{},"数":{"docs":{},"式":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"直":{"docs":{},"接":{"docs":{},"用":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}},"便":{"docs":{},"读":{"docs":{},"取":{"docs":{},"整":{"docs":{},"个":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"及":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}},"进":{"docs":{},"行":{"docs":{},"资":{"docs":{},"源":{"docs":{},"的":{"docs":{},"释":{"docs":{},"放":{"docs":{},"以":{"docs":{},"及":{"docs":{},"移":{"docs":{},"除":{"docs":{},"导":{"docs":{},"入":{"docs":{},"/":{"docs":{},"导":{"docs":{},"出":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"必":{"docs":{},"须":{"docs":{},"调":{"docs":{},"用":{"docs":{},"所":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"抛":{"docs":{},"出":{"docs":{},"异":{"docs":{},"常":{"docs":{},"，":{"docs":{},"则":{"docs":{},"会":{"docs":{},"立":{"docs":{},"即":{"docs":{},"跳":{"docs":{},"转":{"docs":{},"到":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}},"来":{"docs":{},"组":{"docs":{},"织":{"docs":{},"代":{"docs":{},"码":{"docs":{},"最":{"docs":{},"大":{"docs":{},"的":{"docs":{},"价":{"docs":{},"值":{"docs":{},"在":{"docs":{},"于":{"docs":{},"可":{"docs":{},"以":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}},"链":{"docs":{},"式":{"docs":{},"地":{"docs":{},"组":{"docs":{},"合":{"docs":{},"多":{"docs":{},"个":{"docs":{},"异":{"docs":{},"步":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{},"在":{"docs":{},"介":{"docs":{},"绍":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"用":{"docs":{},"途":{"docs":{},"时":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"先":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"一":{"docs":{},"个":{"docs":{},"传":{"docs":{},"统":{"docs":{},"的":{"docs":{},"同":{"docs":{},"步":{"docs":{},"操":{"docs":{},"作":{"docs":{},"和":{"docs":{},"异":{"docs":{},"常":{"docs":{},"处":{"docs":{},"理":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"。":{"docs":{},"假":{"docs":{},"设":{"docs":{},"我":{"docs":{},"们":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"同":{"docs":{},"步":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"串":{"docs":{},"起":{"docs":{},"一":{"docs":{},"个":{"docs":{},"带":{"docs":{},"操":{"docs":{},"作":{"docs":{},"结":{"docs":{},"果":{"docs":{},"的":{"docs":{},"或":{"docs":{},"失":{"docs":{},"败":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"做":{"docs":{},"这":{"docs":{},"个":{"docs":{},"事":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"会":{"docs":{},"以":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"关":{"docs":{},"闭":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"它":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}},"发":{"docs":{},"送":{"docs":{},"消":{"docs":{},"息":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"该":{"docs":{},"请":{"docs":{},"求":{"docs":{},"（":{"docs":{},"结":{"docs":{},"束":{"docs":{},"请":{"docs":{},"求":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"取":{"docs":{},"消":{"docs":{},"一":{"docs":{},"个":{"docs":{},"周":{"docs":{},"期":{"docs":{},"性":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"。":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"启":{"docs":{},"动":{"docs":{},"它":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"即":{"docs":{},"可":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"用":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"应":{"docs":{},"答":{"docs":{},"这":{"docs":{},"个":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"执":{"docs":{},"行":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"此":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{},"当":{"docs":{},"所":{"docs":{},"有":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"被":{"docs":{},"收":{"docs":{},"到":{"docs":{},"时":{"docs":{},"，":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"该":{"docs":{},"操":{"docs":{},"作":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"任":{"docs":{},"何":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"可":{"docs":{},"调":{"docs":{},"用":{"docs":{},"语":{"docs":{},"句":{"docs":{},"（":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}},"更":{"docs":{},"新":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"（":{"docs":{},"包":{"docs":{},"括":{"docs":{},"增":{"docs":{},"、":{"docs":{},"删":{"docs":{},"、":{"docs":{},"改":{"docs":{},"）":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}},"预":{"docs":{},"编":{"docs":{},"译":{"docs":{},"更":{"docs":{},"新":{"docs":{},"（":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}},"拒":{"docs":{},"绝":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"指":{"docs":{},"定":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"以":{"docs":{},"及":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"代":{"docs":{},"码":{"docs":{},"执":{"docs":{},"行":{"docs":{},"后":{"docs":{},"处":{"docs":{},"理":{"docs":{},"结":{"docs":{},"果":{"docs":{},"的":{"docs":{},"异":{"docs":{},"步":{"docs":{},"回":{"docs":{},"调":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"登":{"docs":{},"录":{"docs":{},"用":{"docs":{},"户":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"具":{"docs":{},"有":{"docs":{},"哪":{"docs":{},"些":{"docs":{},"权":{"docs":{},"限":{"docs":{},"才":{"docs":{},"允":{"docs":{},"许":{"docs":{},"访":{"docs":{},"问":{"docs":{},"这":{"docs":{},"个":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"您":{"docs":{},"想":{"docs":{},"隔":{"docs":{},"离":{"docs":{},"的":{"docs":{},"类":{"docs":{},"名":{"docs":{},"列":{"docs":{},"表":{"docs":{},"。":{"docs":{},"列":{"docs":{},"表":{"docs":{},"项":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"撤":{"docs":{},"销":{"docs":{},"部":{"docs":{},"署":{"docs":{},"好":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"更":{"docs":{},"改":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"读":{"docs":{},"取":{"docs":{},"位":{"docs":{},"置":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"偏":{"docs":{},"移":{"docs":{},"量":{"docs":{},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}},"新":{"docs":{},"文":{"docs":{},"档":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"建":{"docs":{},"议":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}},"注":{"docs":{},"销":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"获":{"docs":{},"得":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"实":{"docs":{},"际":{"docs":{},"监":{"docs":{},"听":{"docs":{},"的":{"docs":{},"端":{"docs":{},"口":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"事":{"docs":{},"件":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"原":{"docs":{},"始":{"docs":{},"内":{"docs":{},"容":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"集":{"docs":{},"合":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"被":{"docs":{},"包":{"docs":{},"装":{"docs":{},"成":{"docs":{},"了":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}},"取":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"列":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"用":{"docs":{},"于":{"docs":{},"读":{"docs":{},"取":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"的":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"内":{"docs":{},"存":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"数":{"docs":{},"量":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"缓":{"docs":{},"存":{"docs":{},"的":{"docs":{},"过":{"docs":{},"期":{"docs":{},"时":{"docs":{},"间":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"读":{"docs":{},"取":{"docs":{},"响":{"docs":{},"应":{"docs":{},"头":{"docs":{},"。":{"docs":{},"该":{"docs":{},"方":{"docs":{},"法":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"实":{"docs":{},"际":{"docs":{},"的":{"docs":{},"表":{"docs":{},"单":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"部":{"docs":{},"署":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"释":{"docs":{},"放":{"docs":{},"它":{"docs":{},"，":{"docs":{},"以":{"docs":{},"便":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"调":{"docs":{},"用":{"docs":{},"者":{"docs":{},"可":{"docs":{},"获":{"docs":{},"得":{"docs":{},"它":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"停":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"删":{"docs":{},"除":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"单":{"docs":{},"个":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"文":{"docs":{},"档":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"向":{"docs":{},"会":{"docs":{},"话":{"docs":{},"中":{"docs":{},"设":{"docs":{},"置":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"某":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"定":{"docs":{},"期":{"docs":{},"刷":{"docs":{},"新":{"docs":{},"生":{"docs":{},"成":{"docs":{},"器":{"docs":{},"的":{"docs":{},"种":{"docs":{},"子":{"docs":{},"，":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"找":{"docs":{},"出":{"docs":{},"真":{"docs":{},"正":{"docs":{},"被":{"docs":{},"接":{"docs":{},"受":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"访":{"docs":{},"问":{"docs":{},"会":{"docs":{},"话":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"选":{"docs":{},"择":{"docs":{},"适":{"docs":{},"当":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}},"重":{"docs":{},"新":{"docs":{},"启":{"docs":{},"用":{"docs":{},"它":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"销":{"docs":{},"毁":{"docs":{},"一":{"docs":{},"个":{"docs":{},"会":{"docs":{},"话":{"docs":{},"。":{"docs":{},"这":{"docs":{},"会":{"docs":{},"将":{"docs":{},"这":{"docs":{},"个":{"docs":{},"会":{"docs":{},"话":{"docs":{},"同":{"docs":{},"时":{"docs":{},"从":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"和":{"docs":{},"存":{"docs":{},"储":{"docs":{},"中":{"docs":{},"删":{"docs":{},"除":{"docs":{},"。":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"在":{"docs":{},"删":{"docs":{},"除":{"docs":{},"会":{"docs":{},"话":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"下":{"docs":{},"一":{"docs":{},"次":{"docs":{},"通":{"docs":{},"过":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"访":{"docs":{},"问":{"docs":{},"并":{"docs":{},"经":{"docs":{},"过":{"docs":{},"会":{"docs":{},"话":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"处":{"docs":{},"理":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"创":{"docs":{},"建":{"docs":{},"新":{"docs":{},"的":{"docs":{},"会":{"docs":{},"话":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"保":{"docs":{},"存":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"集":{"docs":{},"合":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}},"插":{"docs":{},"入":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"替":{"docs":{},"换":{"docs":{},"文":{"docs":{},"档":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"计":{"docs":{},"算":{"docs":{},"文":{"docs":{},"档":{"docs":{},"数":{"docs":{},"量":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"处":{"docs":{},"理":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},"订":{"docs":{},"阅":{"docs":{},"一":{"docs":{},"个":{"docs":{},"或":{"docs":{},"多":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"进":{"docs":{},"行":{"docs":{},"流":{"docs":{},"量":{"docs":{},"控":{"docs":{},"制":{"docs":{},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}},"通":{"docs":{},"过":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}},"需":{"docs":{},"要":{"docs":{},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0010218300046446818},"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"当":{"docs":{},"您":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"它":{"docs":{},"和":{"docs":{},"先":{"docs":{},"调":{"docs":{},"用":{"docs":{},"带":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"之":{"docs":{},"后":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"点":{"docs":{},"调":{"docs":{},"用":{"docs":{},"它":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"示":{"docs":{},"例":{"docs":{},"代":{"docs":{},"码":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"编":{"docs":{},"解":{"docs":{},"码":{"docs":{},"器":{"docs":{},"将":{"docs":{},"响":{"docs":{},"应":{"docs":{},"结":{"docs":{},"果":{"docs":{},"压":{"docs":{},"入":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}},"一":{"docs":{},"样":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"它":{"docs":{},"也":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"次":{"docs":{},"性":{"docs":{},"加":{"docs":{},"载":{"docs":{},"它":{"docs":{},"，":{"docs":{},"并":{"docs":{},"直":{"docs":{},"接":{"docs":{},"将":{"docs":{},"其":{"docs":{},"写":{"docs":{},"入":{"docs":{},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{},"注":{"docs":{},"解":{"docs":{},"来":{"docs":{},"定":{"docs":{},"义":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"中":{"docs":{},"手":{"docs":{},"工":{"docs":{},"去":{"docs":{},"撤":{"docs":{},"销":{"docs":{},"启":{"docs":{},"动":{"docs":{},"时":{"docs":{},"部":{"docs":{},"署":{"docs":{},"的":{"docs":{},"子":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"读":{"docs":{},"取":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"部":{"docs":{},"署":{"docs":{},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"阻":{"docs":{},"塞":{"docs":{},"等":{"docs":{},"待":{"docs":{},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"，":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"是":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"为":{"docs":{},"每":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"配":{"docs":{},"置":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"连":{"docs":{},"接":{"docs":{},"数":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"路":{"docs":{},"由":{"docs":{},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"此":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"解":{"docs":{},"决":{"docs":{},"方":{"docs":{},"案":{"docs":{},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}},"观":{"docs":{},"察":{"docs":{},"者":{"docs":{},"（":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"和":{"docs":{},"事":{"docs":{},"件":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"做":{"docs":{},"了":{"docs":{},"适":{"docs":{},"配":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"之":{"docs":{},"后":{"docs":{},"再":{"docs":{},"调":{"docs":{},"用":{"docs":{},"无":{"docs":{},"参":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"也":{"docs":{},"会":{"docs":{},"（":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"）":{"docs":{},"覆":{"docs":{},"盖":{"docs":{},"默":{"docs":{},"认":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"设":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"一":{"docs":{},"段":{"docs":{},"时":{"docs":{},"间":{"docs":{},"过":{"docs":{},"后":{"docs":{},"它":{"docs":{},"会":{"docs":{},"通":{"docs":{},"知":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"并":{"docs":{},"传":{"docs":{},"入":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"从":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"对":{"docs":{},"象":{"docs":{},"中":{"docs":{},"获":{"docs":{},"取":{"docs":{},"值":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"读":{"docs":{},"取":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"中":{"docs":{},"查":{"docs":{},"询":{"docs":{},"响":{"docs":{},"应":{"docs":{},"的":{"docs":{},"状":{"docs":{},"态":{"docs":{},"码":{"docs":{},"和":{"docs":{},"状":{"docs":{},"态":{"docs":{},"消":{"docs":{},"息":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"获":{"docs":{},"取":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{},"并":{"docs":{},"提":{"docs":{},"供":{"docs":{},"文":{"docs":{},"件":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"中":{"docs":{},"获":{"docs":{},"取":{"docs":{},"任":{"docs":{},"何":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"）":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}},"返":{"docs":{},"回":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"上":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"请":{"docs":{},"求":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"连":{"docs":{},"接":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"立":{"docs":{},"即":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"传":{"docs":{},"递":{"docs":{},"延":{"docs":{},"迟":{"docs":{},"时":{"docs":{},"间":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"设":{"docs":{},"置":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"的":{"docs":{},"触":{"docs":{},"发":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}},"作":{"docs":{},"用":{"docs":{},"于":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"组":{"docs":{},"合":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"关":{"docs":{},"闭":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"它":{"docs":{},"。":{"docs":{},"这":{"docs":{},"将":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"所":{"docs":{},"有":{"docs":{},"内":{"docs":{},"部":{"docs":{},"线":{"docs":{},"程":{"docs":{},"池":{"docs":{},"并":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"其":{"docs":{},"他":{"docs":{},"资":{"docs":{},"源":{"docs":{},"，":{"docs":{},"允":{"docs":{},"许":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"退":{"docs":{},"出":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"底":{"docs":{},"层":{"docs":{},"的":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"。":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"操":{"docs":{},"作":{"docs":{},"将":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"所":{"docs":{},"有":{"docs":{},"打":{"docs":{},"开":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"并":{"docs":{},"释":{"docs":{},"放":{"docs":{},"所":{"docs":{},"有":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"资":{"docs":{},"源":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"连":{"docs":{},"接":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"即":{"docs":{},"可":{"docs":{},"，":{"docs":{},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"释":{"docs":{},"放":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}},"写":{"docs":{},"入":{"docs":{},"数":{"docs":{},"据":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"以":{"docs":{},"下":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"头":{"docs":{},"属":{"docs":{},"性":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}},"创":{"docs":{},"建":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"一":{"docs":{},"个":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"副":{"docs":{},"本":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{},"请":{"docs":{},"指":{"docs":{},"定":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"的":{"docs":{},"端":{"docs":{},"口":{"docs":{},"和":{"docs":{},"主":{"docs":{},"机":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"用":{"docs":{},"于":{"docs":{},"处":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"远":{"docs":{},"程":{"docs":{},"主":{"docs":{},"机":{"docs":{},"的":{"docs":{},"通":{"docs":{},"道":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"帧":{"docs":{},"，":{"docs":{},"并":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"。":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"多":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"的":{"docs":{},"调":{"docs":{},"度":{"docs":{},"器":{"docs":{},"钩":{"docs":{},"子":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}},"发":{"docs":{},"送":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"出":{"docs":{},"去":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"消":{"docs":{},"息":{"docs":{},"时":{"docs":{},"，":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"表":{"docs":{},"单":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"j":{"docs":{},"o":{"docs":{},"（":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"体":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}},"流":{"docs":{},"式":{"docs":{},"数":{"docs":{},"据":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"值":{"docs":{},"放":{"docs":{},"入":{"docs":{},"到":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"里":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"当":{"docs":{},"成":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"同":{"docs":{},"时":{"docs":{},"向":{"docs":{},"有":{"docs":{},"序":{"docs":{},"集":{"docs":{},"合":{"docs":{},"中":{"docs":{},"添":{"docs":{},"加":{"docs":{},"多":{"docs":{},"个":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"需":{"docs":{},"要":{"docs":{},"注":{"docs":{},"意":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}}}}},"添":{"docs":{},"加":{"docs":{},"多":{"docs":{},"个":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}},"列":{"docs":{},"出":{"docs":{},"当":{"docs":{},"前":{"docs":{},"分":{"docs":{},"配":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"下":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"这":{"docs":{},"样":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}},"用":{"docs":{},"来":{"docs":{},"解":{"docs":{},"析":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"用":{"docs":{},"于":{"docs":{},"非":{"docs":{},"标":{"docs":{},"准":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"重":{"docs":{},"复":{"docs":{},"多":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"这":{"docs":{},"使":{"docs":{},"得":{"docs":{},"配":{"docs":{},"置":{"docs":{},"以":{"docs":{},"及":{"docs":{},"重":{"docs":{},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}},"启":{"docs":{},"用":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"和":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}},"缓":{"docs":{},"存":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"执":{"docs":{},"行":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"在":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"每":{"docs":{},"次":{"docs":{},"写":{"docs":{},"入":{"docs":{},"时":{"docs":{},"启":{"docs":{},"用":{"docs":{},"/":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"内":{"docs":{},"容":{"docs":{},"的":{"docs":{},"自":{"docs":{},"动":{"docs":{},"同":{"docs":{},"步":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"中":{"docs":{},"获":{"docs":{},"取":{"docs":{},"到":{"docs":{},"该":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"均":{"docs":{},"不":{"docs":{},"接":{"docs":{},"收":{"docs":{},"异":{"docs":{},"常":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"做":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"完":{"docs":{},"成":{"docs":{},"的":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"大":{"docs":{},"文":{"docs":{},"件":{"docs":{},"处":{"docs":{},"理":{"docs":{},"通":{"docs":{},"常":{"docs":{},"更":{"docs":{},"有":{"docs":{},"效":{"docs":{},"，":{"docs":{},"而":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"对":{"docs":{},"于":{"docs":{},"小":{"docs":{},"文":{"docs":{},"件":{"docs":{},"可":{"docs":{},"能":{"docs":{},"很":{"docs":{},"慢":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"调":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"时":{"docs":{},"，":{"docs":{},"需":{"docs":{},"将":{"docs":{},"想":{"docs":{},"要":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"异":{"docs":{},"步":{"docs":{},"操":{"docs":{},"作":{"docs":{},"包":{"docs":{},"装":{"docs":{},"成":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}},"成":{"docs":{},"的":{"docs":{},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}},"将":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}},"一":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"编":{"docs":{},"码":{"docs":{},"成":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"格":{"docs":{},"式":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"先":{"docs":{},"将":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"写":{"docs":{},"入":{"docs":{},"到":{"docs":{},"请":{"docs":{},"求":{"docs":{},"报":{"docs":{},"文":{"docs":{},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"其":{"docs":{},"写":{"docs":{},"入":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"直":{"docs":{},"接":{"docs":{},"写":{"docs":{},"入":{"docs":{},"响":{"docs":{},"应":{"docs":{},"中":{"docs":{},"并":{"docs":{},"发":{"docs":{},"回":{"docs":{},"到":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"禁":{"docs":{},"用":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}},"发":{"docs":{},"送":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"导":{"docs":{},"致":{"docs":{},"新":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"块":{"docs":{},"被":{"docs":{},"写":{"docs":{},"入":{"docs":{},"到":{"docs":{},"报":{"docs":{},"文":{"docs":{},"，":{"docs":{},"这":{"docs":{},"种":{"docs":{},"模":{"docs":{},"式":{"docs":{},"中":{"docs":{},"，":{"docs":{},"无":{"docs":{},"需":{"docs":{},"先":{"docs":{},"设":{"docs":{},"置":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"中":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"据":{"docs":{},"放":{"docs":{},"入":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"。":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"完":{"docs":{},"成":{"docs":{},"它":{"docs":{},"会":{"docs":{},"通":{"docs":{},"知":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"文":{"docs":{},"件":{"docs":{},"和":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"无":{"docs":{},"符":{"docs":{},"号":{"docs":{},"数":{"docs":{},"从":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"版":{"docs":{},"本":{"docs":{},"设":{"docs":{},"置":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"成":{"docs":{},"后":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"就":{"docs":{},"是":{"docs":{},"这":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"；":{"docs":{},"且":{"docs":{},"其":{"docs":{},"后":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"额":{"docs":{},"外":{"docs":{},"的":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"这":{"docs":{},"里":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"写":{"docs":{},"入":{"docs":{},"流":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"能":{"docs":{},"周":{"docs":{},"期":{"docs":{},"性":{"docs":{},"发":{"docs":{},"射":{"docs":{},"事":{"docs":{},"件":{"docs":{},"的":{"docs":{},"定":{"docs":{},"时":{"docs":{},"器":{"docs":{},"并":{"docs":{},"返":{"docs":{},"回":{"docs":{},"之":{"docs":{},"。":{"docs":{},"缺":{"docs":{},"省":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"可":{"docs":{},"调":{"docs":{},"度":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"由":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"注":{"docs":{},"册":{"docs":{},"时":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"对":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"进":{"docs":{},"行":{"docs":{},"一":{"docs":{},"些":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{},"当":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"配":{"docs":{},"置":{"docs":{},"好":{"docs":{},"了":{"docs":{},"，":{"docs":{},"已":{"docs":{},"经":{"docs":{},"准":{"docs":{},"备":{"docs":{},"导":{"docs":{},"入":{"docs":{},"导":{"docs":{},"出":{"docs":{},"初":{"docs":{},"始":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"时":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"或":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"者":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"手":{"docs":{},"动":{"docs":{},"刷":{"docs":{},"新":{"docs":{},"o":{"docs":{},"s":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"中":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"写":{"docs":{},"入":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"查":{"docs":{},"询":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}},"结":{"docs":{},"束":{"docs":{},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"回":{"docs":{},"调":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"事":{"docs":{},"务":{"docs":{},"也":{"docs":{},"将":{"docs":{},"自":{"docs":{},"动":{"docs":{},"开":{"docs":{},"始":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}},"预":{"docs":{},"编":{"docs":{},"译":{"docs":{},"查":{"docs":{},"询":{"docs":{},"（":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"在":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"一":{"docs":{},"个":{"docs":{},"地":{"docs":{},"址":{"docs":{},"去":{"docs":{},"发":{"docs":{},"布":{"docs":{},"即":{"docs":{},"可":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"状":{"docs":{},"态":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"接":{"docs":{},"受":{"docs":{},"多":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}},"提":{"docs":{},"供":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"了":{"docs":{},"带":{"docs":{},"有":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"时":{"docs":{},"指":{"docs":{},"定":{"docs":{},"主":{"docs":{},"机":{"docs":{},"和":{"docs":{},"端":{"docs":{},"口":{"docs":{},"号":{"docs":{},"，":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"中":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"这":{"docs":{},"样":{"docs":{},"就":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"了":{"docs":{},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"（":{"docs":{},"中":{"docs":{},"的":{"docs":{},"主":{"docs":{},"机":{"docs":{},"和":{"docs":{},"端":{"docs":{},"口":{"docs":{},"）":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"关":{"docs":{},"联":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"将":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"加":{"docs":{},"上":{"docs":{},"了":{"docs":{},"具":{"docs":{},"有":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"名":{"docs":{},"称":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}},"绑":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"显":{"docs":{},"式":{"docs":{},"声":{"docs":{},"明":{"docs":{},"失":{"docs":{},"败":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"指":{"docs":{},"定":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}},"检":{"docs":{},"查":{"docs":{},"响":{"docs":{},"应":{"docs":{},"实":{"docs":{},"际":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"版":{"docs":{},"本":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"注":{"docs":{},"册":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"一":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"下":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"传":{"docs":{},"递":{"docs":{},"一":{"docs":{},"些":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"信":{"docs":{},"息":{"docs":{},"给":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"销":{"docs":{},"某":{"docs":{},"个":{"docs":{},"消":{"docs":{},"息":{"docs":{},"编":{"docs":{},"解":{"docs":{},"码":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"添":{"docs":{},"加":{"docs":{},"/":{"docs":{},"删":{"docs":{},"除":{"docs":{},"命":{"docs":{},"令":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"数":{"docs":{},"组":{"docs":{},"项":{"docs":{},"到":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"的":{"docs":{},"一":{"docs":{},"段":{"docs":{},"时":{"docs":{},"间":{"docs":{},"之":{"docs":{},"后":{"docs":{},"才":{"docs":{},"会":{"docs":{},"实":{"docs":{},"际":{"docs":{},"开":{"docs":{},"始":{"docs":{},"监":{"docs":{},"听":{"docs":{},"。":{"docs":{},"若":{"docs":{},"您":{"docs":{},"希":{"docs":{},"望":{"docs":{},"在":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"实":{"docs":{},"际":{"docs":{},"监":{"docs":{},"听":{"docs":{},"时":{"docs":{},"收":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"同":{"docs":{},"时":{"docs":{},"也":{"docs":{},"必":{"docs":{},"须":{"docs":{},"包":{"docs":{},"含":{"docs":{},"在":{"docs":{},"包":{"docs":{},"装":{"docs":{},"命":{"docs":{},"令":{"docs":{},"的":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}},"合":{"docs":{},"并":{"docs":{},"会":{"docs":{},"等":{"docs":{},"待":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"成":{"docs":{},"功":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"。":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"中":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"，":{"docs":{},"它":{"docs":{},"为":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"也":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"的":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"i":{"docs":{},"d":{"docs":{},"，":{"docs":{},"若":{"docs":{},"之":{"docs":{},"后":{"docs":{},"该":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"需":{"docs":{},"要":{"docs":{},"取":{"docs":{},"消":{"docs":{},"则":{"docs":{},"使":{"docs":{},"用":{"docs":{},"该":{"docs":{},"i":{"docs":{},"d":{"docs":{},"。":{"docs":{},"传":{"docs":{},"给":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"也":{"docs":{},"是":{"docs":{},"这":{"docs":{},"个":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"的":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"i":{"docs":{},"d":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"就":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"才":{"docs":{},"会":{"docs":{},"真":{"docs":{},"正":{"docs":{},"的":{"docs":{},"根":{"docs":{},"据":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},"地":{"docs":{},"根":{"docs":{},"据":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"直":{"docs":{},"接":{"docs":{},"传":{"docs":{},"进":{"docs":{},"去":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"在":{"docs":{},"相":{"docs":{},"关":{"docs":{},"配":{"docs":{},"置":{"docs":{},"中":{"docs":{},"指":{"docs":{},"定":{"docs":{},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"直":{"docs":{},"接":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"相":{"docs":{},"同":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"比":{"docs":{},"，":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}},"绑":{"docs":{},"定":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"的":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"编":{"docs":{},"写":{"docs":{},"头":{"docs":{},"文":{"docs":{},"件":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"获":{"docs":{},"取":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"长":{"docs":{},"度":{"docs":{},"，":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"长":{"docs":{},"度":{"docs":{},"值":{"docs":{},"是":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"的":{"docs":{},"字":{"docs":{},"节":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"索":{"docs":{},"引":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"实":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{},"或":{"docs":{},"者":{"docs":{},"通":{"docs":{},"过":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}},"它":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"锁":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"指":{"docs":{},"定":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}},"所":{"docs":{},"有":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"查":{"docs":{},"找":{"docs":{},"只":{"docs":{},"会":{"docs":{},"包":{"docs":{},"含":{"docs":{},"状":{"docs":{},"态":{"docs":{},"为":{"docs":{},"u":{"docs":{},"p":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"如":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"覆":{"docs":{},"盖":{"docs":{},"默":{"docs":{},"认":{"docs":{},"设":{"docs":{},"置":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"得":{"docs":{},"。":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"被":{"docs":{},"包":{"docs":{},"装":{"docs":{},"成":{"docs":{},"了":{"docs":{},"一":{"docs":{},"组":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}},"更":{"docs":{},"新":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"条":{"docs":{},"数":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"如":{"docs":{},"果":{"docs":{},"更":{"docs":{},"新":{"docs":{},"操":{"docs":{},"作":{"docs":{},"有":{"docs":{},"生":{"docs":{},"成":{"docs":{},"主":{"docs":{},"键":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}},"查":{"docs":{},"询":{"docs":{},"结":{"docs":{},"果":{"docs":{},"的":{"docs":{},"列":{"docs":{},"名":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"组":{"docs":{},"成":{"docs":{},"的":{"docs":{},"新":{"docs":{},"流":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}},"适":{"docs":{},"用":{"docs":{},"的":{"docs":{},"调":{"docs":{},"度":{"docs":{},"器":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}},"被":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"过":{"docs":{},"后":{"docs":{},"，":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"裁":{"docs":{},"剪":{"docs":{},"一":{"docs":{},"个":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"让":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"持":{"docs":{},"续":{"docs":{},"发":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"其":{"docs":{},"他":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"设":{"docs":{},"置":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"一":{"docs":{},"个":{"docs":{},"周":{"docs":{},"期":{"docs":{},"性":{"docs":{},"触":{"docs":{},"发":{"docs":{},"的":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"。":{"docs":{},"第":{"docs":{},"一":{"docs":{},"次":{"docs":{},"触":{"docs":{},"发":{"docs":{},"之":{"docs":{},"前":{"docs":{},"同":{"docs":{},"样":{"docs":{},"会":{"docs":{},"有":{"docs":{},"一":{"docs":{},"段":{"docs":{},"设":{"docs":{},"置":{"docs":{},"的":{"docs":{},"延":{"docs":{},"时":{"docs":{},"时":{"docs":{},"间":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"每":{"docs":{},"次":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"的":{"docs":{},"一":{"docs":{},"小":{"docs":{},"块":{"docs":{},"数":{"docs":{},"据":{"docs":{},"收":{"docs":{},"到":{"docs":{},"时":{"docs":{},"，":{"docs":{},"该":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"都":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"以":{"docs":{},"下":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"不":{"docs":{},"同":{"docs":{},"状":{"docs":{},"态":{"docs":{},"代":{"docs":{},"码":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"成":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"解":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"是":{"docs":{},"被":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"此":{"docs":{},"选":{"docs":{},"项":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"的":{"docs":{},"等":{"docs":{},"待":{"docs":{},"响":{"docs":{},"应":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"请":{"docs":{},"求":{"docs":{},"数":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"限":{"docs":{},"制":{"docs":{},"可":{"docs":{},"以":{"docs":{},"确":{"docs":{},"保":{"docs":{},"和":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"分":{"docs":{},"发":{"docs":{},"到":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{},"公":{"docs":{},"平":{"docs":{},"性":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{},"只":{"docs":{},"读":{"docs":{},"属":{"docs":{},"性":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"的":{"docs":{},"模":{"docs":{},"板":{"docs":{},"来":{"docs":{},"渲":{"docs":{},"染":{"docs":{},"文":{"docs":{},"件":{"docs":{},"列":{"docs":{},"表":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"超":{"docs":{},"时":{"docs":{},"时":{"docs":{},"间":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}},"自":{"docs":{},"动":{"docs":{},"提":{"docs":{},"交":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}},"访":{"docs":{},"问":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"读":{"docs":{},"取":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"中":{"docs":{},"的":{"docs":{},"路":{"docs":{},"径":{"docs":{},"部":{"docs":{},"分":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"路":{"docs":{},"径":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"发":{"docs":{},"送":{"docs":{},"者":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{},"返":{"docs":{},"回":{"docs":{},"后":{"docs":{},"一":{"docs":{},"段":{"docs":{},"时":{"docs":{},"间":{"docs":{},"才":{"docs":{},"会":{"docs":{},"完":{"docs":{},"成":{"docs":{},"部":{"docs":{},"署":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"的":{"docs":{},"某":{"docs":{},"些":{"docs":{},"操":{"docs":{},"作":{"docs":{},"中":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{},"像":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"发":{"docs":{},"送":{"docs":{},"的":{"docs":{},"实":{"docs":{},"际":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"时":{"docs":{},"监":{"docs":{},"听":{"docs":{},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"在":{"docs":{},"一":{"docs":{},"段":{"docs":{},"时":{"docs":{},"间":{"docs":{},"过":{"docs":{},"后":{"docs":{},"才":{"docs":{},"监":{"docs":{},"听":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"过":{"docs":{},"后":{"docs":{},"一":{"docs":{},"段":{"docs":{},"时":{"docs":{},"间":{"docs":{},"才":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"被":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"的":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"要":{"docs":{},"和":{"docs":{},"关":{"docs":{},"联":{"docs":{},"到":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}},"进":{"docs":{},"行":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"未":{"docs":{},"启":{"docs":{},"用":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"手":{"docs":{},"动":{"docs":{},"提":{"docs":{},"交":{"docs":{},"。":{"docs":{},"手":{"docs":{},"动":{"docs":{},"提":{"docs":{},"交":{"docs":{},"偏":{"docs":{},"移":{"docs":{},"量":{"docs":{},"通":{"docs":{},"常":{"docs":{},"用":{"docs":{},"于":{"docs":{},"确":{"docs":{},"保":{"docs":{},"消":{"docs":{},"息":{"docs":{},"分":{"docs":{},"发":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}},"封":{"docs":{},"装":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"所":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}},"追":{"docs":{},"加":{"docs":{},"数":{"docs":{},"据":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"都":{"docs":{},"会":{"docs":{},"将":{"docs":{},"索":{"docs":{},"引":{"docs":{},"值":{"docs":{},"作":{"docs":{},"为":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"次":{"docs":{},"回":{"docs":{},"调":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"对":{"docs":{},"应":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"文":{"docs":{},"件":{"docs":{},"访":{"docs":{},"问":{"docs":{},"权":{"docs":{},"限":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"特":{"docs":{},"定":{"docs":{},"值":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"该":{"docs":{},"选":{"docs":{},"项":{"docs":{},"接":{"docs":{},"收":{"docs":{},"多":{"docs":{},"个":{"docs":{},"值":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"和":{"docs":{},"命":{"docs":{},"令":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"隐":{"docs":{},"藏":{"docs":{},"选":{"docs":{},"项":{"docs":{},"，":{"docs":{},"隐":{"docs":{},"藏":{"docs":{},"选":{"docs":{},"项":{"docs":{},"不":{"docs":{},"在":{"docs":{},"用":{"docs":{},"法":{"docs":{},"中":{"docs":{},"列":{"docs":{},"出":{"docs":{},"，":{"docs":{},"但":{"docs":{},"仍":{"docs":{},"可":{"docs":{},"在":{"docs":{},"用":{"docs":{},"户":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"（":{"docs":{},"针":{"docs":{},"对":{"docs":{},"高":{"docs":{},"级":{"docs":{},"用":{"docs":{},"户":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"它":{"docs":{},"会":{"docs":{},"把":{"docs":{},"你":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"导":{"docs":{},"入":{"docs":{},"/":{"docs":{},"导":{"docs":{},"出":{"docs":{},"模":{"docs":{},"块":{"docs":{},"都":{"docs":{},"关":{"docs":{},"掉":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"释":{"docs":{},"放":{"docs":{},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"之":{"docs":{},"后":{"docs":{},"调":{"docs":{},"用":{"docs":{},"无":{"docs":{},"参":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"以":{"docs":{},"下":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"但":{"docs":{},"是":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"在":{"docs":{},"推":{"docs":{},"送":{"docs":{},"响":{"docs":{},"应":{"docs":{},"过":{"docs":{},"后":{"docs":{},"依":{"docs":{},"然":{"docs":{},"可":{"docs":{},"以":{"docs":{},"写":{"docs":{},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"仅":{"docs":{},"仅":{"docs":{},"返":{"docs":{},"回":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"想":{"docs":{},"做":{"docs":{},"一":{"docs":{},"些":{"docs":{},"耗":{"docs":{},"时":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"它":{"docs":{},"将":{"docs":{},"会":{"docs":{},"通":{"docs":{},"过":{"docs":{},"用":{"docs":{},"户":{"docs":{},"空":{"docs":{},"间":{"docs":{},"进":{"docs":{},"行":{"docs":{},"复":{"docs":{},"制":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"若":{"docs":{},"内":{"docs":{},"核":{"docs":{},"将":{"docs":{},"数":{"docs":{},"据":{"docs":{},"直":{"docs":{},"接":{"docs":{},"从":{"docs":{},"磁":{"docs":{},"盘":{"docs":{},"复":{"docs":{},"制":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"于":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"提":{"docs":{},"供":{"docs":{},"通":{"docs":{},"用":{"docs":{},"请":{"docs":{},"求":{"docs":{},"方":{"docs":{},"法":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"当":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"任":{"docs":{},"务":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"成":{"docs":{},"时":{"docs":{},"设":{"docs":{},"置":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"然":{"docs":{},"后":{"docs":{},"在":{"docs":{},"整":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"都":{"docs":{},"被":{"docs":{},"读":{"docs":{},"取":{"docs":{},"后":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"儿":{"docs":{},"有":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"从":{"docs":{},"这":{"docs":{},"个":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"在":{"docs":{},"参":{"docs":{},"数":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"那":{"docs":{},"么":{"docs":{},"当":{"docs":{},"出":{"docs":{},"现":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}},"用":{"docs":{},"于":{"docs":{},"获":{"docs":{},"取":{"docs":{},"给":{"docs":{},"定":{"docs":{},"分":{"docs":{},"区":{"docs":{},"末":{"docs":{},"端":{"docs":{},"的":{"docs":{},"偏":{"docs":{},"移":{"docs":{},"量":{"docs":{},"值":{"docs":{},"。":{"docs":{},"与":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}},"其":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"调":{"docs":{},"度":{"docs":{},"器":{"docs":{},"可":{"docs":{},"供":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}},"向":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"设":{"docs":{},"置":{"docs":{},"任":{"docs":{},"何":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"值":{"docs":{},"进":{"docs":{},"行":{"docs":{},"比":{"docs":{},"较":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"多":{"docs":{},"次":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"引":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"复":{"docs":{},"制":{"docs":{},"一":{"docs":{},"份":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"只":{"docs":{},"返":{"docs":{},"回":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}},"并":{"docs":{},"传":{"docs":{},"递":{"docs":{},"参":{"docs":{},"数":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"替":{"docs":{},"换":{"docs":{},"的":{"docs":{},"是":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"查":{"docs":{},"找":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"询":{"docs":{},"到":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"条":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}},"类":{"docs":{},"似":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"并":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"把":{"docs":{},"连":{"docs":{},"接":{"docs":{},"返":{"docs":{},"回":{"docs":{},"给":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}},"；":{"docs":{},"在":{"docs":{},"需":{"docs":{},"要":{"docs":{},"回":{"docs":{},"滚":{"docs":{},"时":{"docs":{},"，":{"docs":{},"调":{"docs":{},"用":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}},"目":{"docs":{},"前":{"docs":{},"暂":{"docs":{},"未":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}},"不":{"docs":{},"会":{"docs":{},"更":{"docs":{},"改":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"了":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"的":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"与":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"你":{"docs":{},"并":{"docs":{},"不":{"docs":{},"知":{"docs":{},"道":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"操":{"docs":{},"作":{"docs":{},"什":{"docs":{},"么":{"docs":{},"时":{"docs":{},"候":{"docs":{},"完":{"docs":{},"成":{"docs":{},"或":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"这":{"docs":{},"时":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"注":{"docs":{},"册":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"(":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"来":{"docs":{},"监":{"docs":{},"听":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"完":{"docs":{},"成":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{},"当":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"操":{"docs":{},"作":{"docs":{},"彻":{"docs":{},"底":{"docs":{},"完":{"docs":{},"成":{"docs":{},"以":{"docs":{},"后":{"docs":{},"，":{"docs":{},"注":{"docs":{},"册":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"很":{"docs":{},"适":{"docs":{},"合":{"docs":{},"的":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"地":{"docs":{},"方":{"docs":{},"不":{"docs":{},"同":{"docs":{},"：":{"docs":{},"b":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"分":{"docs":{},"配":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"分":{"docs":{},"区":{"docs":{},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},"退":{"docs":{},"出":{"docs":{},"该":{"docs":{},"消":{"docs":{},"费":{"docs":{},"组":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"不":{"docs":{},"再":{"docs":{},"接":{"docs":{},"受":{"docs":{},"到":{"docs":{},"相":{"docs":{},"关":{"docs":{},"消":{"docs":{},"息":{"docs":{},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}},"里":{"docs":{},"指":{"docs":{},"明":{"docs":{},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"与":{"docs":{},"反":{"docs":{},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{},"类":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}},"自":{"docs":{},"动":{"docs":{},"完":{"docs":{},"成":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"部":{"docs":{},"署":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}},"对":{"docs":{},"到":{"docs":{},"达":{"docs":{},"的":{"docs":{},"每":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"都":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"回":{"docs":{},"调":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}},"此":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"次":{"docs":{},"性":{"docs":{},"的":{"docs":{},"回":{"docs":{},"调":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}},"释":{"docs":{},"放":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"都":{"docs":{},"会":{"docs":{},"有":{"docs":{},"事":{"docs":{},"件":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"这":{"docs":{},"里":{"docs":{},"的":{"docs":{},"x":{"docs":{},"指":{"docs":{},"的":{"docs":{},"是":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"）":{"docs":{},"等":{"docs":{},"等":{"docs":{},"。":{"docs":{},"可":{"docs":{},"以":{"docs":{},"查":{"docs":{},"看":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"去":{"docs":{},"向":{"docs":{},"调":{"docs":{},"用":{"docs":{},"端":{"docs":{},"发":{"docs":{},"送":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}},"式":{"docs":{},"返":{"docs":{},"回":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}},"读":{"docs":{},"取":{"docs":{},"配":{"docs":{},"置":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"无":{"docs":{},"关":{"docs":{},"）":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"论":{"docs":{},"是":{"docs":{},"否":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"/":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"和":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"都":{"docs":{},"是":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"创":{"docs":{},"建":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"/":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"没":{"docs":{},"有":{"docs":{},"用":{"docs":{},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"，":{"docs":{},"都":{"docs":{},"应":{"docs":{},"该":{"docs":{},"用":{"docs":{},"上":{"docs":{},"面":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"编":{"docs":{},"写":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"样":{"docs":{},"允":{"docs":{},"许":{"docs":{},"服":{"docs":{},"务":{"docs":{},"交":{"docs":{},"互":{"docs":{},"时":{"docs":{},"保":{"docs":{},"持":{"docs":{},"一":{"docs":{},"致":{"docs":{},"性":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"的":{"docs":{},"简":{"docs":{},"单":{"docs":{},"请":{"docs":{},"求":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}},"状":{"docs":{},"态":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}},"法":{"docs":{},"连":{"docs":{},"接":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"早":{"docs":{},"期":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}},"替":{"docs":{},"换":{"docs":{},"为":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}},"文":{"docs":{},"档":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"代":{"docs":{},"方":{"docs":{},"案":{"docs":{},"是":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"，":{"docs":{},"前":{"docs":{},"提":{"docs":{},"是":{"docs":{},"在":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"粗":{"docs":{},"暴":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"判":{"docs":{},"断":{"docs":{},"同":{"docs":{},"步":{"docs":{},"还":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"就":{"docs":{},"看":{"docs":{},"给":{"docs":{},"出":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"或":{"docs":{},"者":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"，":{"docs":{},"是":{"docs":{},"否":{"docs":{},"有":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"有":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"且":{"docs":{},"这":{"docs":{},"个":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"，":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"判":{"docs":{},"断":{"docs":{},"该":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"或":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"启":{"docs":{},"动":{"docs":{},"失":{"docs":{},"败":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"些":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"，":{"docs":{},"若":{"docs":{},"部":{"docs":{},"署":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"段":{"docs":{},"时":{"docs":{},"间":{"docs":{},"没":{"docs":{},"有":{"docs":{},"响":{"docs":{},"应":{"docs":{},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"记":{"docs":{},"录":{"docs":{},"这":{"docs":{},"种":{"docs":{},"警":{"docs":{},"告":{"docs":{},"。":{"docs":{},"若":{"docs":{},"您":{"docs":{},"在":{"docs":{},"日":{"docs":{},"志":{"docs":{},"中":{"docs":{},"看":{"docs":{},"到":{"docs":{},"类":{"docs":{},"似":{"docs":{},"警":{"docs":{},"告":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"检":{"docs":{},"查":{"docs":{},"您":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"两":{"docs":{},"种":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"些":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"时":{"docs":{},"候":{"docs":{},"您":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"以":{"docs":{},"下":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"选":{"docs":{},"项":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"关":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"更":{"docs":{},"多":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}},"详":{"docs":{},"细":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"请":{"docs":{},"查":{"docs":{},"看":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"详":{"docs":{},"情":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}},"详":{"docs":{},"细":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"可":{"docs":{},"能":{"docs":{},"只":{"docs":{},"需":{"docs":{},"发":{"docs":{},"送":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"时":{"docs":{},"候":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"您":{"docs":{},"想":{"docs":{},"只":{"docs":{},"在":{"docs":{},"特":{"docs":{},"定":{"docs":{},"时":{"docs":{},"间":{"docs":{},"内":{"docs":{},"接":{"docs":{},"收":{"docs":{},"多":{"docs":{},"播":{"docs":{},"组":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"希":{"docs":{},"望":{"docs":{},"在":{"docs":{},"多":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"我":{"docs":{},"们":{"docs":{},"并":{"docs":{},"不":{"docs":{},"希":{"docs":{},"望":{"docs":{},"将":{"docs":{},"所":{"docs":{},"有":{"docs":{},"数":{"docs":{},"据":{"docs":{},"一":{"docs":{},"次":{"docs":{},"性":{"docs":{},"全":{"docs":{},"部":{"docs":{},"读":{"docs":{},"入":{"docs":{},"内":{"docs":{},"存":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"文":{"docs":{},"件":{"docs":{},"太":{"docs":{},"大":{"docs":{},"或":{"docs":{},"希":{"docs":{},"望":{"docs":{},"同":{"docs":{},"时":{"docs":{},"处":{"docs":{},"理":{"docs":{},"多":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"希":{"docs":{},"望":{"docs":{},"每":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"仅":{"docs":{},"使":{"docs":{},"用":{"docs":{},"最":{"docs":{},"小":{"docs":{},"的":{"docs":{},"内":{"docs":{},"存":{"docs":{},"。":{"docs":{},"出":{"docs":{},"于":{"docs":{},"此":{"docs":{},"目":{"docs":{},"的":{"docs":{},"，":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"不":{"docs":{},"知":{"docs":{},"道":{"docs":{},"发":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"想":{"docs":{},"要":{"docs":{},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"个":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"也":{"docs":{},"许":{"docs":{},"您":{"docs":{},"想":{"docs":{},"要":{"docs":{},"在":{"docs":{},"发":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"之":{"docs":{},"前":{"docs":{},"写":{"docs":{},"入":{"docs":{},"头":{"docs":{},"部":{"docs":{},"到":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"格":{"docs":{},"式":{"docs":{},"，":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}},"更":{"docs":{},"多":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"选":{"docs":{},"项":{"docs":{},"和":{"docs":{},"参":{"docs":{},"数":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"很":{"docs":{},"多":{"docs":{},"关":{"docs":{},"于":{"docs":{},"这":{"docs":{},"方":{"docs":{},"面":{"docs":{},"的":{"docs":{},"细":{"docs":{},"节":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"值":{"docs":{},"，":{"docs":{},"则":{"docs":{},"会":{"docs":{},"按":{"docs":{},"照":{"docs":{},"添":{"docs":{},"加":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"来":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"着":{"docs":{},"丰":{"docs":{},"富":{"docs":{},"的":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}},"几":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"一":{"docs":{},"起":{"docs":{},"来":{"docs":{},"看":{"docs":{},"下":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}},"“":{"docs":{},"冷":{"docs":{},"热":{"docs":{},"”":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"/":{"docs":{},"h":{"docs":{},"o":{"docs":{},"t":{"docs":{},")":{"docs":{},"之":{"docs":{},"分":{"docs":{},"。":{"docs":{},"区":{"docs":{},"别":{"docs":{},"在":{"docs":{},"于":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"机":{"docs":{},"制":{"docs":{},"；":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"三":{"docs":{},"个":{"docs":{},"类":{"docs":{},"：":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"了":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"这":{"docs":{},"个":{"docs":{},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"会":{"docs":{},"生":{"docs":{},"成":{"docs":{},"所":{"docs":{},"有":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"用":{"docs":{},"于":{"docs":{},"在":{"docs":{},"e":{"docs":{},"v":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}},"多":{"docs":{},"种":{"docs":{},"日":{"docs":{},"志":{"docs":{},"框":{"docs":{},"架":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"设":{"docs":{},"置":{"docs":{},"系":{"docs":{},"统":{"docs":{},"变":{"docs":{},"量":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"包":{"docs":{},"装":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"一":{"docs":{},"个":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}},"异":{"docs":{},"步":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}},"这":{"docs":{},"些":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"将":{"docs":{},"其":{"docs":{},"传":{"docs":{},"入":{"docs":{},"到":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"，":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"针":{"docs":{},"对":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"异":{"docs":{},"步":{"docs":{},"操":{"docs":{},"作":{"docs":{},"都":{"docs":{},"编":{"docs":{},"写":{"docs":{},"异":{"docs":{},"常":{"docs":{},"处":{"docs":{},"理":{"docs":{},"的":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"。":{"docs":{},"这":{"docs":{},"对":{"docs":{},"于":{"docs":{},"编":{"docs":{},"写":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"异":{"docs":{},"步":{"docs":{},"流":{"docs":{},"程":{"docs":{},"时":{"docs":{},"是":{"docs":{},"非":{"docs":{},"常":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"登":{"docs":{},"录":{"docs":{},"的":{"docs":{},"问":{"docs":{},"题":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"请":{"docs":{},"求":{"docs":{},"（":{"docs":{},"如":{"docs":{},"果":{"docs":{},"有":{"docs":{},"）":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"接":{"docs":{},"收":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"对":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"应":{"docs":{},"异":{"docs":{},"步":{"docs":{},"回":{"docs":{},"调":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"上":{"docs":{},"文":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"的":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}},"获":{"docs":{},"得":{"docs":{},"异":{"docs":{},"常":{"docs":{},"对":{"docs":{},"象":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"有":{"docs":{},"，":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}},"取":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"，":{"docs":{},"限":{"docs":{},"制":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"大":{"docs":{},"小":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"处":{"docs":{},"理":{"docs":{},"文":{"docs":{},"件":{"docs":{},"上":{"docs":{},"传":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"更":{"docs":{},"多":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"给":{"docs":{},"定":{"docs":{},"分":{"docs":{},"区":{"docs":{},"的":{"docs":{},"起":{"docs":{},"始":{"docs":{},"偏":{"docs":{},"移":{"docs":{},"量":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"跟":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}},"做":{"docs":{},"到":{"docs":{},"这":{"docs":{},"一":{"docs":{},"点":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"关":{"docs":{},"闭":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"创":{"docs":{},"建":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"到":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"认":{"docs":{},"证":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"启":{"docs":{},"用":{"docs":{},"/":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"，":{"docs":{},"或":{"docs":{},"在":{"docs":{},"指":{"docs":{},"定":{"docs":{},"模":{"docs":{},"式":{"docs":{},"时":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"/":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"会":{"docs":{},"话":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"并":{"docs":{},"确":{"docs":{},"保":{"docs":{},"它":{"docs":{},"能":{"docs":{},"够":{"docs":{},"在":{"docs":{},"应":{"docs":{},"用":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"之":{"docs":{},"前":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"告":{"docs":{},"诉":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"可":{"docs":{},"以":{"docs":{},"发":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"剩":{"docs":{},"余":{"docs":{},"部":{"docs":{},"分":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"是":{"docs":{},"非":{"docs":{},"常":{"docs":{},"必":{"docs":{},"要":{"docs":{},"的":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"的":{"docs":{},"。":{"docs":{},"它":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"端":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"：":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}},"执":{"docs":{},"行":{"docs":{},"映":{"docs":{},"射":{"docs":{},"。":{"docs":{},"关":{"docs":{},"于":{"docs":{},"字":{"docs":{},"段":{"docs":{},"和":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"可":{"docs":{},"见":{"docs":{},"性":{"docs":{},"的":{"docs":{},"影":{"docs":{},"响":{"docs":{},"、":{"docs":{},"对":{"docs":{},"象":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"和":{"docs":{},"反":{"docs":{},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"的":{"docs":{},"问":{"docs":{},"题":{"docs":{},"等":{"docs":{},"等":{"docs":{},"可":{"docs":{},"参":{"docs":{},"考":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"些":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"行":{"docs":{},"为":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"由":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"了":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"字":{"docs":{},"节":{"docs":{},"数":{"docs":{},"。":{"docs":{},"这":{"docs":{},"对":{"docs":{},"于":{"docs":{},"规":{"docs":{},"避":{"docs":{},"由":{"docs":{},"于":{"docs":{},"过":{"docs":{},"大":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"导":{"docs":{},"致":{"docs":{},"的":{"docs":{},"内":{"docs":{},"存":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"的":{"docs":{},"问":{"docs":{},"题":{"docs":{},"很":{"docs":{},"有":{"docs":{},"用":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}},"提":{"docs":{},"交":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"供":{"docs":{},"网":{"docs":{},"页":{"docs":{},"图":{"docs":{},"标":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"诸":{"docs":{},"如":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"取":{"docs":{},"文":{"docs":{},"件":{"docs":{},"是":{"docs":{},"低":{"docs":{},"效":{"docs":{},"的":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"检":{"docs":{},"测":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"是":{"docs":{},"否":{"docs":{},"适":{"docs":{},"应":{"docs":{},"这":{"docs":{},"个":{"docs":{},"正":{"docs":{},"文":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"。":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"参":{"docs":{},"数":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}},"说":{"docs":{},"，":{"docs":{},"会":{"docs":{},"关":{"docs":{},"联":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"它":{"docs":{},"会":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"底":{"docs":{},"层":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"将":{"docs":{},"执":{"docs":{},"行":{"docs":{},"无":{"docs":{},"延":{"docs":{},"迟":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"，":{"docs":{},"g":{"docs":{},"o":{"docs":{},"a":{"docs":{},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"读":{"docs":{},"取":{"docs":{},"由":{"docs":{},"“":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"”":{"docs":{},"或":{"docs":{},"“":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"”":{"docs":{},"命":{"docs":{},"令":{"docs":{},"创":{"docs":{},"建":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"您":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"部":{"docs":{},"署":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"它":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"是":{"docs":{},"很":{"docs":{},"重":{"docs":{},"要":{"docs":{},"的":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"每":{"docs":{},"一":{"docs":{},"次":{"docs":{},"都":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"型":{"docs":{},"、":{"docs":{},"主":{"docs":{},"机":{"docs":{},"名":{"docs":{},"、":{"docs":{},"端":{"docs":{},"口":{"docs":{},"、":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"和":{"docs":{},"密":{"docs":{},"码":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"匹":{"docs":{},"配":{"docs":{},"规":{"docs":{},"则":{"docs":{},"，":{"docs":{},"指":{"docs":{},"定":{"docs":{},"哪":{"docs":{},"些":{"docs":{},"输":{"docs":{},"入":{"docs":{},"和":{"docs":{},"输":{"docs":{},"出":{"docs":{},"的":{"docs":{},"流":{"docs":{},"量":{"docs":{},"是":{"docs":{},"允":{"docs":{},"许":{"docs":{},"通":{"docs":{},"过":{"docs":{},"的":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"为":{"docs":{},"您":{"docs":{},"处":{"docs":{},"理":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"人":{"docs":{},"工":{"docs":{},"指":{"docs":{},"定":{"docs":{},"会":{"docs":{},"话":{"docs":{},"被":{"docs":{},"访":{"docs":{},"问":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"会":{"docs":{},"话":{"docs":{},"功":{"docs":{},"能":{"docs":{},"是":{"docs":{},"明":{"docs":{},"智":{"docs":{},"的":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"直":{"docs":{},"接":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"此":{"docs":{},"格":{"docs":{},"式":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.003656307129798903}}}}}}}},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}},"删":{"docs":{},"除":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"在":{"docs":{},"磁":{"docs":{},"盘":{"docs":{},"上":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"完":{"docs":{},"成":{"docs":{},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"定":{"docs":{},"义":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"授":{"docs":{},"权":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"描":{"docs":{},"述":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"每":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"支":{"docs":{},"持":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"构":{"docs":{},"建":{"docs":{},"经":{"docs":{},"典":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"查":{"docs":{},"找":{"docs":{},"会":{"docs":{},"话":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"您":{"docs":{},"还":{"docs":{},"需":{"docs":{},"要":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"标":{"docs":{},"示":{"docs":{},"一":{"docs":{},"个":{"docs":{},"会":{"docs":{},"话":{"docs":{},"。":{"docs":{},"会":{"docs":{},"话":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"添":{"docs":{},"加":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"禁":{"docs":{},"用":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"文":{"docs":{},"件":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"结":{"docs":{},"束":{"docs":{},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"维":{"docs":{},"护":{"docs":{},"任":{"docs":{},"何":{"docs":{},"您":{"docs":{},"希":{"docs":{},"望":{"docs":{},"在":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"之":{"docs":{},"间":{"docs":{},"共":{"docs":{},"享":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"认":{"docs":{},"证":{"docs":{},"用":{"docs":{},"户":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"认":{"docs":{},"证":{"docs":{},"成":{"docs":{},"功":{"docs":{},"则":{"docs":{},"该":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"用":{"docs":{},"户":{"docs":{},"授":{"docs":{},"权":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"也":{"docs":{},"成":{"docs":{},"功":{"docs":{},"了":{"docs":{},"则":{"docs":{},"允":{"docs":{},"许":{"docs":{},"这":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"路":{"docs":{},"由":{"docs":{},"到":{"docs":{},"后":{"docs":{},"续":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"里":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{},"否":{"docs":{},"则":{"docs":{},"，":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"让":{"docs":{},"您":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"访":{"docs":{},"问":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"受":{"docs":{},"保":{"docs":{},"护":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"进":{"docs":{},"行":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"，":{"docs":{},"并":{"docs":{},"支":{"docs":{},"持":{"docs":{},"基":{"docs":{},"于":{"docs":{},"通":{"docs":{},"配":{"docs":{},"符":{"docs":{},"的":{"docs":{},"模":{"docs":{},"式":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"授":{"docs":{},"权":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"通":{"docs":{},"信":{"docs":{},"。":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"j":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"名":{"docs":{},"称":{"docs":{},"获":{"docs":{},"取":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"避":{"docs":{},"免":{"docs":{},"这":{"docs":{},"个":{"docs":{},"问":{"docs":{},"题":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"验":{"docs":{},"证":{"docs":{},"它":{"docs":{},"是":{"docs":{},"否":{"docs":{},"如":{"docs":{},"预":{"docs":{},"期":{"docs":{},"的":{"docs":{},"一":{"docs":{},"样":{"docs":{},"工":{"docs":{},"作":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"了":{"docs":{},"解":{"docs":{},"更":{"docs":{},"多":{"docs":{},"关":{"docs":{},"于":{"docs":{},"两":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"的":{"docs":{},"知":{"docs":{},"识":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}},"代":{"docs":{},"替":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},"开":{"docs":{},"启":{"docs":{},"自":{"docs":{},"动":{"docs":{},"提":{"docs":{},"交":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"接":{"docs":{},"受":{"docs":{},"发":{"docs":{},"送":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"结":{"docs":{},"果":{"docs":{},"其":{"docs":{},"实":{"docs":{},"就":{"docs":{},"是":{"docs":{},"一":{"docs":{},"些":{"docs":{},"元":{"docs":{},"数":{"docs":{},"据":{"docs":{},"(":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},"，":{"docs":{},"包":{"docs":{},"含":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"收":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"状":{"docs":{},"态":{"docs":{},"）":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"泵":{"docs":{},"入":{"docs":{},"其":{"docs":{},"中":{"docs":{},"）":{"docs":{},"。":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}},"导":{"docs":{},"入":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"复":{"docs":{},"用":{"docs":{},"现":{"docs":{},"有":{"docs":{},"集":{"docs":{},"群":{"docs":{},"：":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}},"已":{"docs":{},"经":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}},"模":{"docs":{},"式":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"参":{"docs":{},"考":{"docs":{},"这":{"docs":{},"里":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}},"应":{"docs":{},"用":{"docs":{},"。":{"docs":{},"关":{"docs":{},"于":{"docs":{},"更":{"docs":{},"多":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"，":{"docs":{},"但":{"docs":{},"它":{"docs":{},"确":{"docs":{},"实":{"docs":{},"有":{"docs":{},"相":{"docs":{},"似":{"docs":{},"之":{"docs":{},"处":{"docs":{},"，":{"docs":{},"特":{"docs":{},"别":{"docs":{},"是":{"docs":{},"在":{"docs":{},"并":{"docs":{},"发":{"docs":{},"、":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"性":{"docs":{},"和":{"docs":{},"部":{"docs":{},"署":{"docs":{},"等":{"docs":{},"方":{"docs":{},"面":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"和":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"（":{"docs":{},"反":{"docs":{},"应":{"docs":{},"器":{"docs":{},"模":{"docs":{},"式":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"多":{"docs":{},"反":{"docs":{},"应":{"docs":{},"器":{"docs":{},"模":{"docs":{},"式":{"docs":{},"）":{"docs":{},"，":{"docs":{},"区":{"docs":{},"别":{"docs":{},"于":{"docs":{},"单":{"docs":{},"线":{"docs":{},"程":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"板":{"docs":{},"中":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603}}}}}}},"引":{"docs":{},"擎":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0019474196689386564}},"时":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"不":{"docs":{},"指":{"docs":{},"定":{"docs":{},"模":{"docs":{},"板":{"docs":{},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"名":{"docs":{},"，":{"docs":{},"则":{"docs":{},"默":{"docs":{},"认":{"docs":{},"会":{"docs":{},"查":{"docs":{},"找":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"名":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"：":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},".":{"docs":{},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"#":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"#":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"#":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"#":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"b":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"#":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"y":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"f":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"#":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"现":{"docs":{},"没":{"docs":{},"有":{"docs":{},"内":{"docs":{},"嵌":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"：":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},":":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922}}}}}}},"型":{"docs":{},"类":{"docs":{},"似":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"户":{"docs":{},"可":{"docs":{},"以":{"docs":{},"有":{"0":{"docs":{},"到":{"docs":{},"多":{"docs":{},"个":{"docs":{},"角":{"docs":{},"色":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"角":{"docs":{},"色":{"docs":{},"可":{"docs":{},"以":{"docs":{},"有":{"0":{"docs":{},"到":{"docs":{},"多":{"docs":{},"个":{"docs":{},"权":{"docs":{},"限":{"docs":{},"。":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}},"此":{"docs":{},"处":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"会":{"docs":{},"列":{"docs":{},"出":{"docs":{},"常":{"docs":{},"见":{"docs":{},"的":{"docs":{},"关":{"docs":{},"于":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}},"是":{"docs":{},"公":{"docs":{},"开":{"docs":{},"的":{"docs":{},"，":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"登":{"docs":{},"录":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"登":{"docs":{},"录":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}},"可":{"docs":{},"填":{"docs":{},"入":{"docs":{},"超":{"docs":{},"时":{"docs":{},"处":{"docs":{},"理":{"docs":{},"部":{"docs":{},"分":{"docs":{},"代":{"docs":{},"码":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}},"外":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"实":{"docs":{},"现":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"转":{"docs":{},"换":{"docs":{},"器":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"并":{"docs":{},"指":{"docs":{},"定":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"使":{"docs":{},"用":{"docs":{},"此":{"docs":{},"转":{"docs":{},"换":{"docs":{},"器":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"还":{"docs":{},"会":{"docs":{},"加":{"docs":{},"上":{"docs":{},"：":{"docs":{},"k":{"docs":{},"u":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"u":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"将":{"docs":{},"启":{"docs":{},"动":{"docs":{},"但":{"docs":{},"不":{"docs":{},"部":{"docs":{},"署":{"docs":{},"模":{"docs":{},"块":{"docs":{},"（":{"docs":{},"尚":{"docs":{},"未":{"docs":{},"）":{"docs":{},"因":{"docs":{},"为":{"docs":{},"目":{"docs":{},"前":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"只":{"docs":{},"有":{"1":{"docs":{},"个":{"docs":{},"节":{"docs":{},"点":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"3":{"docs":{},"个":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}}}}}}}},"2":{"docs":{},"个":{"docs":{},"节":{"docs":{},"点":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"3":{"docs":{},"个":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"内":{"docs":{},"容":{"docs":{},"会":{"docs":{},"是":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"不":{"docs":{},"会":{"docs":{},"使":{"docs":{},"用":{"docs":{},"分":{"docs":{},"块":{"docs":{},"传":{"docs":{},"输":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"用":{"docs":{},"来":{"docs":{},"支":{"docs":{},"持":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"确":{"docs":{},"定":{"docs":{},"管":{"docs":{},"理":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"类":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"i":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"3":{"docs":{},"p":{"0":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"着":{"docs":{},"支":{"docs":{},"持":{"docs":{},"驱":{"docs":{},"动":{"docs":{},"所":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"大":{"docs":{},"多":{"docs":{},"数":{"docs":{},"参":{"docs":{},"数":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{},"有":{"docs":{},"两":{"docs":{},"种":{"docs":{},"配":{"docs":{},"置":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"一":{"docs":{},"种":{"docs":{},"是":{"docs":{},"连":{"docs":{},"接":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"，":{"docs":{},"另":{"docs":{},"一":{"docs":{},"种":{"docs":{},"是":{"docs":{},"驱":{"docs":{},"动":{"docs":{},"配":{"docs":{},"置":{"docs":{},"选":{"docs":{},"项":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"把":{"docs":{},"配":{"docs":{},"置":{"docs":{},"参":{"docs":{},"数":{"docs":{},"放":{"docs":{},"在":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"支":{"docs":{},"持":{"docs":{},"以":{"docs":{},"下":{"docs":{},"这":{"docs":{},"些":{"docs":{},"参":{"docs":{},"数":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"可":{"docs":{},"以":{"docs":{},"更":{"docs":{},"新":{"docs":{},"集":{"docs":{},"合":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}},"从":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"中":{"docs":{},"获":{"docs":{},"取":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"连":{"docs":{},"接":{"docs":{},"，":{"docs":{},"并":{"docs":{},"返":{"docs":{},"回":{"docs":{},"给":{"docs":{},"回":{"docs":{},"调":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}}}}}}},"式":{"docs":{},"有":{"docs":{},"两":{"docs":{},"个":{"docs":{},"必":{"docs":{},"要":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}},"异":{"docs":{},"步":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}},"组":{"docs":{},"件":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"底":{"docs":{},"层":{"docs":{},"使":{"docs":{},"用":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"格":{"docs":{},"式":{"docs":{},"支":{"docs":{},"持":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}},"也":{"docs":{},"支":{"docs":{},"持":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"格":{"docs":{},"式":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}},"仅":{"docs":{},"仅":{"docs":{},"从":{"docs":{},"文":{"docs":{},"件":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"支":{"docs":{},"持":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"格":{"docs":{},"式":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"从":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}},"通":{"docs":{},"过":{"docs":{},"给":{"docs":{},"定":{"docs":{},"的":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"将":{"docs":{},"环":{"docs":{},"境":{"docs":{},"变":{"docs":{},"量":{"docs":{},"中":{"docs":{},"的":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"映":{"docs":{},"射":{"docs":{},"成":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{},"中":{"docs":{},"的":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"映":{"docs":{},"射":{"docs":{},"成":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"以":{"docs":{},"下":{"docs":{},"几":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"参":{"docs":{},"数":{"docs":{},"：":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.002136553646075244},"web/Web.html":{"ref":"web/Web.html","tf":0.004868549172346641},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.00554016620498615},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.006369426751592357},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"中":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"风":{"docs":{},"格":{"docs":{},"会":{"docs":{},"很":{"docs":{},"怪":{"docs":{},"异":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"我":{"docs":{},"们":{"docs":{},"根":{"docs":{},"据":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"异":{"docs":{},"步":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"接":{"docs":{},"口":{"docs":{},"约":{"docs":{},"定":{"docs":{},"，":{"docs":{},"其":{"docs":{},"实":{"docs":{},"都":{"docs":{},"是":{"docs":{},"关":{"docs":{},"于":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}},"输":{"docs":{},"入":{"docs":{},"是":{"docs":{},"前":{"docs":{},"一":{"docs":{},"个":{"docs":{},"异":{"docs":{},"步":{"docs":{},"过":{"docs":{},"程":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"（":{"docs":{},"此":{"docs":{},"处":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"不":{"docs":{},"是":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"方":{"docs":{},"法":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"那":{"docs":{},"样":{"docs":{},"做":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"代":{"docs":{},"码":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"库":{"docs":{},"。":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"于":{"docs":{},"t":{"docs":{},"c":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"它":{"docs":{},"需":{"docs":{},"要":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"安":{"docs":{},"装":{"docs":{},"在":{"docs":{},"您":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"加":{"docs":{},"到":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"目":{"docs":{},"录":{"docs":{},"中":{"docs":{},"。":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{},"首":{"docs":{},"先":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"添":{"docs":{},"加":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},")":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"地":{"docs":{},"址":{"docs":{},"并":{"docs":{},"且":{"docs":{},"加":{"docs":{},"入":{"docs":{},"多":{"docs":{},"播":{"docs":{},"组":{"docs":{},"，":{"docs":{},"并":{"docs":{},"加":{"docs":{},"入":{"docs":{},"多":{"docs":{},"播":{"docs":{},"组":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"都":{"docs":{},"将":{"docs":{},"收":{"docs":{},"到":{"docs":{},"该":{"docs":{},"报":{"docs":{},"文":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"单":{"docs":{},"个":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"并":{"docs":{},"行":{"docs":{},"发":{"docs":{},"送":{"docs":{},"多":{"docs":{},"个":{"docs":{},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"但":{"docs":{},"是":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},"，":{"docs":{},"能":{"docs":{},"根":{"docs":{},"据":{"docs":{},"服":{"docs":{},"务":{"docs":{},"i":{"docs":{},"d":{"docs":{},"部":{"docs":{},"署":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}},"代":{"docs":{},"码":{"docs":{},"自":{"docs":{},"动":{"docs":{},"生":{"docs":{},"成":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"就":{"docs":{},"像":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}},"关":{"docs":{},"键":{"docs":{},"优":{"docs":{},"点":{"docs":{},"是":{"docs":{},"完":{"docs":{},"全":{"docs":{},"非":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"(":{"docs":{},"于":{"docs":{},"内":{"docs":{},"核":{"docs":{},"线":{"docs":{},"程":{"docs":{},"而":{"docs":{},"言":{"docs":{},")":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}},"部":{"docs":{},"分":{"docs":{},"关":{"docs":{},"键":{"docs":{},"特":{"docs":{},"性":{"docs":{},"有":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"些":{"docs":{},"基":{"docs":{},"本":{"docs":{},"概":{"docs":{},"念":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}},"例":{"docs":{},"子":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}},"可":{"docs":{},"以":{"docs":{},"参":{"docs":{},"见":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}},"区":{"docs":{},"别":{"docs":{},"：":{"docs":{},"文":{"docs":{},"中":{"docs":{},"所":{"docs":{},"有":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"压":{"docs":{},"缩":{"docs":{},"级":{"docs":{},"别":{"docs":{},"通":{"docs":{},"常":{"docs":{},"允":{"docs":{},"许":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"保":{"docs":{},"存":{"docs":{},"一":{"docs":{},"些":{"docs":{},"字":{"docs":{},"节":{"docs":{},"大":{"docs":{},"小":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"原":{"docs":{},"生":{"docs":{},"支":{"docs":{},"持":{"docs":{},"（":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"发":{"docs":{},"行":{"docs":{},"版":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"将":{"docs":{},"安":{"docs":{},"装":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"布":{"docs":{},"者":{"docs":{},"和":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"者":{"docs":{},"。":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}},"角":{"docs":{},"色":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"拿":{"docs":{},"到":{"docs":{},"任":{"docs":{},"意":{"docs":{},"的":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}},"）":{"docs":{},"，":{"docs":{},"随":{"docs":{},"后":{"docs":{},"你":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"像":{"docs":{},"从":{"docs":{},"其":{"docs":{},"他":{"docs":{},"任":{"docs":{},"意":{"docs":{},"的":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}},"名":{"docs":{},"称":{"docs":{},"会":{"docs":{},"用":{"docs":{},"于":{"docs":{},"查":{"docs":{},"找":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}},"含":{"docs":{},"义":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"是":{"docs":{},"由":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"来":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"。":{"docs":{},"这":{"docs":{},"完":{"docs":{},"全":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"如":{"docs":{},"何":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"基":{"docs":{},"本":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"概":{"docs":{},"念":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"器":{"docs":{},"。":{"docs":{},"当":{"docs":{},"连":{"docs":{},"接":{"docs":{},"成":{"docs":{},"功":{"docs":{},"或":{"docs":{},"失":{"docs":{},"败":{"docs":{},"时":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"这":{"docs":{},"些":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"子":{"docs":{},"类":{"docs":{},"来":{"docs":{},"启":{"docs":{},"动":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"类":{"docs":{},"被":{"docs":{},"设":{"docs":{},"计":{"docs":{},"成":{"docs":{},"易":{"docs":{},"于":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"传":{"docs":{},"入":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"并":{"docs":{},"调":{"docs":{},"用":{"docs":{},"它":{"docs":{},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"您":{"docs":{},"现":{"docs":{},"在":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"该":{"docs":{},"锁":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"添":{"docs":{},"加":{"docs":{},"、":{"docs":{},"设":{"docs":{},"置":{"docs":{},"、":{"docs":{},"删":{"docs":{},"除":{"docs":{},"条":{"docs":{},"目":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"现":{"docs":{},"类":{"docs":{},"必":{"docs":{},"须":{"docs":{},"实":{"docs":{},"现":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"可":{"docs":{},"以":{"docs":{},"和":{"docs":{},"泵":{"docs":{},"(":{"docs":{},"p":{"docs":{},"u":{"docs":{},"m":{"docs":{},"p":{"docs":{},")":{"docs":{},"一":{"docs":{},"起":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"源":{"docs":{},"码":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"。":{"docs":{},"不":{"docs":{},"过":{"docs":{},"需":{"docs":{},"要":{"docs":{},"确":{"docs":{},"保":{"docs":{},"在":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"数":{"docs":{},"量":{"docs":{},"—":{"docs":{},"—":{"docs":{},"方":{"docs":{},"法":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"u":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"返":{"docs":{},"回":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"。":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"当":{"docs":{},"写":{"docs":{},"队":{"docs":{},"列":{"docs":{},"被":{"docs":{},"认":{"docs":{},"为":{"docs":{},"已":{"docs":{},"满":{"docs":{},"时":{"docs":{},"，":{"docs":{},"若":{"docs":{},"写":{"docs":{},"（":{"docs":{},"操":{"docs":{},"作":{"docs":{},"）":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"则":{"docs":{},"数":{"docs":{},"据":{"docs":{},"依":{"docs":{},"然":{"docs":{},"会":{"docs":{},"被":{"docs":{},"接":{"docs":{},"收":{"docs":{},"和":{"docs":{},"排":{"docs":{},"队":{"docs":{},"。":{"docs":{},"实":{"docs":{},"际":{"docs":{},"数":{"docs":{},"量":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"流":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"尺":{"docs":{},"寸":{"docs":{},"代":{"docs":{},"表":{"docs":{},"实":{"docs":{},"际":{"docs":{},"写":{"docs":{},"入":{"docs":{},"的":{"docs":{},"字":{"docs":{},"节":{"docs":{},"数":{"docs":{},"，":{"docs":{},"而":{"docs":{},"并":{"docs":{},"非":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"区":{"docs":{},"的":{"docs":{},"数":{"docs":{},"量":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"帧":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"值":{"docs":{},"，":{"docs":{},"则":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"在":{"docs":{},"将":{"docs":{},"其":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{},"报":{"docs":{},"文":{"docs":{},"之":{"docs":{},"前":{"docs":{},"将":{"docs":{},"其":{"docs":{},"拆":{"docs":{},"分":{"docs":{},"为":{"docs":{},"多":{"docs":{},"个":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"常":{"docs":{},"用":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"参":{"docs":{},"数":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"引":{"docs":{},"用":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"情":{"docs":{},"况":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"发":{"docs":{},"生":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"下":{"docs":{},"）":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}},"控":{"docs":{},"制":{"docs":{},"中":{"docs":{},"心":{"docs":{},"，":{"docs":{},"也":{"docs":{},"是":{"docs":{},"您":{"docs":{},"做":{"docs":{},"几":{"docs":{},"乎":{"docs":{},"一":{"docs":{},"切":{"docs":{},"事":{"docs":{},"情":{"docs":{},"的":{"docs":{},"基":{"docs":{},"础":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"创":{"docs":{},"建":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"、":{"docs":{},"获":{"docs":{},"取":{"docs":{},"事":{"docs":{},"件":{"docs":{},"总":{"docs":{},"线":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"、":{"docs":{},"设":{"docs":{},"置":{"docs":{},"定":{"docs":{},"时":{"docs":{},"器":{"docs":{},"等":{"docs":{},"等":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"量":{"docs":{},"，":{"docs":{},"您":{"docs":{},"亦":{"docs":{},"可":{"docs":{},"自":{"docs":{},"行":{"docs":{},"设":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"据":{"docs":{},"并":{"docs":{},"把":{"docs":{},"它":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"端":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"库":{"docs":{},"来":{"docs":{},"说":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"后":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"对":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}},"进":{"docs":{},"行":{"docs":{},"交":{"docs":{},"互":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}},"整":{"docs":{},"数":{"docs":{},"值":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"个":{"docs":{},"生":{"docs":{},"命":{"docs":{},"周":{"docs":{},"期":{"docs":{},"里":{"docs":{},"）":{"docs":{},"，":{"docs":{},"可":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"不":{"docs":{},"再":{"docs":{},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"后":{"docs":{},"，":{"docs":{},"就":{"docs":{},"应":{"docs":{},"该":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"它":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}},"，":{"docs":{},"就":{"docs":{},"应":{"docs":{},"该":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}}}},"文":{"docs":{},"档":{"docs":{},"获":{"docs":{},"取":{"docs":{},"更":{"docs":{},"多":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"件":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922}}},"上":{"docs":{},"传":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"从":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"来":{"docs":{},"部":{"docs":{},"署":{"docs":{},"，":{"docs":{},"且":{"docs":{},"在":{"docs":{},"没":{"docs":{},"有":{"docs":{},"权":{"docs":{},"限":{"docs":{},"把":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}},"从":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"读":{"docs":{},"取":{"docs":{},"（":{"docs":{},"甚":{"docs":{},"至":{"docs":{},"可":{"docs":{},"以":{"docs":{},"支":{"docs":{},"持":{"docs":{},"暂":{"docs":{},"停":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},"和":{"docs":{},"恢":{"docs":{},"复":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},"操":{"docs":{},"作":{"docs":{},"）":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"法":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"替":{"docs":{},"换":{"docs":{},"了":{"docs":{},"以":{"docs":{},"前":{"docs":{},"版":{"docs":{},"本":{"docs":{},"中":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"一":{"docs":{},"个":{"docs":{},"语":{"docs":{},"义":{"docs":{},"上":{"docs":{},"的":{"docs":{},"改":{"docs":{},"变":{"docs":{},"是":{"docs":{},"为":{"docs":{},"了":{"docs":{},"与":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}},"个":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"本":{"docs":{},"地":{"docs":{},"地":{"docs":{},"址":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"核":{"docs":{},"心":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"概":{"docs":{},"念":{"docs":{},"之":{"docs":{},"一":{"docs":{},"。":{"docs":{},"它":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"维":{"docs":{},"护":{"docs":{},"了":{"docs":{},"零":{"docs":{},"或":{"docs":{},"多":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"特":{"docs":{},"定":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"分":{"docs":{},"区":{"docs":{},"里":{"docs":{},"接":{"docs":{},"收":{"docs":{},"消":{"docs":{},"息":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}},"点":{"docs":{},"，":{"docs":{},"灵":{"docs":{},"感":{"docs":{},"来":{"docs":{},"自":{"docs":{},"于":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"状":{"docs":{},"态":{"docs":{},"一":{"docs":{},"致":{"docs":{},"性":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"被":{"docs":{},"标":{"docs":{},"记":{"docs":{},"成":{"docs":{},"失":{"docs":{},"败":{"docs":{},"）":{"docs":{},"，":{"docs":{},"则":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"神":{"docs":{},"经":{"docs":{},"系":{"docs":{},"统":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"第":{"docs":{},"二":{"docs":{},"种":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"处":{"docs":{},"理":{"docs":{},"从":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"发":{"docs":{},"送":{"docs":{},"的":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"升":{"docs":{},"级":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"调":{"docs":{},"用":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"请":{"docs":{},"求":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"为":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}},"简":{"docs":{},"单":{"docs":{},"示":{"docs":{},"例":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"索":{"docs":{},"引":{"docs":{},"进":{"docs":{},"行":{"docs":{},"标":{"docs":{},"识":{"docs":{},"。":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"线":{"docs":{},"程":{"docs":{},"来":{"docs":{},"调":{"docs":{},"用":{"docs":{},"您":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"模":{"docs":{},"型":{"docs":{},"完":{"docs":{},"美":{"docs":{},"契":{"docs":{},"合":{"docs":{},"。":{"docs":{},"但":{"docs":{},"是":{"docs":{},"即":{"docs":{},"使":{"docs":{},"这":{"docs":{},"些":{"docs":{},"接":{"docs":{},"口":{"docs":{},"已":{"docs":{},"经":{"docs":{},"存":{"docs":{},"在":{"docs":{},"一":{"docs":{},"段":{"docs":{},"时":{"docs":{},"间":{"docs":{},"，":{"docs":{},"却":{"docs":{},"没":{"docs":{},"有":{"docs":{},"通":{"docs":{},"过":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"计":{"docs":{},"是":{"docs":{},"强":{"docs":{},"大":{"docs":{},"的":{"docs":{},"，":{"docs":{},"非":{"docs":{},"侵":{"docs":{},"入":{"docs":{},"式":{"docs":{},"的":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"是":{"docs":{},"完":{"docs":{},"全":{"docs":{},"可":{"docs":{},"插":{"docs":{},"拔":{"docs":{},"的":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"远":{"docs":{},"程":{"docs":{},"地":{"docs":{},"址":{"docs":{},"（":{"docs":{},"即":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"端":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"，":{"docs":{},"则":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"若":{"docs":{},"您":{"docs":{},"想":{"docs":{},"要":{"docs":{},"在":{"docs":{},"一":{"docs":{},"段":{"docs":{},"空":{"docs":{},"闲":{"docs":{},"时":{"docs":{},"间":{"docs":{},"之":{"docs":{},"后":{"docs":{},"让":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"同":{"docs":{},"时":{"docs":{},"释":{"docs":{},"放":{"docs":{},"所":{"docs":{},"有":{"docs":{},"相":{"docs":{},"关":{"docs":{},"资":{"docs":{},"源":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"相":{"docs":{},"关":{"docs":{},"资":{"docs":{},"源":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},"并":{"docs":{},"发":{"docs":{},"送":{"docs":{},"和":{"docs":{},"接":{"docs":{},"收":{"docs":{},"消":{"docs":{},"息":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"部":{"docs":{},"署":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"和":{"docs":{},"并":{"docs":{},"发":{"docs":{},"模":{"docs":{},"型":{"docs":{},"机":{"docs":{},"制":{"docs":{},"。":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"此":{"docs":{},"模":{"docs":{},"型":{"docs":{},"机":{"docs":{},"制":{"docs":{},"来":{"docs":{},"保":{"docs":{},"管":{"docs":{},"您":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"组":{"docs":{},"件":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{},"查":{"docs":{},"看":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"和":{"docs":{},"私":{"docs":{},"钥":{"docs":{},"是":{"docs":{},"不":{"docs":{},"加":{"docs":{},"密":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"用":{"docs":{},"法":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"所":{"docs":{},"有":{"docs":{},"集":{"docs":{},"群":{"docs":{},"节":{"docs":{},"点":{"docs":{},"中":{"docs":{},"保":{"docs":{},"持":{"docs":{},"一":{"docs":{},"致":{"docs":{},"性":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}},"内":{"docs":{},"容":{"docs":{},"一":{"docs":{},"致":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"文":{"docs":{},"件":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"避":{"docs":{},"免":{"docs":{},"传":{"docs":{},"统":{"docs":{},"的":{"docs":{},"多":{"docs":{},"线":{"docs":{},"程":{"docs":{},"应":{"docs":{},"用":{"docs":{},"经":{"docs":{},"常":{"docs":{},"会":{"docs":{},"遇":{"docs":{},"到":{"docs":{},"的":{"docs":{},"竞":{"docs":{},"态":{"docs":{},"条":{"docs":{},"件":{"docs":{},"和":{"docs":{},"死":{"docs":{},"锁":{"docs":{},"的":{"docs":{},"问":{"docs":{},"题":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"顺":{"docs":{},"序":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"一":{"docs":{},"致":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"使":{"docs":{},"其":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"或":{"docs":{},"不":{"docs":{},"定":{"docs":{},"义":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"）":{"docs":{},"，":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"值":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"、":{"docs":{},"开":{"docs":{},"箱":{"docs":{},"即":{"docs":{},"用":{"docs":{},"的":{"docs":{},"错":{"docs":{},"误":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"渲":{"docs":{},"染":{"docs":{},"错":{"docs":{},"误":{"docs":{},"页":{"docs":{},"面":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"会":{"docs":{},"使":{"docs":{},"用":{"docs":{},"最":{"docs":{},"新":{"docs":{},"发":{"docs":{},"布":{"docs":{},"的":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"版":{"docs":{},"本":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"不":{"docs":{},"同":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"会":{"docs":{},"话":{"docs":{},"标":{"docs":{},"示":{"docs":{},"是":{"docs":{},"不":{"docs":{},"能":{"docs":{},"够":{"docs":{},"派":{"docs":{},"发":{"docs":{},"出":{"docs":{},"存":{"docs":{},"储":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"他":{"docs":{},"们":{"docs":{},"具":{"docs":{},"有":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"种":{"docs":{},"子":{"docs":{},"和":{"docs":{},"状":{"docs":{},"态":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"作":{"docs":{},"用":{"docs":{},"是":{"docs":{},"当":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"值":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"键":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}},"会":{"docs":{},"是":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"使":{"docs":{},"其":{"docs":{},"能":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"，":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"是":{"docs":{},"读":{"docs":{},"取":{"docs":{},"（":{"docs":{},"只":{"docs":{},"读":{"docs":{},"模":{"docs":{},"式":{"docs":{},"）":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}},"其":{"docs":{},"他":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"具":{"docs":{},"体":{"docs":{},"实":{"docs":{},"现":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"内":{"docs":{},"容":{"docs":{},"写":{"docs":{},"作":{"docs":{},"风":{"docs":{},"格":{"docs":{},"明":{"docs":{},"显":{"docs":{},"和":{"docs":{},"前":{"docs":{},"文":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"有":{"docs":{},"些":{"docs":{},"地":{"docs":{},"方":{"docs":{},"描":{"docs":{},"述":{"docs":{},"的":{"docs":{},"很":{"docs":{},"简":{"docs":{},"略":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"匹":{"docs":{},"配":{"docs":{},"过":{"docs":{},"程":{"docs":{},"是":{"docs":{},"精":{"docs":{},"确":{"docs":{},"的":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"取":{"docs":{},"值":{"docs":{},"范":{"docs":{},"围":{"docs":{},"由":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}},"拒":{"docs":{},"绝":{"docs":{},"访":{"docs":{},"问":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"回":{"docs":{},"调":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"从":{"docs":{},"而":{"docs":{},"得":{"docs":{},"到":{"docs":{},"回":{"docs":{},"调":{"docs":{},"通":{"docs":{},"知":{"docs":{},"。":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}},"大":{"docs":{},"多":{"docs":{},"数":{"docs":{},"特":{"docs":{},"性":{"docs":{},"被":{"docs":{},"实":{"docs":{},"现":{"docs":{},"为":{"docs":{},"了":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"您":{"docs":{},"随":{"docs":{},"时":{"docs":{},"可":{"docs":{},"以":{"docs":{},"实":{"docs":{},"现":{"docs":{},"您":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"我":{"docs":{},"们":{"docs":{},"预":{"docs":{},"计":{"docs":{},"随":{"docs":{},"着":{"docs":{},"时":{"docs":{},"间":{"docs":{},"的":{"docs":{},"推":{"docs":{},"移":{"docs":{},"会":{"docs":{},"有":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"被":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"套":{"docs":{},"接":{"docs":{},"字":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"时":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"该":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"空":{"docs":{},"闲":{"docs":{},"事":{"docs":{},"件":{"docs":{},"超":{"docs":{},"过":{"docs":{},"出":{"docs":{},"事":{"docs":{},"设":{"docs":{},"置":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"该":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"库":{"docs":{},"来":{"docs":{},"建":{"docs":{},"立":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}},"库":{"docs":{},"每":{"docs":{},"隔":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"应":{"docs":{},"用":{"docs":{},"创":{"docs":{},"建":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"您":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"时":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},"挂":{"docs":{},"载":{"docs":{},"点":{"docs":{},"上":{"docs":{},"来":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"挂":{"docs":{},"载":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"授":{"docs":{},"权":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"功":{"docs":{},"能":{"docs":{},"来":{"docs":{},"配":{"docs":{},"置":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"访":{"docs":{},"问":{"docs":{},"授":{"docs":{},"权":{"docs":{},"。":{"docs":{},"同":{"docs":{},"时":{"docs":{},"支":{"docs":{},"持":{"docs":{},"输":{"docs":{},"入":{"docs":{},"和":{"docs":{},"输":{"docs":{},"出":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"很":{"docs":{},"有":{"docs":{},"用":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"受":{"docs":{},"保":{"docs":{},"护":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"机":{"docs":{},"制":{"docs":{},"时":{"docs":{},"，":{"docs":{},"所":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"为":{"docs":{},"您":{"docs":{},"和":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}},"提":{"docs":{},"供":{"docs":{},"商":{"docs":{},"参":{"docs":{},"考":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"调":{"docs":{},"用":{"docs":{},"某":{"docs":{},"个":{"docs":{},"传":{"docs":{},"统":{"docs":{},"的":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"更":{"docs":{},"简":{"docs":{},"单":{"docs":{},"些":{"docs":{},"。":{"docs":{},"但":{"docs":{},"要":{"docs":{},"注":{"docs":{},"意":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"查":{"docs":{},"询":{"docs":{},"出":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"中":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"出":{"docs":{},"现":{"docs":{},"重":{"docs":{},"复":{"docs":{},"的":{"docs":{},"列":{"docs":{},"名":{"docs":{},"。":{"docs":{},"若":{"docs":{},"遇":{"docs":{},"到":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"您":{"docs":{},"应":{"docs":{},"该":{"docs":{},"选":{"docs":{},"择":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"候":{"docs":{},"指":{"docs":{},"定":{"docs":{},"任":{"docs":{},"意":{"docs":{},"的":{"docs":{},"路":{"docs":{},"径":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"框":{"docs":{},"架":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}},"流":{"docs":{},"程":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"保":{"docs":{},"护":{"docs":{},"资":{"docs":{},"源":{"docs":{},"并":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"需":{"docs":{},"要":{"docs":{},"，":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},".":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"头":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"并":{"docs":{},"加":{"docs":{},"入":{"docs":{},"消":{"docs":{},"费":{"docs":{},"组":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"费":{"docs":{},"者":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}},"算":{"docs":{},"法":{"docs":{},"所":{"docs":{},"影":{"docs":{},"响":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"网":{"docs":{},"站":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"详":{"docs":{},"细":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"请":{"docs":{},"求":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"也":{"docs":{},"是":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"会":{"docs":{},"同":{"docs":{},"时":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"两":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"被":{"docs":{},"定":{"docs":{},"位":{"docs":{},"到":{"docs":{},"索":{"docs":{},"引":{"docs":{},"页":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"该":{"docs":{},"文":{"docs":{},"件":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}}}}}}}}}},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"我":{"docs":{},"们":{"docs":{},"会":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"结":{"docs":{},"尾":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"都":{"docs":{},"需":{"docs":{},"要":{"docs":{},"认":{"docs":{},"证":{"docs":{},"控":{"docs":{},"制":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"实":{"docs":{},"现":{"docs":{},"这":{"docs":{},"个":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"确":{"docs":{},"保":{"docs":{},"您":{"docs":{},"的":{"docs":{},"认":{"docs":{},"证":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"这":{"docs":{},"个":{"docs":{},"路":{"docs":{},"径":{"docs":{},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"之":{"docs":{},"前":{"docs":{},"执":{"docs":{},"行":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"静":{"docs":{},"态":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"在":{"docs":{},"该":{"docs":{},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{},"查":{"docs":{},"找":{"docs":{},"文":{"docs":{},"件":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"路":{"docs":{},"径":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"由":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"运":{"docs":{},"行":{"docs":{},"配":{"docs":{},"置":{"docs":{},"来":{"docs":{},"启":{"docs":{},"动":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"修":{"docs":{},"改":{"docs":{},"了":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"时":{"docs":{},"不":{"docs":{},"会":{"docs":{},"被":{"docs":{},"更":{"docs":{},"新":{"docs":{},"的":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"集":{"docs":{},"合":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"被":{"docs":{},"回":{"docs":{},"写":{"docs":{},"到":{"docs":{},"响":{"docs":{},"应":{"docs":{},"里":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"存":{"docs":{},"储":{"docs":{},"下":{"docs":{},"来":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}},"成":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"以":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"书":{"docs":{},"的":{"docs":{},"数":{"docs":{},"量":{"docs":{},"，":{"docs":{},"结":{"docs":{},"果":{"docs":{},"包":{"docs":{},"装":{"docs":{},"在":{"docs":{},"回":{"docs":{},"调":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"文":{"docs":{},"档":{"docs":{},"数":{"docs":{},"据":{"docs":{},"都":{"docs":{},"存":{"docs":{},"储":{"docs":{},"在":{"docs":{},"集":{"docs":{},"合":{"docs":{},"中":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"分":{"docs":{},"区":{"docs":{},"上":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"者":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"不":{"docs":{},"能":{"docs":{},"在":{"docs":{},"关":{"docs":{},"闭":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}},"持":{"docs":{},"久":{"docs":{},"化":{"docs":{},"和":{"docs":{},"检":{"docs":{},"索":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"转":{"docs":{},"换":{"docs":{},"。":{"docs":{},"虽":{"docs":{},"然":{"docs":{},"大":{"docs":{},"部":{"docs":{},"分":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"都":{"docs":{},"支":{"docs":{},"持":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}},"下":{"docs":{},"标":{"docs":{},"和":{"docs":{},"输":{"docs":{},"入":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"输":{"docs":{},"出":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"值":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"表":{"docs":{},"示":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"设":{"docs":{},"置":{"docs":{},"成":{"docs":{},"了":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}},"相":{"docs":{},"关":{"docs":{},"命":{"docs":{},"令":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789}}}},"信":{"docs":{},"息":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"语":{"docs":{},"法":{"docs":{},"来":{"docs":{},"进":{"docs":{},"行":{"docs":{},"交":{"docs":{},"互":{"docs":{},"，":{"docs":{},"这":{"docs":{},"在":{"docs":{},"与":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}},"依":{"docs":{},"赖":{"docs":{},"为":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},"分":{"docs":{},"区":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"官":{"docs":{},"方":{"docs":{},"文":{"docs":{},"档":{"docs":{},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"网":{"docs":{},"站":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"找":{"docs":{},"到":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"描":{"docs":{},"述":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}},"中":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"找":{"docs":{},"到":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"描":{"docs":{},"述":{"docs":{},"。":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}},"中":{"docs":{},"文":{"docs":{},"文":{"docs":{},"档":{"docs":{},"中":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"找":{"docs":{},"到":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"描":{"docs":{},"述":{"docs":{},"。":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}}}}}}}}}}},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"格":{"docs":{},"式":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"作":{"docs":{},"为":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},"末":{"docs":{},"端":{"docs":{},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"解":{"docs":{},"析":{"docs":{},"方":{"docs":{},"式":{"docs":{},"作":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"传":{"docs":{},"入":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},"起":{"docs":{},"始":{"docs":{},"位":{"docs":{},"置":{"docs":{},"读":{"docs":{},"取":{"docs":{},"消":{"docs":{},"息":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}},"端":{"docs":{},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"前":{"docs":{},"缀":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"都":{"docs":{},"返":{"docs":{},"回":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"概":{"docs":{},"念":{"docs":{},"和":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"订":{"docs":{},"阅":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}},"者":{"docs":{},"角":{"docs":{},"色":{"docs":{},"。":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}},"）":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"你":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"像":{"docs":{},"处":{"docs":{},"理":{"docs":{},"其":{"docs":{},"他":{"docs":{},"任":{"docs":{},"意":{"docs":{},"的":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}}},"调":{"docs":{},"度":{"docs":{},"器":{"docs":{},"，":{"docs":{},"这":{"docs":{},"得":{"docs":{},"益":{"docs":{},"于":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"这":{"docs":{},"些":{"docs":{},"方":{"docs":{},"法":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}},"形":{"docs":{},"式":{"docs":{},"。":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}},"，":{"docs":{},"在":{"docs":{},"构":{"docs":{},"建":{"docs":{},"工":{"docs":{},"具":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"版":{"docs":{},"本":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}},"用":{"docs":{},"法":{"docs":{},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}},"领":{"docs":{},"域":{"docs":{},"里":{"docs":{},"，":{"docs":{},"很":{"docs":{},"多":{"docs":{},"操":{"docs":{},"作":{"docs":{},"都":{"docs":{},"会":{"docs":{},"接":{"docs":{},"受":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"来":{"docs":{},"通":{"docs":{},"知":{"docs":{},"调":{"docs":{},"用":{"docs":{},"者":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"操":{"docs":{},"作":{"docs":{},"已":{"docs":{},"经":{"docs":{},"完":{"docs":{},"成":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"公":{"docs":{},"共":{"docs":{},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"接":{"docs":{},"口":{"docs":{},"中":{"docs":{},"，":{"docs":{},"仅":{"docs":{},"需":{"docs":{},"要":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"些":{"docs":{},"辅":{"docs":{},"助":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"来":{"docs":{},"简":{"docs":{},"化":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"提":{"docs":{},"供":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"地":{"docs":{},"址":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"组":{"docs":{},"件":{"docs":{},"中":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"动":{"docs":{},"态":{"docs":{},"地":{"docs":{},"导":{"docs":{},"入":{"docs":{},"新":{"docs":{},"加":{"docs":{},"入":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"移":{"docs":{},"除":{"docs":{},"被":{"docs":{},"删":{"docs":{},"除":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}},"端":{"docs":{},"口":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"端":{"docs":{},"口":{"docs":{},"是":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}},"记":{"docs":{},"录":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"行":{"docs":{},"为":{"docs":{},"，":{"docs":{},"以":{"docs":{},"便":{"docs":{},"受":{"docs":{},"益":{"docs":{},"于":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}},"扩":{"docs":{},"展":{"docs":{},"。":{"docs":{},"它":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"对":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"提":{"docs":{},"供":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}},"支":{"docs":{},"持":{"docs":{},"从":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.003656307129798903}}}}}}}},"支":{"docs":{},"持":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}},"读":{"docs":{},"权":{"docs":{},"限":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}},"日":{"docs":{},"志":{"docs":{},"默":{"docs":{},"认":{"docs":{},"采":{"docs":{},"用":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}},"根":{"docs":{},"目":{"docs":{},"录":{"docs":{},"中":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"此":{"docs":{},"文":{"docs":{},"件":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"外":{"docs":{},"部":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"则":{"docs":{},"必":{"docs":{},"须":{"docs":{},"将":{"docs":{},"其":{"docs":{},"添":{"docs":{},"加":{"docs":{},"至":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}}}}}}}}},"安":{"docs":{},"装":{"docs":{},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{},"的":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}},"目":{"docs":{},"的":{"docs":{},"。":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"其":{"docs":{},"底":{"docs":{},"层":{"docs":{},"实":{"docs":{},"现":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"于":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"用":{"docs":{},"于":{"docs":{},"将":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}},"示":{"docs":{},"范":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"为":{"docs":{},"了":{"docs":{},"解":{"docs":{},"释":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"的":{"docs":{},"用":{"docs":{},"法":{"docs":{},"简":{"docs":{},"写":{"docs":{},"了":{"docs":{},"代":{"docs":{},"码":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}},"例":{"docs":{},"代":{"docs":{},"码":{"docs":{},"：":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}},"答":{"docs":{},"：":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"对":{"docs":{},"象":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"种":{"docs":{},"异":{"docs":{},"步":{"docs":{},"结":{"docs":{},"果":{"docs":{},"的":{"docs":{},"包":{"docs":{},"装":{"docs":{},"，":{"docs":{},"用":{"docs":{},"户":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"类":{"docs":{},"中":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"保":{"docs":{},"存":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"在":{"docs":{},"原":{"docs":{},"先":{"docs":{},"使":{"docs":{},"用":{"docs":{},"该":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"地":{"docs":{},"方":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"方":{"docs":{},"法":{"docs":{},"予":{"docs":{},"以":{"docs":{},"填":{"docs":{},"充":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"便":{"docs":{},"可":{"docs":{},"将":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"从":{"docs":{},"原":{"docs":{},"参":{"docs":{},"数":{"docs":{},"中":{"docs":{},"取":{"docs":{},"出":{"docs":{},"，":{"docs":{},"以":{"docs":{},"减":{"docs":{},"少":{"docs":{},"回":{"docs":{},"调":{"docs":{},"缩":{"docs":{},"进":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"规":{"docs":{},"避":{"docs":{},"回":{"docs":{},"调":{"docs":{},"地":{"docs":{},"狱":{"docs":{},"，":{"docs":{},"来":{"docs":{},"看":{"docs":{},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"各":{"docs":{},"种":{"docs":{},"预":{"docs":{},"设":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"等":{"docs":{},"，":{"docs":{},"一":{"docs":{},"般":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"建":{"docs":{},"议":{"docs":{},"将":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"与":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"对":{"docs":{},"象":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"对":{"docs":{},"象":{"docs":{},"内":{"docs":{},"保":{"docs":{},"留":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"将":{"docs":{},"其":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"会":{"docs":{},"在":{"docs":{},"执":{"docs":{},"行":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"执":{"docs":{},"行":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"并":{"docs":{},"保":{"docs":{},"存":{"docs":{},"该":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"生":{"docs":{},"命":{"docs":{},"周":{"docs":{},"期":{"docs":{},"内":{"docs":{},"，":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"频":{"docs":{},"繁":{"docs":{},"创":{"docs":{},"建":{"docs":{},"和":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"同":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"，":{"docs":{},"建":{"docs":{},"议":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"生":{"docs":{},"命":{"docs":{},"周":{"docs":{},"期":{"docs":{},"内":{"docs":{},"对":{"docs":{},"于":{"docs":{},"特":{"docs":{},"定":{"docs":{},"领":{"docs":{},"域":{"docs":{},"，":{"docs":{},"只":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"并":{"docs":{},"复":{"docs":{},"用":{"docs":{},"该":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"其":{"docs":{},"实":{"docs":{},"就":{"docs":{},"是":{"docs":{},"建":{"docs":{},"立":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"内":{"docs":{},"部":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"安":{"docs":{},"全":{"docs":{},"机":{"docs":{},"制":{"docs":{},"，":{"docs":{},"让":{"docs":{},"用":{"docs":{},"户":{"docs":{},"可":{"docs":{},"以":{"docs":{},"排":{"docs":{},"除":{"docs":{},"多":{"docs":{},"线":{"docs":{},"程":{"docs":{},"并":{"docs":{},"发":{"docs":{},"冲":{"docs":{},"突":{"docs":{},"的":{"docs":{},"干":{"docs":{},"扰":{"docs":{},"，":{"docs":{},"专":{"docs":{},"注":{"docs":{},"于":{"docs":{},"业":{"docs":{},"务":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"上":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"用":{"docs":{},"了":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"，":{"docs":{},"您":{"docs":{},"就":{"docs":{},"不":{"docs":{},"用":{"docs":{},"操":{"docs":{},"心":{"docs":{},"多":{"docs":{},"线":{"docs":{},"程":{"docs":{},"和":{"docs":{},"并":{"docs":{},"发":{"docs":{},"的":{"docs":{},"问":{"docs":{},"题":{"docs":{},"了":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"内":{"docs":{},"部":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"除":{"docs":{},"非":{"docs":{},"声":{"docs":{},"明":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"是":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"对":{"docs":{},"象":{"docs":{},"往":{"docs":{},"往":{"docs":{},"包":{"docs":{},"含":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"或":{"docs":{},"者":{"docs":{},"多":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"，":{"docs":{},"在":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"，":{"docs":{},"后":{"docs":{},"者":{"docs":{},"经":{"docs":{},"常":{"docs":{},"是":{"docs":{},"以":{"docs":{},"l":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"d":{"docs":{},"a":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"匿":{"docs":{},"名":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"出":{"docs":{},"现":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"严":{"docs":{},"格":{"docs":{},"说":{"docs":{},"来":{"docs":{},"，":{"docs":{},"不":{"docs":{},"同":{"docs":{},"框":{"docs":{},"架":{"docs":{},"和":{"docs":{},"语":{"docs":{},"言":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"概":{"docs":{},"念":{"docs":{},"无":{"docs":{},"法":{"docs":{},"一":{"docs":{},"一":{"docs":{},"对":{"docs":{},"应":{"docs":{},"，":{"docs":{},"但":{"docs":{},"如":{"docs":{},"果":{"docs":{},"我":{"docs":{},"们":{"docs":{},"不":{"docs":{},"那":{"docs":{},"么":{"docs":{},"严":{"docs":{},"格":{"docs":{},"地":{"docs":{},"去":{"docs":{},"深":{"docs":{},"究":{"docs":{},"细":{"docs":{},"节":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"概":{"docs":{},"念":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"其":{"docs":{},"它":{"docs":{},"框":{"docs":{},"架":{"docs":{},"以":{"docs":{},"及":{"docs":{},"语":{"docs":{},"言":{"docs":{},"中":{"docs":{},"找":{"docs":{},"到":{"docs":{},"一":{"docs":{},"些":{"docs":{},"痕":{"docs":{},"迹":{"docs":{},"，":{"docs":{},"以":{"docs":{},"下":{"docs":{},"是":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"概":{"docs":{},"念":{"docs":{},"跟":{"docs":{},"其":{"docs":{},"它":{"docs":{},"框":{"docs":{},"架":{"docs":{},"和":{"docs":{},"语":{"docs":{},"言":{"docs":{},"定":{"docs":{},"义":{"docs":{},"概":{"docs":{},"念":{"docs":{},"的":{"docs":{},"比":{"docs":{},"较":{"docs":{},"，":{"docs":{},"同":{"docs":{},"一":{"docs":{},"行":{"docs":{},"中":{"docs":{},"的":{"docs":{},"概":{"docs":{},"念":{"docs":{},"可":{"docs":{},"被":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"相":{"docs":{},"似":{"docs":{},"的":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"要":{"docs":{},"认":{"docs":{},"真":{"docs":{},"看":{"docs":{},"代":{"docs":{},"码":{"docs":{},"文":{"docs":{},"档":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"，":{"docs":{},"来":{"docs":{},"判":{"docs":{},"断":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"还":{"docs":{},"是":{"docs":{},"同":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"文":{"docs":{},"档":{"docs":{},"中":{"docs":{},"没":{"docs":{},"有":{"docs":{},"明":{"docs":{},"确":{"docs":{},"说":{"docs":{},"明":{"docs":{},"，":{"docs":{},"则":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{},"同":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"异":{"docs":{},"步":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"往":{"docs":{},"往":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"i":{"docs":{},"o":{"docs":{},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"，":{"docs":{},"所":{"docs":{},"谓":{"docs":{},"i":{"docs":{},"o":{"docs":{},"一":{"docs":{},"般":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"涉":{"docs":{},"及":{"docs":{},"到":{"docs":{},"硬":{"docs":{},"盘":{"docs":{},"（":{"docs":{},"比":{"docs":{},"如":{"docs":{},"在":{"docs":{},"硬":{"docs":{},"盘":{"docs":{},"上":{"docs":{},"存":{"docs":{},"取":{"docs":{},"文":{"docs":{},"件":{"docs":{},"）":{"docs":{},"，":{"docs":{},"网":{"docs":{},"络":{"docs":{},"（":{"docs":{},"通":{"docs":{},"过":{"docs":{},"网":{"docs":{},"络":{"docs":{},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"并":{"docs":{},"获":{"docs":{},"取":{"docs":{},"相":{"docs":{},"应":{"docs":{},"结":{"docs":{},"果":{"docs":{},"）":{"docs":{},"，":{"docs":{},"其":{"docs":{},"它":{"docs":{},"进":{"docs":{},"程":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"（":{"docs":{},"操":{"docs":{},"作":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"）":{"docs":{},"等":{"docs":{},"，":{"docs":{},"一":{"docs":{},"般":{"docs":{},"纯":{"docs":{},"粹":{"docs":{},"的":{"docs":{},"，":{"docs":{},"本":{"docs":{},"进":{"docs":{},"程":{"docs":{},"内":{"docs":{},"的":{"docs":{},"内":{"docs":{},"存":{"docs":{},"操":{"docs":{},"作":{"docs":{},"并":{"docs":{},"不":{"docs":{},"被":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"涉":{"docs":{},"及":{"docs":{},"i":{"docs":{},"o":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"时":{"docs":{},"候":{"docs":{},"将":{"docs":{},"方":{"docs":{},"法":{"docs":{},"或":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"制":{"docs":{},"作":{"docs":{},"成":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"并":{"docs":{},"无":{"docs":{},"实":{"docs":{},"际":{"docs":{},"意":{"docs":{},"义":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"一":{"docs":{},"般":{"docs":{},"非":{"docs":{},"i":{"docs":{},"o":{"docs":{},"相":{"docs":{},"关":{"docs":{},"操":{"docs":{},"作":{"docs":{},"都":{"docs":{},"被":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"同":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"占":{"docs":{},"用":{"docs":{},"显":{"docs":{},"著":{"docs":{},"执":{"docs":{},"行":{"docs":{},"时":{"docs":{},"间":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"不":{"docs":{},"会":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"线":{"docs":{},"程":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"初":{"docs":{},"次":{"docs":{},"接":{"docs":{},"触":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"开":{"docs":{},"发":{"docs":{},"人":{"docs":{},"员":{"docs":{},"往":{"docs":{},"往":{"docs":{},"会":{"docs":{},"在":{"docs":{},"异":{"docs":{},"步":{"docs":{},"，":{"docs":{},"显":{"docs":{},"著":{"docs":{},"执":{"docs":{},"行":{"docs":{},"时":{"docs":{},"间":{"docs":{},"，":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"等":{"docs":{},"概":{"docs":{},"念":{"docs":{},"理":{"docs":{},"解":{"docs":{},"上":{"docs":{},"遇":{"docs":{},"到":{"docs":{},"一":{"docs":{},"定":{"docs":{},"的":{"docs":{},"困":{"docs":{},"难":{"docs":{},"，":{"docs":{},"在":{"docs":{},"此":{"docs":{},"一":{"docs":{},"并":{"docs":{},"做":{"docs":{},"个":{"docs":{},"解":{"docs":{},"释":{"docs":{},"和":{"docs":{},"说":{"docs":{},"明":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"因":{"docs":{},"为":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"（":{"docs":{},"不":{"docs":{},"可":{"docs":{},"变":{"docs":{},"的":{"docs":{},"）":{"docs":{},"的":{"docs":{},"东":{"docs":{},"西":{"docs":{},"线":{"docs":{},"程":{"docs":{},"安":{"docs":{},"全":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"多":{"docs":{},"个":{"docs":{},"线":{"docs":{},"程":{"docs":{},"安":{"docs":{},"全":{"docs":{},"地":{"docs":{},"并":{"docs":{},"发":{"docs":{},"访":{"docs":{},"问":{"docs":{},"，":{"docs":{},"线":{"docs":{},"程":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"一":{"docs":{},"份":{"docs":{},"也":{"docs":{},"不":{"docs":{},"会":{"docs":{},"有":{"docs":{},"并":{"docs":{},"发":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"里":{"docs":{},"面":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"对":{"docs":{},"象":{"docs":{},"是":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"（":{"docs":{},"不":{"docs":{},"可":{"docs":{},"变":{"docs":{},"）":{"docs":{},"的":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"缺":{"docs":{},"省":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"事":{"docs":{},"件":{"docs":{},"总":{"docs":{},"线":{"docs":{},"（":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},"）":{"docs":{},"上":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"是":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"也":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"事":{"docs":{},"件":{"docs":{},"总":{"docs":{},"线":{"docs":{},"上":{"docs":{},"消":{"docs":{},"息":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"编":{"docs":{},"解":{"docs":{},"码":{"docs":{},"器":{"docs":{},"，":{"docs":{},"除":{"docs":{},"了":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"以":{"docs":{},"外":{"docs":{},"，":{"docs":{},"还":{"docs":{},"支":{"docs":{},"持":{"docs":{},"少":{"docs":{},"量":{"docs":{},"的":{"docs":{},"其":{"docs":{},"它":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"原":{"docs":{},"始":{"docs":{},"数":{"docs":{},"据":{"docs":{},"类":{"docs":{},"型":{"docs":{},"及":{"docs":{},"其":{"docs":{},"包":{"docs":{},"装":{"docs":{},"类":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"字":{"docs":{},"节":{"docs":{},"流":{"docs":{},"（":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"[":{"docs":{},"]":{"docs":{},"）":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"（":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},",":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"和":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"：":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}},"自":{"docs":{},"身":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"链":{"docs":{},"式":{"docs":{},"地":{"docs":{},"调":{"docs":{},"用":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"动":{"docs":{},"关":{"docs":{},"闭":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},"故":{"docs":{},"障":{"docs":{},"转":{"docs":{},"移":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"生":{"docs":{},"成":{"docs":{},"了":{"docs":{},"适":{"docs":{},"应":{"docs":{},"不":{"docs":{},"同":{"docs":{},"语":{"docs":{},"言":{"docs":{},"代":{"docs":{},"码":{"docs":{},"风":{"docs":{},"格":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"提":{"docs":{},"交":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"检":{"docs":{},"测":{"docs":{},"并":{"docs":{},"使":{"docs":{},"用":{"docs":{},"出":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}},"发":{"docs":{},"现":{"docs":{},"及":{"docs":{},"网":{"docs":{},"络":{"docs":{},"传":{"docs":{},"输":{"docs":{},"配":{"docs":{},"置":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}},"签":{"docs":{},"名":{"docs":{},"证":{"docs":{},"书":{"docs":{},"也":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"其":{"docs":{},"他":{"docs":{},"基":{"docs":{},"于":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{},"的":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"如":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"带":{"docs":{},"现":{"docs":{},"成":{"docs":{},"的":{"docs":{},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"与":{"docs":{},"反":{"docs":{},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"机":{"docs":{},"制":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"处":{"docs":{},"理":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"与":{"docs":{},"反":{"docs":{},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"机":{"docs":{},"制":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"配":{"docs":{},"置":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"获":{"docs":{},"取":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"步":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}},"终":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"的":{"docs":{},"过":{"docs":{},"程":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"结":{"docs":{},"果":{"docs":{},"可":{"docs":{},"以":{"docs":{},"传":{"docs":{},"给":{"docs":{},"您":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"中":{"docs":{},"。":{"docs":{},"以":{"docs":{},"下":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"到":{"docs":{},"了":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"下":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"的":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"出":{"docs":{},"现":{"docs":{},"了":{"docs":{},"问":{"docs":{},"题":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"完":{"docs":{},"整":{"docs":{},"列":{"docs":{},"表":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"整":{"docs":{},"个":{"docs":{},"集":{"docs":{},"合":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"，":{"docs":{},"`":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}},"响":{"docs":{},"应":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.0037243947858473}}}},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"连":{"docs":{},"接":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}},"的":{"docs":{},"这":{"docs":{},"个":{"docs":{},"连":{"docs":{},"接":{"docs":{},"，":{"docs":{},"是":{"docs":{},"接":{"docs":{},"口":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}},"连":{"docs":{},"接":{"docs":{},"，":{"docs":{},"是":{"docs":{},"接":{"docs":{},"口":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}},"连":{"docs":{},"接":{"docs":{},"失":{"docs":{},"败":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"传":{"docs":{},"递":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"对":{"docs":{},"象":{"docs":{},"来":{"docs":{},"配":{"docs":{},"置":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"括":{"docs":{},"用":{"docs":{},"来":{"docs":{},"配":{"docs":{},"置":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"各":{"docs":{},"种":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"某":{"docs":{},"些":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"额":{"docs":{},"外":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"有":{"docs":{},"些":{"docs":{},"需":{"docs":{},"要":{"docs":{},"（":{"docs":{},"比":{"docs":{},"如":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"对":{"docs":{},"象":{"docs":{},"）":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"新":{"docs":{},"配":{"docs":{},"置":{"docs":{},"时":{"docs":{},"发":{"docs":{},"生":{"docs":{},"错":{"docs":{},"误":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"发":{"docs":{},"生":{"docs":{},"错":{"docs":{},"误":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"得":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"锁":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"连":{"docs":{},"接":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},"次":{"docs":{},"性":{"docs":{},"的":{"docs":{},"事":{"docs":{},"件":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}},"异":{"docs":{},"步":{"docs":{},"操":{"docs":{},"作":{"docs":{},"结":{"docs":{},"果":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"消":{"docs":{},"息":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"计":{"docs":{},"算":{"docs":{},"机":{"docs":{},"本":{"docs":{},"质":{"docs":{},"上":{"docs":{},"是":{"docs":{},"计":{"docs":{},"算":{"docs":{},"的":{"docs":{},"机":{"docs":{},"器":{"docs":{},"，":{"docs":{},"任":{"docs":{},"何":{"docs":{},"一":{"docs":{},"个":{"docs":{},"指":{"docs":{},"令":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"都":{"docs":{},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"定":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"予":{"docs":{},"以":{"docs":{},"完":{"docs":{},"成":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"时":{"docs":{},"间":{"docs":{},"可":{"docs":{},"能":{"docs":{},"长":{"docs":{},"可":{"docs":{},"能":{"docs":{},"短":{"docs":{},"，":{"docs":{},"而":{"docs":{},"这":{"docs":{},"些":{"docs":{},"指":{"docs":{},"令":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"都":{"docs":{},"会":{"docs":{},"分":{"docs":{},"配":{"docs":{},"给":{"docs":{},"一":{"docs":{},"个":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{},"线":{"docs":{},"程":{"docs":{},"中":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"成":{"docs":{},"。":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"，":{"docs":{},"黄":{"docs":{},"金":{"docs":{},"原":{"docs":{},"则":{"docs":{},"是":{"docs":{},"不":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"而":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"顾":{"docs":{},"名":{"docs":{},"思":{"docs":{},"义":{"docs":{},"，":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"事":{"docs":{},"件":{"docs":{},"的":{"docs":{},"循":{"docs":{},"环":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"生":{"docs":{},"命":{"docs":{},"周":{"docs":{},"期":{"docs":{},"内":{"docs":{},"，":{"docs":{},"不":{"docs":{},"停":{"docs":{},"轮":{"docs":{},"询":{"docs":{},"事":{"docs":{},"件":{"docs":{},"是":{"docs":{},"否":{"docs":{},"发":{"docs":{},"生":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"发":{"docs":{},"生":{"docs":{},"的":{"docs":{},"事":{"docs":{},"件":{"docs":{},"交":{"docs":{},"给":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"予":{"docs":{},"以":{"docs":{},"处":{"docs":{},"理":{"docs":{},"的":{"docs":{},"无":{"docs":{},"限":{"docs":{},"调":{"docs":{},"度":{"docs":{},"循":{"docs":{},"环":{"docs":{},"线":{"docs":{},"程":{"docs":{},"。":{"docs":{},"那":{"docs":{},"么":{"docs":{},"为":{"docs":{},"了":{"docs":{},"不":{"docs":{},"停":{"docs":{},"地":{"docs":{},"检":{"docs":{},"查":{"docs":{},"事":{"docs":{},"件":{"docs":{},"是":{"docs":{},"否":{"docs":{},"发":{"docs":{},"生":{"docs":{},"，":{"docs":{},"该":{"docs":{},"线":{"docs":{},"程":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"短":{"docs":{},"时":{"docs":{},"间":{"docs":{},"内":{"docs":{},"完":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"调":{"docs":{},"度":{"docs":{},"循":{"docs":{},"环":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"在":{"docs":{},"完":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"调":{"docs":{},"度":{"docs":{},"循":{"docs":{},"环":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"过":{"docs":{},"长":{"docs":{},"，":{"docs":{},"就":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"导":{"docs":{},"致":{"docs":{},"新":{"docs":{},"发":{"docs":{},"生":{"docs":{},"的":{"docs":{},"事":{"docs":{},"件":{"docs":{},"得":{"docs":{},"不":{"docs":{},"到":{"docs":{},"及":{"docs":{},"时":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"，":{"docs":{},"进":{"docs":{},"而":{"docs":{},"导":{"docs":{},"致":{"docs":{},"单":{"docs":{},"次":{"docs":{},"事":{"docs":{},"件":{"docs":{},"响":{"docs":{},"应":{"docs":{},"时":{"docs":{},"间":{"docs":{},"过":{"docs":{},"长":{"docs":{},"，":{"docs":{},"影":{"docs":{},"响":{"docs":{},"客":{"docs":{},"户":{"docs":{},"体":{"docs":{},"验":{"docs":{},"。":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"数":{"docs":{},"操":{"docs":{},"作":{"docs":{},"、":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"的":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}},"让":{"docs":{},"异":{"docs":{},"步":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"和":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"编":{"docs":{},"写":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"看":{"docs":{},"起":{"docs":{},"来":{"docs":{},"一":{"docs":{},"致":{"docs":{},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{},"任":{"docs":{},"何":{"docs":{},"一":{"docs":{},"步":{"docs":{},"抛":{"docs":{},"出":{"docs":{},"异":{"docs":{},"常":{"docs":{},"时":{"docs":{},"直":{"docs":{},"接":{"docs":{},"退":{"docs":{},"出":{"docs":{},"到":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"个":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"举":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"要":{"docs":{},"从":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"将":{"docs":{},"数":{"docs":{},"据":{"docs":{},"写":{"docs":{},"入":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"看":{"docs":{},"看":{"docs":{},"使":{"docs":{},"用":{"docs":{},"异":{"docs":{},"步":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"几":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"些":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"过":{"docs":{},"滤":{"docs":{},"器":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}},"改":{"docs":{},"变":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"通":{"docs":{},"过":{"docs":{},"研":{"docs":{},"究":{"docs":{},"一":{"docs":{},"些":{"docs":{},"样":{"docs":{},"例":{"docs":{},"来":{"docs":{},"了":{"docs":{},"解":{"docs":{},"相":{"docs":{},"关":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}},"先":{"docs":{},"看":{"docs":{},"看":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"并":{"docs":{},"了":{"docs":{},"解":{"docs":{},"一":{"docs":{},"下":{"docs":{},"为":{"docs":{},"什":{"docs":{},"么":{"docs":{},"它":{"docs":{},"们":{"docs":{},"有":{"docs":{},"用":{"docs":{},"。":{"docs":{},"假":{"docs":{},"设":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"服":{"docs":{},"务":{"docs":{},"暴":{"docs":{},"露":{"docs":{},"在":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"监":{"docs":{},"听":{"docs":{},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"主":{"docs":{},"机":{"docs":{},"和":{"docs":{},"端":{"docs":{},"口":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"访":{"docs":{},"问":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},"文":{"docs":{},"件":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"系":{"docs":{},"统":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"否":{"docs":{},"则":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"引":{"docs":{},"起":{"docs":{},"由":{"docs":{},"流":{"docs":{},"量":{"docs":{},"嗅":{"docs":{},"探":{"docs":{},"引":{"docs":{},"起":{"docs":{},"的":{"docs":{},"会":{"docs":{},"话":{"docs":{},"劫":{"docs":{},"持":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"令":{"docs":{},"牌":{"docs":{},"对":{"docs":{},"象":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}},"该":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"输":{"docs":{},"入":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"有":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"也":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"命":{"docs":{},"令":{"docs":{},"集":{"docs":{},"是":{"docs":{},"可":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"的":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"目":{"docs":{},"录":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"可":{"docs":{},"写":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"可":{"docs":{},"通":{"docs":{},"过":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"会":{"docs":{},"将":{"docs":{},"从":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"请":{"docs":{},"求":{"docs":{},"到":{"docs":{},"写":{"docs":{},"入":{"docs":{},"响":{"docs":{},"应":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"数":{"docs":{},"写":{"docs":{},"入":{"docs":{},"到":{"docs":{},"响":{"docs":{},"应":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"渲":{"docs":{},"染":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"，":{"docs":{},"并":{"docs":{},"默":{"docs":{},"认":{"docs":{},"设":{"docs":{},"置":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"存":{"docs":{},"储":{"docs":{},"将":{"docs":{},"会":{"docs":{},"话":{"docs":{},"保":{"docs":{},"存":{"docs":{},"在":{"docs":{},"内":{"docs":{},"存":{"docs":{},"中":{"docs":{},"，":{"docs":{},"并":{"docs":{},"只":{"docs":{},"在":{"docs":{},"当":{"docs":{},"前":{"docs":{},"实":{"docs":{},"例":{"docs":{},"中":{"docs":{},"有":{"docs":{},"效":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"分":{"docs":{},"布":{"docs":{},"式":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384},"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"启":{"docs":{},"用":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"启":{"docs":{},"用":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"使":{"docs":{},"用":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}},"开":{"docs":{},"箱":{"docs":{},"即":{"docs":{},"用":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"便":{"docs":{},"捷":{"docs":{},"的":{"docs":{},"、":{"docs":{},"可":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"的":{"docs":{},"、":{"docs":{},"类":{"docs":{},"似":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"源":{"docs":{},"文":{"docs":{},"件":{"docs":{},"运":{"docs":{},"行":{"1":{"0":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"docs":{}},"docs":{}}}}}},"覆":{"docs":{},"盖":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"一":{"docs":{},"个":{"docs":{},"挂":{"docs":{},"载":{"docs":{},"点":{"docs":{},"挂":{"docs":{},"载":{"docs":{},"到":{"docs":{},"主":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"内":{"docs":{},"置":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}},"正":{"docs":{},"则":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"捕":{"docs":{},"捉":{"docs":{},"路":{"docs":{},"径":{"docs":{},"参":{"docs":{},"数":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"存":{"docs":{},"储":{"docs":{},"，":{"docs":{},"您":{"docs":{},"的":{"docs":{},"会":{"docs":{},"话":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"节":{"docs":{},"点":{"docs":{},"访":{"docs":{},"问":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"事":{"docs":{},"件":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"监":{"docs":{},"听":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"映":{"docs":{},"射":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}},"原":{"docs":{},"始":{"docs":{},"的":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"基":{"docs":{},"于":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"注":{"docs":{},"销":{"docs":{},"操":{"docs":{},"作":{"docs":{},"可":{"docs":{},"以":{"docs":{},"取":{"docs":{},"消":{"docs":{},"对":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}},"继":{"docs":{},"承":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"静":{"docs":{},"态":{"docs":{},"方":{"docs":{},"法":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"实":{"docs":{},"现":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"来":{"docs":{},"访":{"docs":{},"问":{"docs":{},"服":{"docs":{},"务":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"（":{"docs":{},"b":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"g":{"docs":{},"e":{"docs":{},"）":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"其":{"docs":{},"他":{"docs":{},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"组":{"docs":{},"件":{"docs":{},"中":{"docs":{},"导":{"docs":{},"入":{"docs":{},"和":{"docs":{},"导":{"docs":{},"出":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"k":{"docs":{},"u":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"等":{"docs":{},"。":{"docs":{},"每":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"，":{"docs":{},"决":{"docs":{},"定":{"docs":{},"了":{"docs":{},"服":{"docs":{},"务":{"docs":{},"如":{"docs":{},"何":{"docs":{},"导":{"docs":{},"入":{"docs":{},"和":{"docs":{},"导":{"docs":{},"出":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"不":{"docs":{},"一":{"docs":{},"定":{"docs":{},"都":{"docs":{},"是":{"docs":{},"双":{"docs":{},"向":{"docs":{},"的":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"插":{"docs":{},"拔":{"docs":{},"的":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353}}}}}}}}}}}}}}}}}}},"上":{"docs":{},"述":{"docs":{},"两":{"docs":{},"项":{"docs":{},"系":{"docs":{},"统":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"j":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}},"编":{"docs":{},"码":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"，":{"docs":{},"设":{"docs":{},"置":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}},"消":{"docs":{},"息":{"docs":{},"与":{"docs":{},"服":{"docs":{},"务":{"docs":{},"交":{"docs":{},"互":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}},"常":{"docs":{},"您":{"docs":{},"希":{"docs":{},"望":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"需":{"docs":{},"要":{"docs":{},"像":{"docs":{},"上":{"docs":{},"边":{"docs":{},"例":{"docs":{},"子":{"docs":{},"一":{"docs":{},"样":{"docs":{},"重":{"docs":{},"写":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"以":{"docs":{},"异":{"docs":{},"步":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"相":{"docs":{},"关":{"docs":{},"配":{"docs":{},"置":{"docs":{},"是":{"docs":{},"由":{"docs":{},"打":{"docs":{},"包":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"中":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}}}}}}},"z":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"中":{"docs":{},"会":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}},"，":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{},"会":{"docs":{},"对":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"表":{"docs":{},"示":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"中":{"docs":{},"的":{"docs":{},"类":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"，":{"docs":{},"您":{"docs":{},"想":{"docs":{},"发":{"docs":{},"出":{"docs":{},"没":{"docs":{},"有":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"的":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"都":{"docs":{},"会":{"docs":{},"让":{"docs":{},"您":{"docs":{},"从":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"连":{"docs":{},"接":{"docs":{},"中":{"docs":{},"得":{"docs":{},"到":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"个":{"docs":{},"插":{"docs":{},"入":{"docs":{},"的":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}}},"知":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},"何":{"docs":{},"时":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"所":{"docs":{},"有":{"docs":{},"流":{"docs":{},"，":{"docs":{},"连":{"docs":{},"接":{"docs":{},"尚":{"docs":{},"未":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"信":{"docs":{},"时":{"docs":{},"十":{"docs":{},"分":{"docs":{},"方":{"docs":{},"便":{"docs":{},"。":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}},"问":{"docs":{},"：":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}},"中":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"该":{"docs":{},"如":{"docs":{},"何":{"docs":{},"正":{"docs":{},"确":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"怎":{"docs":{},"样":{"docs":{},"规":{"docs":{},"避":{"docs":{},"回":{"docs":{},"调":{"docs":{},"地":{"docs":{},"狱":{"docs":{},"？":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}},"各":{"docs":{},"种":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"该":{"docs":{},"如":{"docs":{},"何":{"docs":{},"正":{"docs":{},"确":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"用":{"docs":{},"完":{"docs":{},"是":{"docs":{},"否":{"docs":{},"需":{"docs":{},"要":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"？":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"对":{"docs":{},"象":{"docs":{},"和":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"是":{"docs":{},"什":{"docs":{},"么":{"docs":{},"关":{"docs":{},"系":{"docs":{},"？":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"如":{"docs":{},"何":{"docs":{},"保":{"docs":{},"证":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"内":{"docs":{},"部":{"docs":{},"线":{"docs":{},"程":{"docs":{},"安":{"docs":{},"全":{"docs":{},"？":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"为":{"docs":{},"什":{"docs":{},"么":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"之":{"docs":{},"间":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"要":{"docs":{},"求":{"docs":{},"是":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"（":{"docs":{},"不":{"docs":{},"可":{"docs":{},"变":{"docs":{},"）":{"docs":{},"的":{"docs":{},"？":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"什":{"docs":{},"么":{"docs":{},"是":{"docs":{},"显":{"docs":{},"著":{"docs":{},"执":{"docs":{},"行":{"docs":{},"时":{"docs":{},"间":{"docs":{},"？":{"docs":{},"什":{"docs":{},"么":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"？":{"docs":{},"如":{"docs":{},"何":{"docs":{},"正":{"docs":{},"确":{"docs":{},"理":{"docs":{},"解":{"docs":{},"文":{"docs":{},"档":{"docs":{},"中":{"docs":{},"说":{"docs":{},"的":{"docs":{},"不":{"docs":{},"要":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"？":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"怎":{"docs":{},"样":{"docs":{},"正":{"docs":{},"确":{"docs":{},"理":{"docs":{},"解":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"机":{"docs":{},"制":{"docs":{},"？":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}},"我":{"docs":{},"之":{"docs":{},"前":{"docs":{},"有":{"docs":{},"过":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"，":{"docs":{},"a":{"docs":{},"k":{"docs":{},"k":{"docs":{},"a":{"docs":{},"，":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"或":{"docs":{},"g":{"docs":{},"o":{"docs":{},"的":{"docs":{},"经":{"docs":{},"验":{"docs":{},"，":{"docs":{},"请":{"docs":{},"问":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"概":{"docs":{},"念":{"docs":{},"有":{"docs":{},"我":{"docs":{},"熟":{"docs":{},"悉":{"docs":{},"的":{"docs":{},"吗":{"docs":{},"？":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"刚":{"docs":{},"拿":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"第":{"docs":{},"三":{"docs":{},"方":{"docs":{},"类":{"docs":{},"库":{"docs":{},"（":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"）":{"docs":{},"，":{"docs":{},"怎":{"docs":{},"么":{"docs":{},"判":{"docs":{},"断":{"docs":{},"这":{"docs":{},"个":{"docs":{},"类":{"docs":{},"库":{"docs":{},"中":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"还":{"docs":{},"是":{"docs":{},"同":{"docs":{},"步":{"docs":{},"的":{"docs":{},"？":{"docs":{},"有":{"docs":{},"没":{"docs":{},"有":{"docs":{},"简":{"docs":{},"单":{"docs":{},"粗":{"docs":{},"暴":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"可":{"docs":{},"以":{"docs":{},"一":{"docs":{},"眼":{"docs":{},"看":{"docs":{},"出":{"docs":{},"来":{"docs":{},"？":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{"start/FAQ.html":{"ref":"start/FAQ.html","tf":0.0021413276231263384}}}},"它":{"docs":{},"可":{"docs":{},"使":{"docs":{},"您":{"docs":{},"避":{"docs":{},"免":{"docs":{},"用":{"docs":{},"传":{"docs":{},"统":{"docs":{},"方":{"docs":{},"式":{"docs":{},"编":{"docs":{},"写":{"docs":{},"代":{"docs":{},"码":{"docs":{},"：":{"docs":{},"如":{"docs":{},"果":{"docs":{},"成":{"docs":{},"功":{"docs":{},"则":{"docs":{},"完":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"也":{"docs":{},"是":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}},"同":{"docs":{},"样":{"docs":{},"也":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"您":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"某":{"docs":{},"些":{"docs":{},"处":{"docs":{},"理":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"则":{"docs":{},"设":{"docs":{},"置":{"docs":{},"此":{"docs":{},"参":{"docs":{},"数":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"因":{"docs":{},"为":{"docs":{},"由":{"docs":{},"它":{"docs":{},"决":{"docs":{},"定":{"docs":{},"更":{"docs":{},"新":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"将":{"docs":{},"会":{"docs":{},"在":{"docs":{},"集":{"docs":{},"合":{"docs":{},"的":{"docs":{},"文":{"docs":{},"档":{"docs":{},"中":{"docs":{},"，":{"docs":{},"以":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}},"代":{"docs":{},"表":{"docs":{},"系":{"docs":{},"统":{"docs":{},"在":{"docs":{},"与":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"永":{"docs":{},"远":{"docs":{},"不":{"docs":{},"超":{"docs":{},"时":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"这":{"docs":{},"是":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{},"超":{"docs":{},"时":{"docs":{},"时":{"docs":{},"间":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"一":{"docs":{},"个":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"所":{"docs":{},"有":{"docs":{},"域":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}},"我":{"docs":{},"们":{"docs":{},"也":{"docs":{},"能":{"docs":{},"将":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"然":{"docs":{},"后":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"实":{"docs":{},"现":{"docs":{},"自":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}},"那":{"docs":{},"得":{"docs":{},"首":{"docs":{},"先":{"docs":{},"把":{"docs":{},"这":{"docs":{},"个":{"docs":{},"一":{"docs":{},"般":{"docs":{},"的":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"工":{"docs":{},"程":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"中":{"docs":{},"加":{"docs":{},"上":{"docs":{},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}},"此":{"docs":{},"文":{"docs":{},"件":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}},"处":{"docs":{},"省":{"docs":{},"略":{"docs":{},"配":{"docs":{},"置":{"docs":{},"代":{"docs":{},"码":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}},"甚":{"docs":{},"至":{"docs":{},"直":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}},"在":{"docs":{},"亚":{"docs":{},"马":{"docs":{},"逊":{"docs":{},"云":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}},"如":{"docs":{},"果":{"docs":{},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}},"或":{"docs":{},"者":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}},"其":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"命":{"docs":{},"名":{"docs":{},"为":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}},"!":{"docs":{},"=":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.005620848237097598},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.008403361344537815}}},"!":{"docs":{},"!":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}},"#":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.007677543186180422},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.008213552361396304},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.011661807580174927},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.009852216748768473}}},"&":{"docs":{"integration/STOMPClient&Server.html":{"ref":"integration/STOMPClient&Server.html","tf":2.7}},"&":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0035769034236075624}}}},"+":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.009010682768230376},"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.03165735567970205},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.004073319755600814},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.005471956224350205},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.03777335984095427},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.016666666666666666},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.011570247933884297},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0046168051708217915},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.009554140127388535},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0058823529411764705}}},"[":{"2":{"docs":{},".":{"6":{"docs":{},".":{"0":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}},"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"docs":{}}},"docs":{}}},"docs":{}}},"4":{"docs":{},".":{"0":{"docs":{},".":{"3":{"1":{"docs":{},",":{"5":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}}}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"PLAN.html":{"ref":"PLAN.html","tf":0.03225806451612903}},"s":{"docs":{},"n":{"docs":{},"i":{"docs":{},"p":{"docs":{},"]":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922}}}}}}},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"]":{"docs":{},"|":{"docs":{},"(":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"/":{"docs":{},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"m":{"docs":{},"d":{"docs":{},")":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"编":{"docs":{},"程":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"实":{"docs":{},"现":{"docs":{},"：":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"]":{"docs":{},"|":{"docs":{},"(":{"docs":{},"/":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"/":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"m":{"docs":{},"d":{"docs":{},")":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}},"x":{"docs":{},"]":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.13709677419354838}}}}},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215}},"a":{"docs":{},"l":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"y":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.019438444924406047},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"和":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"k":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.026954177897574125}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}},".":{"docs":{},"j":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}},"c":{"docs":{},"e":{"docs":{},"k":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.02425876010781671}},"s":{"docs":{},")":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}},"p":{"docs":{},"f":{"docs":{},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}},":":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}},"i":{"docs":{},"z":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.02425876010781671}}}}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.02425876010781671}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0064794816414686825}}}}}}},"）":{"docs":{},"。":{"docs":{},"需":{"docs":{},"要":{"docs":{},"注":{"docs":{},"意":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}},"=":{"docs":{},"\"":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406}}}},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"a":{"docs":{},"l":{"docs":{},"g":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.02425876010781671}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.02425876010781671}}}}}}},"r":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}},"l":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"a":{"docs":{},"f":{"docs":{},"k":{"docs":{},"a":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":5.019880715705765},"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.007952286282306162}},"e":{"docs":{},"r":{"docs":{},"#":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.007952286282306162}},"e":{"docs":{},"r":{"docs":{},"#":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0033134526176275677}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"用":{"docs":{},"于":{"docs":{},"读":{"docs":{},"取":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"用":{"docs":{},"于":{"docs":{},"向":{"docs":{},"某":{"docs":{},"些":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0030659172202350538},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.006398537477148081},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"docs":{}}},"docs":{}}},"docs":{}},"中":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"在":{"docs":{},"导":{"docs":{},"入":{"docs":{},"到":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"后":{"docs":{},"都":{"docs":{},"会":{"docs":{},"创":{"docs":{},"建":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"）":{"docs":{},"。":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"都":{"docs":{},"将":{"docs":{},"映":{"docs":{},"射":{"docs":{},"为":{"docs":{},"一":{"docs":{},"条":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"，":{"docs":{},"则":{"docs":{},"会":{"docs":{},"优":{"docs":{},"先":{"docs":{},"使":{"docs":{},"用":{"docs":{},"此":{"docs":{},"值":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"p":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.008213552361396304}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0013934045517882026}},"，":{"docs":{},"单":{"docs":{},"您":{"docs":{},"已":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"您":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"主":{"docs":{},"类":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"：":{"docs":{},"启":{"docs":{},"动":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"m":{"docs":{},"b":{"docs":{},"d":{"docs":{},"a":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"n":{"docs":{},"g":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}},"r":{"docs":{},"g":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},",":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0010218300046446818},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"若":{"docs":{},"您":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"头":{"docs":{},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{},"会":{"docs":{},"出":{"docs":{},"错":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"：":{"docs":{},"要":{"docs":{},"读":{"docs":{},"取":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"字":{"docs":{},"节":{"docs":{},"数":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612}},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036}},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"s":{"docs":{},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"docs":{}}},"docs":{}}},"docs":{}}},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{},"挑":{"docs":{},"选":{"docs":{},"一":{"docs":{},"个":{"docs":{},"链":{"docs":{},"接":{"docs":{},"本":{"docs":{},"地":{"docs":{},"i":{"docs":{},"p":{"docs":{},"地":{"docs":{},"址":{"docs":{},"从":{"1":{"6":{"9":{"docs":{},".":{"2":{"5":{"4":{"docs":{},".":{"1":{"docs":{},".":{"0":{"docs":{},"到":{"1":{"6":{"9":{"docs":{},".":{"2":{"5":{"4":{"docs":{},".":{"2":{"5":{"4":{"docs":{},".":{"2":{"5":{"5":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"2":{"8":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}},"docs":{}},"docs":{}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.01094391244870041},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.004705882352941176}},"e":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}},"）":{"docs":{},"。":{"docs":{},"当":{"docs":{},"任":{"docs":{},"意":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"i":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.013223140495867768}}}}}}},"f":{"docs":{},"e":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"t":{"docs":{},"(":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"r":{"docs":{},"x":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"r":{"docs":{},"x":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"j":{"docs":{},"o":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}},";":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"变":{"docs":{},"换":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"k":{"docs":{},"e":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"z":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"x":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"负":{"docs":{},"责":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"，":{"9":{"4":{"3":{"4":{"7":{"0":{"5":{"4":{"9":{"docs":{},"@":{"docs":{},"q":{"docs":{},"q":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"负":{"docs":{},"责":{"docs":{},"校":{"docs":{},"对":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"功":{"docs":{},"能":{"docs":{},"查":{"docs":{},"找":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"以":{"docs":{},"便":{"docs":{},"在":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{},"查":{"docs":{},"找":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"方":{"docs":{},"法":{"docs":{},"获":{"docs":{},"取":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"）":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0025549310168625446}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"信":{"docs":{},"息":{"docs":{},"将":{"docs":{},"从":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"端":{"docs":{},"口":{"docs":{},"推":{"docs":{},"断":{"docs":{},"出":{"docs":{},"来":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612}},"!":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"g":{"4":{"docs":{},"j":{"2":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}},"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.01026694045174538}},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},".":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},"!":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"e":{"docs":{},"s":{"docs":{},"的":{"docs":{},"j":{"docs":{},"u":{"docs":{},"l":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"在":{"docs":{},"您":{"docs":{},"的":{"docs":{},"f":{"docs":{},"a":{"docs":{},"t":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"中":{"docs":{},"）":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"该":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"配":{"docs":{},"置":{"docs":{},"j":{"docs":{},"u":{"docs":{},"l":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"动":{"docs":{},"词":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"n":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.006109979633401222},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"k":{"docs":{},"u":{"docs":{},"p":{"4":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"6":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0061318344404701075}}}}},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0030654900139340455},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"为":{"docs":{},"了":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"您":{"docs":{},"诊":{"docs":{},"断":{"docs":{},"类":{"docs":{},"似":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"若":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"中":{"docs":{},"执":{"docs":{},"行":{"docs":{},"（":{"docs":{},"只":{"docs":{},"要":{"docs":{},"您":{"docs":{},"不":{"docs":{},"创":{"docs":{},"建":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"并":{"docs":{},"调":{"docs":{},"用":{"docs":{},"它":{"docs":{},"！":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"直":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"访":{"docs":{},"问":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"（":{"docs":{},"如":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"，":{"docs":{},"任":{"docs":{},"何":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"永":{"docs":{},"远":{"docs":{},"不":{"docs":{},"会":{"docs":{},"被":{"docs":{},"并":{"docs":{},"发":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"大":{"docs":{},"部":{"docs":{},"分":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"（":{"docs":{},"除":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"但":{"docs":{},"是":{"docs":{},"这":{"docs":{},"并":{"docs":{},"不":{"docs":{},"能":{"docs":{},"帮":{"docs":{},"您":{"docs":{},"避":{"docs":{},"免":{"docs":{},"在":{"docs":{},"您":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"中":{"docs":{},"阻":{"docs":{},"塞":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"而":{"docs":{},"且":{"docs":{},"您":{"docs":{},"希":{"docs":{},"望":{"docs":{},"每":{"docs":{},"秒":{"docs":{},"处":{"docs":{},"理":{"1":{"0":{"0":{"0":{"0":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"那":{"docs":{},"么":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"就":{"docs":{},"会":{"docs":{},"完":{"docs":{},"全":{"docs":{},"停":{"docs":{},"止":{"docs":{},"！":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"线":{"docs":{},"程":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"不":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"您":{"docs":{},"将":{"docs":{},"失":{"docs":{},"去":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"并":{"docs":{},"发":{"docs":{},"模":{"docs":{},"型":{"docs":{},"的":{"docs":{},"优":{"docs":{},"势":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"必":{"docs":{},"须":{"docs":{},"自":{"docs":{},"行":{"docs":{},"管":{"docs":{},"理":{"docs":{},"线":{"docs":{},"程":{"docs":{},"同":{"docs":{},"步":{"docs":{},"和":{"docs":{},"执":{"docs":{},"行":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"：":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}},"或":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"线":{"docs":{},"程":{"docs":{},")":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},":":{"docs":{},"挑":{"docs":{},"选":{"docs":{},"一":{"docs":{},"个":{"docs":{},"环":{"docs":{},"回":{"docs":{},"地":{"docs":{},"址":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"1":{"2":{"7":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"p":{"docs":{},"e":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.004103967168262654}},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}},"=":{"docs":{},"?":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"\"":{"docs":{},";":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}},"u":{"docs":{},"a":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.04433497536945813}},"_":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"：":{"docs":{},"这":{"docs":{},"个":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"是":{"docs":{},"设":{"docs":{},"置":{"docs":{},"l":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"必":{"docs":{},"须":{"docs":{},"以":{"docs":{},"l":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"开":{"docs":{},"头":{"docs":{},"，":{"docs":{},"端":{"docs":{},"口":{"docs":{},"也":{"docs":{},"必":{"docs":{},"须":{"docs":{},"要":{"docs":{},"指":{"docs":{},"定":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"l":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"m":{"docs":{},"y":{"docs":{},"l":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},":":{"1":{"0":{"3":{"8":{"9":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"t":{"docs":{},"i":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.01592356687898089}}}}}},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"（":{"docs":{},"多":{"docs":{},"数":{"docs":{},"派":{"docs":{},"机":{"docs":{},"制":{"docs":{},"）":{"docs":{},"。":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"r":{"docs":{},"u":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0007431490942870413}},"（":{"docs":{},"法":{"docs":{},"定":{"docs":{},"人":{"docs":{},"数":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"：":{"docs":{},"该":{"docs":{},"参":{"docs":{},"数":{"docs":{},"需":{"docs":{},"要":{"docs":{},"和":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"u":{"docs":{},"x":{"docs":{},"\"":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.008146639511201629},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{},"此":{"docs":{},"方":{"docs":{},"法":{"docs":{},"接":{"docs":{},"受":{"docs":{},"含":{"docs":{},"参":{"docs":{},"数":{"docs":{},"占":{"docs":{},"位":{"docs":{},"符":{"docs":{},"的":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"查":{"docs":{},"询":{"docs":{},"语":{"docs":{},"句":{"docs":{},"以":{"docs":{},"及":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.005431093007467753},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}},"=":{"0":{"docs":{},".":{"7":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"9":{"docs":{},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"docs":{}}},"docs":{}},")":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},":":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"/":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"x":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"，":{"docs":{},"它":{"docs":{},"要":{"docs":{},"么":{"docs":{},"返":{"docs":{},"回":{"docs":{},"结":{"docs":{},"果":{"docs":{},"或":{"docs":{},"直":{"docs":{},"接":{"docs":{},"抛":{"docs":{},"出":{"docs":{},"异":{"docs":{},"常":{"docs":{},"。":{"docs":{},"很":{"docs":{},"多":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"一":{"docs":{},"些":{"docs":{},"潜":{"docs":{},"在":{"docs":{},"的":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"操":{"docs":{},"作":{"docs":{},"可":{"docs":{},"以":{"docs":{},"快":{"docs":{},"速":{"docs":{},"返":{"docs":{},"回":{"docs":{},"（":{"docs":{},"这":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"和":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"）":{"docs":{},"，":{"docs":{},"这":{"docs":{},"就":{"docs":{},"是":{"docs":{},"我":{"docs":{},"们":{"docs":{},"为":{"docs":{},"什":{"docs":{},"么":{"docs":{},"提":{"docs":{},"供":{"docs":{},"它":{"docs":{},"。":{"docs":{},"但":{"docs":{},"是":{"docs":{},"强":{"docs":{},"烈":{"docs":{},"建":{"docs":{},"议":{"docs":{},"您":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"，":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"h":{"docs":{},"r":{"docs":{},"。":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"端":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"响":{"docs":{},"应":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"接":{"docs":{},"受":{"docs":{},"了":{"docs":{},"响":{"docs":{},"应":{"docs":{},"，":{"docs":{},"会":{"docs":{},"立":{"docs":{},"刻":{"docs":{},"再":{"docs":{},"发":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"f":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"。":{"docs":{},"它":{"docs":{},"是":{"docs":{},"一":{"docs":{},"种":{"docs":{},"可":{"docs":{},"以":{"docs":{},"再":{"docs":{},"未":{"docs":{},"授":{"docs":{},"权":{"docs":{},"的":{"docs":{},"网":{"docs":{},"站":{"docs":{},"获":{"docs":{},"取":{"docs":{},"用":{"docs":{},"户":{"docs":{},"隐":{"docs":{},"私":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"技":{"docs":{},"术":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"l":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"y":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"o":{"docs":{},"u":{"docs":{},"?":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"k":{"docs":{},"e":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"x":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"a":{"docs":{},"m":{"docs":{},"l":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.006398537477148081}},":":{"3":{"docs":{},".":{"4":{"docs":{},".":{"1":{"docs":{},"'":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"docs":{}}},"docs":{}}},"docs":{}},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"|":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.001207617278216442},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"|":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}},"—":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"—":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0015791918253599629},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.006369426751592357},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.002742230347349177},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}}}},"“":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"压":{"docs":{},"缩":{"docs":{},"级":{"docs":{},"别":{"docs":{},"”":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"映":{"docs":{},"射":{"docs":{},"”":{"docs":{},"，":{"docs":{},"名":{"docs":{},"词":{"docs":{},"为":{"docs":{},"数":{"docs":{},"据":{"docs":{},"结":{"docs":{},"构":{"docs":{},"未":{"docs":{},"翻":{"docs":{},"译":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"记":{"docs":{},"录":{"docs":{},"”":{"docs":{},"，":{"docs":{},"名":{"docs":{},"词":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"成":{"docs":{},"日":{"docs":{},"志":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"”":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}},"冷":{"docs":{},"的":{"docs":{},"”":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},")":{"docs":{},"，":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.004975124378109453},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.01592356687898089},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.008213552361396304},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}},"当":{"docs":{},"全":{"docs":{},"部":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"保":{"docs":{},"存":{"docs":{},"的":{"docs":{},"文":{"docs":{},"档":{"docs":{},"中":{"docs":{},"，":{"docs":{},"没":{"docs":{},"有":{"docs":{},"设":{"docs":{},"置":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"想":{"docs":{},"使":{"docs":{},"用":{"docs":{},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{},"类":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"自":{"docs":{},"己":{"docs":{},"设":{"docs":{},"置":{"docs":{},"这":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"但":{"docs":{},"参":{"docs":{},"数":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"类":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"实":{"docs":{},"现":{"docs":{},"接":{"docs":{},"口":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"开":{"docs":{},"发":{"docs":{},"者":{"docs":{},"想":{"docs":{},"使":{"docs":{},"用":{"docs":{},"其":{"docs":{},"他":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}},"有":{"docs":{},"关":{"docs":{},"连":{"docs":{},"接":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"格":{"docs":{},"式":{"docs":{},"的":{"docs":{},"更":{"docs":{},"多":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"驱":{"docs":{},"动":{"docs":{},"程":{"docs":{},"序":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}},"此":{"docs":{},"参":{"docs":{},"数":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"异":{"docs":{},"步":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}},"j":{"docs":{},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}},"不":{"docs":{},"建":{"docs":{},"议":{"docs":{},"在":{"docs":{},"生":{"docs":{},"产":{"docs":{},"或":{"docs":{},"测":{"docs":{},"试":{"docs":{},"环":{"docs":{},"境":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}},"不":{"docs":{},"严":{"docs":{},"格":{"docs":{},"的":{"docs":{},"轮":{"docs":{},"询":{"docs":{},"算":{"docs":{},"法":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"仅":{"docs":{},"仅":{"docs":{},"存":{"docs":{},"在":{"docs":{},"于":{"docs":{},"单":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"多":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"会":{"docs":{},"强":{"docs":{},"迫":{"docs":{},"您":{"docs":{},"用":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"创":{"docs":{},"建":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"自":{"docs":{},"动":{"docs":{},"关":{"docs":{},"闭":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"像":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{},"中":{"docs":{},"提":{"docs":{},"供":{"docs":{},"响":{"docs":{},"应":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"请":{"docs":{},"求":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"相":{"docs":{},"反":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"当":{"docs":{},"请":{"docs":{},"求":{"docs":{},"创":{"docs":{},"建":{"docs":{},"时":{"docs":{},"不":{"docs":{},"提":{"docs":{},"供":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"、":{"docs":{},"稍":{"docs":{},"后":{"docs":{},"在":{"docs":{},"请":{"docs":{},"求":{"docs":{},"对":{"docs":{},"象":{"docs":{},"中":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"允":{"docs":{},"许":{"docs":{},"请":{"docs":{},"求":{"docs":{},"或":{"docs":{},"响":{"docs":{},"应":{"docs":{},"流":{"docs":{},"执":{"docs":{},"行":{"docs":{},"清":{"docs":{},"除":{"docs":{},"重":{"docs":{},"置":{"docs":{},"，":{"docs":{},"如":{"docs":{},"当":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"上":{"docs":{},"传":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"已":{"docs":{},"经":{"docs":{},"存":{"docs":{},"在":{"docs":{},"于":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"就":{"docs":{},"需":{"docs":{},"要":{"docs":{},"接":{"docs":{},"受":{"docs":{},"整":{"docs":{},"个":{"docs":{},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"进":{"docs":{},"行":{"docs":{},"重":{"docs":{},"置":{"docs":{},"，":{"docs":{},"如":{"docs":{},"当":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"上":{"docs":{},"传":{"docs":{},"了":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"时":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"依":{"docs":{},"然":{"docs":{},"要":{"docs":{},"接":{"docs":{},"收":{"docs":{},"整":{"docs":{},"个":{"docs":{},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"模":{"docs":{},"板":{"docs":{},"中":{"docs":{},"随":{"docs":{},"意":{"docs":{},"地":{"docs":{},"调":{"docs":{},"用":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"我":{"docs":{},"们":{"docs":{},"不":{"docs":{},"能":{"docs":{},"像":{"docs":{},"对":{"docs":{},"待":{"docs":{},"其":{"docs":{},"他":{"docs":{},"模":{"docs":{},"板":{"docs":{},"引":{"docs":{},"擎":{"docs":{},"一":{"docs":{},"样":{"docs":{},"将":{"docs":{},"路":{"docs":{},"由":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"传":{"docs":{},"递":{"docs":{},"到":{"docs":{},"引":{"docs":{},"擎":{"docs":{},"里":{"docs":{},"并":{"docs":{},"让":{"docs":{},"模":{"docs":{},"板":{"docs":{},"来":{"docs":{},"识":{"docs":{},"别":{"docs":{},"它":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"兼":{"docs":{},"容":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"同":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"支":{"docs":{},"持":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"可":{"docs":{},"以":{"docs":{},"执":{"docs":{},"行":{"docs":{},"经":{"docs":{},"典":{"docs":{},"的":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"握":{"docs":{},"手":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"要":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"我":{"docs":{},"！":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"忘":{"docs":{},"记":{"docs":{},"释":{"docs":{},"放":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"！":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}},"难":{"docs":{},"看":{"docs":{},"出":{"docs":{},"，":{"docs":{},"若":{"docs":{},"写":{"docs":{},"入":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"速":{"docs":{},"度":{"docs":{},"比":{"docs":{},"实":{"docs":{},"际":{"docs":{},"写":{"docs":{},"入":{"docs":{},"底":{"docs":{},"层":{"docs":{},"数":{"docs":{},"据":{"docs":{},"资":{"docs":{},"源":{"docs":{},"速":{"docs":{},"度":{"docs":{},"快":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"写":{"docs":{},"入":{"docs":{},"队":{"docs":{},"列":{"docs":{},"就":{"docs":{},"会":{"docs":{},"无":{"docs":{},"限":{"docs":{},"增":{"docs":{},"长":{"docs":{},"，":{"docs":{},"最":{"docs":{},"终":{"docs":{},"导":{"docs":{},"致":{"docs":{},"内":{"docs":{},"存":{"docs":{},"耗":{"docs":{},"尽":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"容":{"docs":{},"器":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"只":{"docs":{},"使":{"docs":{},"用":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"部":{"docs":{},"分":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"序":{"docs":{},"的":{"docs":{},"，":{"docs":{},"但":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"默":{"docs":{},"认":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"能":{"docs":{},"够":{"docs":{},"很":{"docs":{},"容":{"docs":{},"易":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"部":{"docs":{},"署":{"docs":{},"一":{"docs":{},"个":{"docs":{},"已":{"docs":{},"经":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"将":{"docs":{},"创":{"docs":{},"建":{"docs":{},"新":{"docs":{},"的":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}},"那":{"docs":{},"首":{"docs":{},"先":{"docs":{},"将":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"特":{"docs":{},"别":{"docs":{},"的":{"docs":{},"部":{"docs":{},"署":{"docs":{},"器":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}},"正":{"docs":{},"确":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"v":{"docs":{},"p":{"docs":{},"n":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}},"接":{"docs":{},"口":{"docs":{},"将":{"docs":{},"被":{"docs":{},"选":{"docs":{},"择":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}},"推":{"docs":{},"荐":{"docs":{},"但":{"docs":{},"是":{"docs":{},"有":{"docs":{},"效":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"：":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}},"与":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588}},"发":{"docs":{},"布":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"之":{"docs":{},"处":{"docs":{},"在":{"docs":{},"于":{"docs":{},"，":{"docs":{},"发":{"docs":{},"送":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},")":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"只":{"docs":{},"会":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"在":{"docs":{},"该":{"docs":{},"地":{"docs":{},"址":{"docs":{},"注":{"docs":{},"册":{"docs":{},"的":{"docs":{},"其":{"docs":{},"中":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"这":{"docs":{},"就":{"docs":{},"是":{"docs":{},"点":{"docs":{},"对":{"docs":{},"点":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"授":{"docs":{},"权":{"docs":{},"用":{"docs":{},"户":{"docs":{},"关":{"docs":{},"联":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"名":{"docs":{},"称":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}},"各":{"docs":{},"种":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"集":{"docs":{},"群":{"docs":{},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{},"命":{"docs":{},"令":{"docs":{},"。":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"些":{"docs":{},"命":{"docs":{},"令":{"docs":{},"，":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}},"关":{"docs":{},"闭":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},"此":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"还":{"docs":{},"有":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},"两":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"过":{"docs":{},"后":{"docs":{},"，":{"docs":{},"在":{"docs":{},"流":{"docs":{},"重":{"docs":{},"置":{"docs":{},"完":{"docs":{},"成":{"docs":{},"时":{"docs":{},"您":{"docs":{},"将":{"docs":{},"会":{"docs":{},"收":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"者":{"docs":{},"都":{"docs":{},"支":{"docs":{},"持":{"docs":{},"。":{"docs":{},"若":{"docs":{},"找":{"docs":{},"到":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"所":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"算":{"docs":{},"法":{"docs":{},"之":{"docs":{},"一":{"docs":{},"自":{"docs":{},"动":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"响":{"docs":{},"应":{"docs":{},"正":{"docs":{},"文":{"docs":{},"并":{"docs":{},"发":{"docs":{},"送":{"docs":{},"回":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"临":{"docs":{},"时":{"docs":{},"响":{"docs":{},"应":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"可":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"之":{"docs":{},"前":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"执":{"docs":{},"行":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"其":{"docs":{},"指":{"docs":{},"定":{"docs":{},"为":{"docs":{},"负":{"docs":{},"值":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"为":{"docs":{},"您":{"docs":{},"的":{"docs":{},"构":{"docs":{},"建":{"docs":{},"工":{"docs":{},"具":{"docs":{},"在":{"docs":{},"描":{"docs":{},"述":{"docs":{},"文":{"docs":{},"件":{"docs":{},"中":{"docs":{},"添":{"docs":{},"加":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"项":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"可":{"docs":{},"写":{"docs":{},"成":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}},"后":{"docs":{},"，":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"另":{"docs":{},"外":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"为":{"docs":{},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"告":{"docs":{},"诉":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"监":{"docs":{},"听":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"再":{"docs":{},"调":{"docs":{},"用":{"docs":{},"此":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"只":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"但":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"是":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"。":{"docs":{},"这":{"docs":{},"时":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"但":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"是":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"。":{"docs":{},"这":{"docs":{},"时":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"间":{"docs":{},"分":{"docs":{},"享":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"那":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"您":{"docs":{},"无":{"docs":{},"需":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{},"对":{"docs":{},"话":{"docs":{},"窗":{"docs":{},"口":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"消":{"docs":{},"息":{"docs":{},"模":{"docs":{},"式":{"docs":{},"被":{"docs":{},"称":{"docs":{},"作":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"差":{"docs":{},"异":{"docs":{},"等":{"docs":{},"）":{"docs":{},"。":{"docs":{},"本":{"docs":{},"着":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"准":{"docs":{},"确":{"docs":{},"的":{"docs":{},"原":{"docs":{},"则":{"docs":{},"，":{"docs":{},"本":{"docs":{},"译":{"docs":{},"文":{"docs":{},"没":{"docs":{},"有":{"docs":{},"进":{"docs":{},"一":{"docs":{},"步":{"docs":{},"展":{"docs":{},"开":{"docs":{},"描":{"docs":{},"述":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"安":{"docs":{},"全":{"docs":{},"共":{"docs":{},"享":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"互":{"docs":{},"相":{"docs":{},"转":{"docs":{},"化":{"docs":{},"的":{"docs":{},"静":{"docs":{},"态":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}},"也":{"docs":{},"会":{"docs":{},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"可":{"docs":{},"以":{"docs":{},"与":{"docs":{},"h":{"docs":{},"a":{"docs":{},"组":{"docs":{},"合":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"每":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"组":{"docs":{},"会":{"docs":{},"解":{"docs":{},"决":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"从":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"表":{"docs":{},"单":{"docs":{},"中":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"选":{"docs":{},"项":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"在":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"重":{"docs":{},"部":{"docs":{},"署":{"docs":{},"功":{"docs":{},"能":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"失":{"docs":{},"败":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"中":{"docs":{},"转":{"docs":{},"发":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{},"转":{"docs":{},"发":{"docs":{},"的":{"docs":{},"性":{"docs":{},"质":{"docs":{},"，":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"当":{"docs":{},"前":{"docs":{},"的":{"docs":{},"状":{"docs":{},"态":{"docs":{},"码":{"docs":{},"和":{"docs":{},"失":{"docs":{},"败":{"docs":{},"原":{"docs":{},"因":{"docs":{},"也":{"docs":{},"会":{"docs":{},"被":{"docs":{},"重":{"docs":{},"置":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"转":{"docs":{},"发":{"docs":{},"后":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"应":{"docs":{},"该":{"docs":{},"根":{"docs":{},"据":{"docs":{},"需":{"docs":{},"要":{"docs":{},"生":{"docs":{},"成":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"状":{"docs":{},"态":{"docs":{},"码":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"匹":{"docs":{},"配":{"docs":{},"多":{"docs":{},"个":{"docs":{},"精":{"docs":{},"确":{"docs":{},"的":{"docs":{},"值":{"docs":{},"（":{"docs":{},"m":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"作":{"docs":{},"为":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"失":{"docs":{},"败":{"docs":{},"时":{"docs":{},"回":{"docs":{},"调":{"docs":{},"方":{"docs":{},"法":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},")":{"docs":{},"：":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}},"达":{"docs":{},"到":{"docs":{},"配":{"docs":{},"置":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}},"通":{"docs":{},"过":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"部":{"docs":{},"署":{"docs":{},"：":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"消":{"docs":{},"息":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"来":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"采":{"docs":{},"用":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"多":{"docs":{},"语":{"docs":{},"言":{"docs":{},"的":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"同":{"docs":{},"语":{"docs":{},"言":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"转":{"docs":{},"换":{"docs":{},"实":{"docs":{},"现":{"docs":{},"起":{"docs":{},"来":{"docs":{},"十":{"docs":{},"分":{"docs":{},"的":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"和":{"docs":{},"困":{"docs":{},"难":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"会":{"docs":{},"用":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"的":{"docs":{},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"即":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"需":{"docs":{},"要":{"docs":{},"加":{"docs":{},"载":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"能":{"docs":{},"被":{"docs":{},"配":{"docs":{},"置":{"docs":{},"成":{"docs":{},"使":{"docs":{},"用":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}},"以":{"docs":{},"同":{"docs":{},"步":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"获":{"docs":{},"得":{"docs":{},"一":{"docs":{},"次":{"docs":{},"性":{"docs":{},"的":{"docs":{},"事":{"docs":{},"件":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"定":{"docs":{},"时":{"docs":{},"器":{"docs":{},"的":{"docs":{},"触":{"docs":{},"发":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"额":{"docs":{},"外":{"docs":{},"的":{"docs":{},"格":{"docs":{},"式":{"docs":{},"支":{"docs":{},"持":{"docs":{},"组":{"docs":{},"件":{"docs":{},"，":{"docs":{},"并":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"你":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"支":{"docs":{},"持":{"docs":{},"，":{"docs":{},"并":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"你":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"以":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"进":{"docs":{},"行":{"docs":{},"服":{"docs":{},"务":{"docs":{},"调":{"docs":{},"用":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}},"了":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"事":{"docs":{},"件":{"docs":{},"总":{"docs":{},"线":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"(":{"1":{"0":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"docs":{}},"docs":{}},"延":{"docs":{},"时":{"docs":{},"时":{"docs":{},"间":{"docs":{},"由":{"docs":{},"这":{"docs":{},"个":{"docs":{},"配":{"docs":{},"置":{"docs":{},"决":{"docs":{},"定":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"会":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"(":{"5":{"0":{"0":{"0":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"以":{"docs":{},"下":{"docs":{},"的":{"docs":{},"某":{"docs":{},"一":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"对":{"docs":{},"象":{"docs":{},"同":{"docs":{},"时":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"流":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}},"通":{"docs":{},"知":{"docs":{},"收":{"docs":{},"集":{"docs":{},"的":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"不":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"通":{"docs":{},"知":{"docs":{},"地":{"docs":{},"址":{"docs":{},"，":{"docs":{},"则":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"时":{"docs":{},"指":{"docs":{},"定":{"docs":{},"。":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"是":{"docs":{},"，":{"docs":{},"很":{"docs":{},"多":{"docs":{},"，":{"docs":{},"也":{"docs":{},"非":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"库":{"docs":{},"，":{"docs":{},"特":{"docs":{},"别":{"docs":{},"是":{"docs":{},"在":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"生":{"docs":{},"态":{"docs":{},"系":{"docs":{},"统":{"docs":{},"中":{"docs":{},"有":{"docs":{},"很":{"docs":{},"多":{"docs":{},"同":{"docs":{},"步":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"中":{"docs":{},"许":{"docs":{},"多":{"docs":{},"方":{"docs":{},"法":{"docs":{},"都":{"docs":{},"是":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"的":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"很":{"docs":{},"好":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"就":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"物":{"docs":{},"提":{"docs":{},"交":{"docs":{},"失":{"docs":{},"败":{"docs":{},"!":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"成":{"docs":{},"功":{"docs":{},"!":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}},"先":{"docs":{},"配":{"docs":{},"置":{"docs":{},"好":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}},"仅":{"docs":{},"仅":{"docs":{},"遵":{"docs":{},"循":{"3":{"0":{"1":{"docs":{},"状":{"docs":{},"态":{"docs":{},"代":{"docs":{},"码":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"docs":{}},"docs":{}},"docs":{}}}},"限":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"语":{"docs":{},"言":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"当":{"docs":{},"用":{"docs":{},"户":{"docs":{},"已":{"docs":{},"登":{"docs":{},"录":{"docs":{},"并":{"docs":{},"且":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"权":{"docs":{},"限":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"经":{"docs":{},"登":{"docs":{},"录":{"docs":{},"并":{"docs":{},"且":{"docs":{},"包":{"docs":{},"含":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"通":{"docs":{},"过":{"docs":{},"多":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"输":{"docs":{},"出":{"docs":{},"响":{"docs":{},"应":{"docs":{},"时":{"docs":{},"才":{"docs":{},"需":{"docs":{},"要":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}}}}}}}}}}}}},"仍":{"docs":{},"然":{"docs":{},"使":{"docs":{},"用":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"，":{"docs":{},"但":{"docs":{},"始":{"docs":{},"终":{"docs":{},"使":{"docs":{},"用":{"docs":{},"原":{"docs":{},"始":{"docs":{},"源":{"docs":{},"刷":{"docs":{},"新":{"docs":{},"存":{"docs":{},"储":{"docs":{},"在":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"中":{"docs":{},"的":{"docs":{},"版":{"docs":{},"本":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"编":{"docs":{},"辑":{"docs":{},"从":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"并":{"docs":{},"刷":{"docs":{},"新":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"从":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"到":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"读":{"docs":{},"取":{"docs":{},"数":{"docs":{},"据":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"读":{"docs":{},"取":{"docs":{},"数":{"docs":{},"据":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"直":{"docs":{},"接":{"docs":{},"运":{"docs":{},"行":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}},"节":{"docs":{},"数":{"docs":{},"组":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"磁":{"docs":{},"盘":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"数":{"docs":{},"据":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"捕":{"docs":{},"捉":{"docs":{},"到":{"docs":{},"异":{"docs":{},"常":{"docs":{},"时":{"docs":{},"会":{"docs":{},"标":{"docs":{},"记":{"docs":{},"一":{"docs":{},"个":{"docs":{},"状":{"docs":{},"态":{"docs":{},"码":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"可":{"docs":{},"以":{"docs":{},"看":{"docs":{},"到":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"一":{"docs":{},"个":{"docs":{},"到":{"docs":{},"达":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"包":{"docs":{},"含":{"docs":{},"路":{"docs":{},"径":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"话":{"docs":{},"中":{"docs":{},"删":{"docs":{},"除":{"docs":{},"值":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"获":{"docs":{},"取":{"docs":{},"值":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{},"提":{"docs":{},"取":{"docs":{},"参":{"docs":{},"数":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"上":{"docs":{},"面":{"docs":{},"可":{"docs":{},"以":{"docs":{},"看":{"docs":{},"出":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"来":{"docs":{},"共":{"docs":{},"享":{"docs":{},"关":{"docs":{},"键":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"仓":{"docs":{},"库":{"docs":{},"中":{"docs":{},"中":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"(":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},")":{"docs":{},"中":{"docs":{},"获":{"docs":{},"取":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}},"克":{"docs":{},"隆":{"docs":{},"下":{"docs":{},"来":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"从":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"集":{"docs":{},"合":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}},"的":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"代":{"docs":{},"理":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"支":{"docs":{},"持":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"代":{"docs":{},"理":{"docs":{},"仅":{"docs":{},"支":{"docs":{},"持":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"创":{"docs":{},"建":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}},"访":{"docs":{},"问":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"（":{"docs":{},"如":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"）":{"docs":{},"或":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"码":{"docs":{},"块":{"docs":{},"会":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"可":{"docs":{},"以":{"docs":{},"发":{"docs":{},"送":{"docs":{},"任":{"docs":{},"何":{"docs":{},"消":{"docs":{},"息":{"docs":{},"到":{"docs":{},"任":{"docs":{},"何":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"或":{"docs":{},"其":{"docs":{},"他":{"docs":{},"所":{"docs":{},"有":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"上":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"生":{"docs":{},"成":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}},"表":{"docs":{},"的":{"docs":{},"文":{"docs":{},"档":{"docs":{},"已":{"docs":{},"经":{"docs":{},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"插":{"docs":{},"入":{"docs":{},"就":{"docs":{},"会":{"docs":{},"失":{"docs":{},"败":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}},"是":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"符":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}},"任":{"docs":{},"何":{"docs":{},"可":{"docs":{},"控":{"docs":{},"制":{"docs":{},"的":{"docs":{},"写":{"docs":{},"入":{"docs":{},"流":{"docs":{},"对":{"docs":{},"象":{"docs":{},"都":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"都":{"docs":{},"可":{"docs":{},"能":{"docs":{},"存":{"docs":{},"在":{"docs":{},"潜":{"docs":{},"在":{"docs":{},"的":{"docs":{},"漏":{"docs":{},"洞":{"docs":{},"，":{"docs":{},"无":{"docs":{},"论":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"还":{"docs":{},"是":{"docs":{},"任":{"docs":{},"何":{"docs":{},"其":{"docs":{},"他":{"docs":{},"工":{"docs":{},"具":{"docs":{},"包":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"始":{"docs":{},"终":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"安":{"docs":{},"全":{"docs":{},"最":{"docs":{},"佳":{"docs":{},"实":{"docs":{},"践":{"docs":{},"，":{"docs":{},"特":{"docs":{},"别":{"docs":{},"是":{"docs":{},"当":{"docs":{},"您":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"面":{"docs":{},"向":{"docs":{},"公":{"docs":{},"众":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"生":{"docs":{},"的":{"docs":{},"事":{"docs":{},"件":{"docs":{},"都":{"docs":{},"会":{"docs":{},"被":{"docs":{},"传":{"docs":{},"递":{"docs":{},"到":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"事":{"docs":{},"件":{"docs":{},"由":{"docs":{},"对":{"docs":{},"象":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"枚":{"docs":{},"举":{"docs":{},"类":{"docs":{},"型":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}}}},"被":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.002352941176470588}}}},"意":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}},"原":{"docs":{},"生":{"docs":{},"类":{"docs":{},"型":{"docs":{},"或":{"docs":{},"包":{"docs":{},"装":{"docs":{},"的":{"docs":{},"原":{"docs":{},"生":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}},"但":{"docs":{},"不":{"docs":{},"幸":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"包":{"docs":{},"括":{"docs":{},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"满":{"docs":{},"足":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"所":{"docs":{},"要":{"docs":{},"求":{"docs":{},"的":{"docs":{},"c":{"docs":{},"p":{"docs":{},"u":{"docs":{},"周":{"docs":{},"期":{"docs":{},"的":{"docs":{},"不":{"docs":{},"可":{"docs":{},"控":{"docs":{},"的":{"docs":{},"成":{"docs":{},"本":{"docs":{},"（":{"docs":{},"注":{"docs":{},"意":{"docs":{},"现":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{},"任":{"docs":{},"何":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"形":{"docs":{},"式":{"docs":{},"的":{"docs":{},"响":{"docs":{},"应":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"如":{"docs":{},"静":{"docs":{},"态":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"是":{"docs":{},"在":{"docs":{},"每":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"生":{"docs":{},"成":{"docs":{},"时":{"docs":{},"进":{"docs":{},"行":{"docs":{},"的":{"docs":{},"）":{"docs":{},",":{"docs":{},"它":{"docs":{},"可":{"docs":{},"生":{"docs":{},"成":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"过":{"docs":{},"的":{"docs":{},"响":{"docs":{},"应":{"docs":{},"数":{"docs":{},"据":{"docs":{},"、":{"docs":{},"并":{"docs":{},"对":{"docs":{},"接":{"docs":{},"收":{"docs":{},"的":{"docs":{},"响":{"docs":{},"应":{"docs":{},"解":{"docs":{},"码":{"docs":{},"（":{"docs":{},"膨":{"docs":{},"胀":{"docs":{},"）":{"docs":{},"—":{"docs":{},"—":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"…":{"docs":{},"…":{"docs":{},"真":{"docs":{},"实":{"docs":{},"世":{"docs":{},"界":{"docs":{},"并":{"docs":{},"非":{"docs":{},"如":{"docs":{},"此":{"docs":{},"（":{"docs":{},"您":{"docs":{},"最":{"docs":{},"近":{"docs":{},"看":{"docs":{},"新":{"docs":{},"闻":{"docs":{},"了":{"docs":{},"吧":{"docs":{},"？":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"某":{"docs":{},"些":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"能":{"docs":{},"需":{"docs":{},"要":{"docs":{},"部":{"docs":{},"署":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"它":{"docs":{},"包":{"docs":{},"含":{"docs":{},"的":{"docs":{},"类":{"docs":{},"要":{"docs":{},"与":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"中":{"docs":{},"其":{"docs":{},"他":{"docs":{},"类":{"docs":{},"隔":{"docs":{},"离":{"docs":{},"开":{"docs":{},"来":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"您":{"docs":{},"想":{"docs":{},"要":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"中":{"docs":{},"部":{"docs":{},"署":{"docs":{},"两":{"docs":{},"个":{"docs":{},"同":{"docs":{},"名":{"docs":{},"不":{"docs":{},"同":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"包":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"版":{"docs":{},"本":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"要":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"即":{"docs":{},"使":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"尺":{"docs":{},"寸":{"docs":{},"小":{"docs":{},"于":{"docs":{},"m":{"docs":{},"t":{"docs":{},"u":{"docs":{},"，":{"docs":{},"它":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"发":{"docs":{},"送":{"docs":{},"失":{"docs":{},"败":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"当":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"您":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"直":{"docs":{},"接":{"docs":{},"运":{"docs":{},"行":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"若":{"docs":{},"您":{"docs":{},"愿":{"docs":{},"意":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"上":{"docs":{},"述":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"日":{"docs":{},"志":{"docs":{},"记":{"docs":{},"录":{"docs":{},"工":{"docs":{},"具":{"docs":{},"为":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"记":{"docs":{},"录":{"docs":{},"日":{"docs":{},"志":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"命":{"docs":{},"令":{"docs":{},"执":{"docs":{},"行":{"docs":{},"是":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"的":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"结":{"docs":{},"合":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}},"如":{"docs":{},"果":{"docs":{},"存":{"docs":{},"储":{"docs":{},"过":{"docs":{},"程":{"docs":{},"有":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"样":{"docs":{},"调":{"docs":{},"用":{"docs":{},"：":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}},"当":{"docs":{},"您":{"docs":{},"使":{"docs":{},"用":{"docs":{},"存":{"docs":{},"储":{"docs":{},"过":{"docs":{},"程":{"docs":{},"时":{"docs":{},"，":{"docs":{},"还":{"docs":{},"是":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"来":{"docs":{},"返":{"docs":{},"回":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"一":{"docs":{},"个":{"docs":{},"存":{"docs":{},"储":{"docs":{},"过":{"docs":{},"程":{"docs":{},"没":{"docs":{},"有":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"样":{"docs":{},"调":{"docs":{},"用":{"docs":{},"：":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"例":{"docs":{},"外":{"docs":{},"。":{"docs":{},"任":{"docs":{},"意":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"在":{"docs":{},"部":{"docs":{},"署":{"docs":{},"时":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"配":{"docs":{},"置":{"docs":{},"都":{"docs":{},"将":{"docs":{},"覆":{"docs":{},"盖":{"docs":{},"任":{"docs":{},"何":{"docs":{},"呈":{"docs":{},"现":{"docs":{},"在":{"docs":{},"文":{"docs":{},"件":{"docs":{},"描":{"docs":{},"述":{"docs":{},"符":{"docs":{},"文":{"docs":{},"件":{"docs":{},"中":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"作":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"的":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"来":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"验":{"docs":{},"证":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"要":{"docs":{},"检":{"docs":{},"查":{"docs":{},"参":{"docs":{},"数":{"docs":{},"或":{"docs":{},"选":{"docs":{},"项":{"docs":{},"，":{"docs":{},"即":{"docs":{},"使":{"docs":{},"解":{"docs":{},"析":{"docs":{},"的":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"无":{"docs":{},"效":{"docs":{},"，":{"docs":{},"这":{"docs":{},"也":{"docs":{},"是":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"压":{"docs":{},"缩":{"docs":{},"级":{"docs":{},"别":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"该":{"docs":{},"参":{"docs":{},"数":{"docs":{},"可":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"最":{"docs":{},"多":{"6":{"docs":{},"个":{"docs":{},"）":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"结":{"docs":{},"果":{"docs":{},"归":{"docs":{},"并":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"，":{"docs":{},"或":{"docs":{},"传":{"docs":{},"入":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"docs":{}}}},"，":{"docs":{},"以":{"docs":{},"表":{"docs":{},"示":{"docs":{},"操":{"docs":{},"作":{"docs":{},"和":{"docs":{},"结":{"docs":{},"果":{"docs":{},"的":{"docs":{},"成":{"docs":{},"功":{"docs":{},"或":{"docs":{},"失":{"docs":{},"败":{"docs":{},"。":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"写":{"docs":{},"流":{"docs":{},"或":{"docs":{},"可":{"docs":{},"读":{"docs":{},"流":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"只":{"docs":{},"能":{"docs":{},"用":{"docs":{},"于":{"docs":{},"不":{"docs":{},"分":{"docs":{},"割":{"docs":{},"多":{"docs":{},"个":{"docs":{},"帧":{"docs":{},"的":{"docs":{},"二":{"docs":{},"进":{"docs":{},"制":{"docs":{},"帧":{"docs":{},"一":{"docs":{},"起":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"发":{"docs":{},"送":{"docs":{},"。":{"docs":{},"不":{"docs":{},"过":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"缓":{"docs":{},"存":{"docs":{},"目":{"docs":{},"录":{"docs":{},"，":{"docs":{},"它":{"docs":{},"在":{"docs":{},"此":{"docs":{},"之":{"docs":{},"间":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"的":{"docs":{},"目":{"docs":{},"录":{"docs":{},"，":{"docs":{},"以":{"docs":{},"避":{"docs":{},"免":{"docs":{},"冲":{"docs":{},"突":{"docs":{},"。":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"前":{"docs":{},"缀":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"我":{"docs":{},"们":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"根":{"docs":{},"目":{"docs":{},"录":{"docs":{},"。":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"结":{"docs":{},"尾":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"标":{"docs":{},"准":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"格":{"docs":{},"式":{"docs":{},"，":{"docs":{},"这":{"docs":{},"使":{"docs":{},"得":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"在":{"docs":{},"接":{"docs":{},"受":{"docs":{},"数":{"docs":{},"据":{"docs":{},"类":{"docs":{},"型":{"docs":{},"时":{"docs":{},"受":{"docs":{},"到":{"docs":{},"很":{"docs":{},"多":{"docs":{},"限":{"docs":{},"制":{"docs":{},"。":{"docs":{},"我":{"docs":{},"们":{"docs":{},"只":{"docs":{},"能":{"docs":{},"从":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"最":{"docs":{},"后":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"用":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}},"访":{"docs":{},"问":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"获":{"docs":{},"取":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"方":{"docs":{},"法":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"时":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"下":{"docs":{},"列":{"docs":{},"示":{"docs":{},"例":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}},"以":{"docs":{},"下":{"docs":{},"s":{"docs":{},"p":{"docs":{},"i":{"docs":{},"对":{"docs":{},"其":{"docs":{},"进":{"docs":{},"行":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"殊":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"并":{"docs":{},"给":{"docs":{},"其":{"docs":{},"加":{"docs":{},"上":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}},"利":{"docs":{},"用":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"w":{"docs":{},"t":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"并":{"docs":{},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"w":{"docs":{},"t":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"把":{"docs":{},"这":{"docs":{},"个":{"docs":{},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"任":{"docs":{},"意":{"docs":{},"的":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}},"它":{"docs":{},"当":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"普":{"docs":{},"通":{"docs":{},"的":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}},"做":{"docs":{},"一":{"docs":{},"些":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"获":{"docs":{},"取":{"docs":{},"一":{"docs":{},"条":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"，":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"名":{"docs":{},"是":{"docs":{},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"类":{"docs":{},"名":{"docs":{},"加":{"docs":{},"上":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}},"利":{"docs":{},"用":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}},"直":{"docs":{},"接":{"docs":{},"传":{"docs":{},"递":{"docs":{},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"类":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"将":{"docs":{},"事":{"docs":{},"件":{"docs":{},"发":{"docs":{},"送":{"docs":{},"地":{"docs":{},"址":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"服":{"docs":{},"务":{"docs":{},"使":{"docs":{},"用":{"docs":{},"情":{"docs":{},"况":{"docs":{},"的":{"docs":{},"监":{"docs":{},"听":{"docs":{},"功":{"docs":{},"能":{"docs":{},"了":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"编":{"docs":{},"程":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"用":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"方":{"docs":{},"法":{"docs":{},"注":{"docs":{},"册":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"实":{"docs":{},"例":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"将":{"docs":{},"多":{"docs":{},"语":{"docs":{},"言":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"生":{"docs":{},"成":{"docs":{},"功":{"docs":{},"能":{"docs":{},"（":{"docs":{},"@":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"注":{"docs":{},"解":{"docs":{},"）":{"docs":{},"与":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"个":{"docs":{},"同":{"docs":{},"时":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}},"对":{"docs":{},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"进":{"docs":{},"行":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"来":{"docs":{},"找":{"docs":{},"到":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}},"将":{"docs":{},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"加":{"docs":{},"上":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}},"能":{"docs":{},"够":{"docs":{},"配":{"docs":{},"置":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"生":{"docs":{},"效":{"docs":{},"/":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"时":{"docs":{},"回":{"docs":{},"调":{"docs":{},"。":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}},"仅":{"docs":{},"仅":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}}}},"例":{"docs":{},"如":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"磁":{"docs":{},"盘":{"docs":{},"上":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"直":{"docs":{},"接":{"docs":{},"泵":{"docs":{},"送":{"docs":{},"到":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"能":{"docs":{},"在":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"应":{"docs":{},"该":{"docs":{},"始":{"docs":{},"终":{"docs":{},"在":{"docs":{},"d":{"docs":{},"m":{"docs":{},"z":{"docs":{},"中":{"docs":{},"运":{"docs":{},"行":{"docs":{},"它":{"docs":{},"们":{"docs":{},"，":{"docs":{},"并":{"docs":{},"使":{"docs":{},"用":{"docs":{},"具":{"docs":{},"有":{"docs":{},"受":{"docs":{},"限":{"docs":{},"权":{"docs":{},"限":{"docs":{},"的":{"docs":{},"用":{"docs":{},"户":{"docs":{},"账":{"docs":{},"户":{"docs":{},"，":{"docs":{},"以":{"docs":{},"限":{"docs":{},"制":{"docs":{},"服":{"docs":{},"务":{"docs":{},"受":{"docs":{},"到":{"docs":{},"损":{"docs":{},"害":{"docs":{},"的":{"docs":{},"程":{"docs":{},"度":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"若":{"docs":{},"您":{"docs":{},"使":{"docs":{},"用":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"分":{"docs":{},"割":{"docs":{},"的":{"docs":{},"简":{"docs":{},"单":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{},"文":{"docs":{},"本":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"并":{"docs":{},"输":{"docs":{},"入":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"部":{"docs":{},"署":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"创":{"docs":{},"建":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"该":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"在":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"中":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"为":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"对":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"路":{"docs":{},"径":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"对":{"docs":{},"于":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"失":{"docs":{},"败":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"只":{"docs":{},"处":{"docs":{},"理":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{},"路":{"docs":{},"径":{"docs":{},"上":{"docs":{},"发":{"docs":{},"生":{"docs":{},"的":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"或":{"docs":{},"某":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}},"保":{"docs":{},"存":{"docs":{},"一":{"docs":{},"个":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"删":{"docs":{},"除":{"docs":{},"作":{"docs":{},"者":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"匹":{"docs":{},"配":{"docs":{},"所":{"docs":{},"有":{"docs":{},"文":{"docs":{},"档":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"执":{"docs":{},"行":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"插":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"含":{"docs":{},"有":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}},"更":{"docs":{},"新":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"替":{"docs":{},"换":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"获":{"docs":{},"取":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"批":{"docs":{},"量":{"docs":{},"模":{"docs":{},"式":{"docs":{},"下":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"计":{"docs":{},"算":{"docs":{},"作":{"docs":{},"者":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"我":{"docs":{},"们":{"docs":{},"在":{"docs":{},"部":{"docs":{},"署":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"j":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"=":{"1":{"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"1":{"docs":{},".":{"5":{"docs":{},"。":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"名":{"docs":{},"：":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"就":{"docs":{},"是":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"调":{"docs":{},"用":{"docs":{},"的":{"docs":{},"输":{"docs":{},"出":{"docs":{},"：":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}},"子":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"忽":{"docs":{},"略":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"依":{"docs":{},"照":{"docs":{},"u":{"docs":{},"d":{"docs":{},"p":{"docs":{},"的":{"docs":{},"本":{"docs":{},"质":{"docs":{},"，":{"docs":{},"它":{"docs":{},"最":{"docs":{},"适":{"docs":{},"合":{"docs":{},"一":{"docs":{},"些":{"docs":{},"允":{"docs":{},"许":{"docs":{},"丢":{"docs":{},"弃":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"（":{"docs":{},"如":{"docs":{},"监":{"docs":{},"视":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"赖":{"docs":{},"添":{"docs":{},"加":{"docs":{},"至":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},",":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}},"与":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}},"信":{"docs":{},"息":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"，":{"docs":{},"请":{"docs":{},"查":{"docs":{},"阅":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}},"。":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.009852216748768473}}}}},"做":{"docs":{},"一":{"docs":{},"些":{"docs":{},"事":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"情":{"docs":{},"。":{"docs":{},"。":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{},"事":{"docs":{},"情":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"工":{"docs":{},"作":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"初":{"docs":{},"创":{"docs":{},"性":{"docs":{},"的":{"docs":{},"工":{"docs":{},"作":{"docs":{},"来":{"docs":{},"提":{"docs":{},"供":{"docs":{},"这":{"docs":{},"样":{"docs":{},"一":{"docs":{},"份":{"docs":{},"标":{"docs":{},"准":{"docs":{},"。":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}}}},"允":{"docs":{},"许":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"单":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"您":{"docs":{},"传":{"docs":{},"递":{"docs":{},"一":{"docs":{},"个":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"查":{"docs":{},"询":{"docs":{},"完":{"docs":{},"成":{"docs":{},"将":{"docs":{},"会":{"docs":{},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"给":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"并":{"docs":{},"通":{"docs":{},"知":{"docs":{},"它":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"请":{"docs":{},"求":{"docs":{},"对":{"docs":{},"象":{"docs":{},"中":{"docs":{},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"轻":{"docs":{},"松":{"docs":{},"编":{"docs":{},"写":{"docs":{},"非":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"向":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"中":{"docs":{},"添":{"docs":{},"加":{"docs":{},"任":{"docs":{},"何":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"时":{"docs":{},"向":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"向":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"发":{"docs":{},"送":{"docs":{},"地":{"docs":{},"址":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"以":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"向":{"docs":{},"地":{"docs":{},"址":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603}}}}}}}},"该":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"为":{"docs":{},"您":{"docs":{},"处":{"docs":{},"理":{"docs":{},"回":{"docs":{},"调":{"docs":{},"地":{"docs":{},"址":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"全":{"docs":{},"限":{"docs":{},"定":{"docs":{},"类":{"docs":{},"名":{"docs":{},"（":{"docs":{},"f":{"docs":{},"q":{"docs":{},"c":{"docs":{},"n":{"docs":{},"）":{"docs":{},"然":{"docs":{},"后":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"它":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"共":{"docs":{},"享":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"数":{"docs":{},"据":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"包":{"docs":{},"括":{"docs":{},"本":{"docs":{},"地":{"docs":{},"共":{"docs":{},"享":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"、":{"docs":{},"分":{"docs":{},"布":{"docs":{},"式":{"docs":{},"、":{"docs":{},"集":{"docs":{},"群":{"docs":{},"范":{"docs":{},"围":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"、":{"docs":{},"异":{"docs":{},"步":{"docs":{},"集":{"docs":{},"群":{"docs":{},"范":{"docs":{},"围":{"docs":{},"锁":{"docs":{},"和":{"docs":{},"异":{"docs":{},"步":{"docs":{},"集":{"docs":{},"群":{"docs":{},"范":{"docs":{},"围":{"docs":{},"计":{"docs":{},"数":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"关":{"docs":{},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"高":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"和":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"更":{"docs":{},"多":{"docs":{},"细":{"docs":{},"节":{"docs":{},"可":{"docs":{},"参":{"docs":{},"考":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"何":{"docs":{},"编":{"docs":{},"写":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922}}}}}},"服":{"docs":{},"务":{"docs":{},"事":{"docs":{},"件":{"docs":{},"的":{"docs":{},"更":{"docs":{},"详":{"docs":{},"细":{"docs":{},"内":{"docs":{},"容":{"docs":{},"参":{"docs":{},"考":{"docs":{},"后":{"docs":{},"续":{"docs":{},"章":{"docs":{},"节":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}},"闭":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0026507620941020544}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"底":{"docs":{},"层":{"docs":{},"连":{"docs":{},"接":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"操":{"docs":{},"作":{"docs":{},"也":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"直":{"docs":{},"到":{"docs":{},"方":{"docs":{},"法":{"docs":{},"调":{"docs":{},"用":{"docs":{},"返":{"docs":{},"回":{"docs":{},"过":{"docs":{},"后":{"docs":{},"一":{"docs":{},"段":{"docs":{},"时":{"docs":{},"间":{"docs":{},"才":{"docs":{},"会":{"docs":{},"实":{"docs":{},"际":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"。":{"docs":{},"若":{"docs":{},"您":{"docs":{},"想":{"docs":{},"在":{"docs":{},"实":{"docs":{},"际":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"完":{"docs":{},"成":{"docs":{},"时":{"docs":{},"收":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"传":{"docs":{},"递":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"收":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"（":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},"连":{"docs":{},"接":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"键":{"docs":{},"字":{"docs":{},"返":{"docs":{},"回":{"docs":{},"输":{"docs":{},"出":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"，":{"docs":{},"这":{"docs":{},"时":{"docs":{},"可":{"docs":{},"以":{"docs":{},"这":{"docs":{},"样":{"docs":{},"调":{"docs":{},"用":{"docs":{},"：":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}},"其":{"docs":{},"中":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"m":{"docs":{},"y":{"docs":{},"_":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"也":{"docs":{},"许":{"docs":{},"会":{"docs":{},"包":{"docs":{},"含":{"docs":{},"以":{"docs":{},"下":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"访":{"docs":{},"问":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"、":{"docs":{},"端":{"docs":{},"口":{"docs":{},"等":{"docs":{},"）":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"会":{"docs":{},"接":{"docs":{},"受":{"docs":{},"一":{"docs":{},"个":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}},"他":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"操":{"docs":{},"作":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"命":{"docs":{},"令":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"很":{"docs":{},"多":{"docs":{},"情":{"docs":{},"况":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"通":{"docs":{},"用":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{},"的":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"配":{"docs":{},"置":{"docs":{},"示":{"docs":{},"例":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}},"docs":{}}}}}}}},"存":{"docs":{},"储":{"docs":{},"后":{"docs":{},"端":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"优":{"docs":{},"点":{"docs":{},"是":{"docs":{},"与":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{},"相":{"docs":{},"比":{"docs":{},"具":{"docs":{},"有":{"docs":{},"更":{"docs":{},"少":{"docs":{},"的":{"docs":{},"开":{"docs":{},"销":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"可":{"docs":{},"以":{"docs":{},"由":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"和":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"处":{"docs":{},"理":{"docs":{},"（":{"docs":{},"参":{"docs":{},"考":{"docs":{},"前":{"docs":{},"文":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"它":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"实":{"docs":{},"现":{"docs":{},"：":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}},"内":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"联":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"代":{"docs":{},"码":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"设":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"部":{"docs":{},"创":{"docs":{},"建":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"，":{"docs":{},"大":{"docs":{},"部":{"docs":{},"分":{"docs":{},"数":{"docs":{},"据":{"docs":{},"被":{"docs":{},"重":{"docs":{},"新":{"docs":{},"组":{"docs":{},"织":{"docs":{},"（":{"docs":{},"s":{"docs":{},"h":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"表":{"docs":{},"意":{"docs":{},"为":{"docs":{},"洗":{"docs":{},"牌":{"docs":{},"）":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"进":{"docs":{},"行":{"docs":{},"偏":{"docs":{},"移":{"docs":{},"量":{"docs":{},"定":{"docs":{},"位":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"e":{"docs":{},"k":{"docs":{},")":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"并":{"docs":{},"从":{"docs":{},"任":{"docs":{},"意":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}},"容":{"docs":{},"协":{"docs":{},"商":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"(":{"2":{"docs":{},")":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"docs":{}}}}},"置":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"同":{"docs":{},"一":{"docs":{},"种":{"docs":{},"格":{"docs":{},"式":{"docs":{},"）":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}},"嵌":{"docs":{},"在":{"docs":{},"对":{"docs":{},"应":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"包":{"docs":{},"中":{"docs":{},"。":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}},"写":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"文":{"docs":{},"本":{"docs":{},"消":{"docs":{},"息":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"些":{"docs":{},"块":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"入":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"到":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"，":{"docs":{},"这":{"docs":{},"种":{"docs":{},"请":{"docs":{},"求":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"带":{"docs":{},"编":{"docs":{},"码":{"docs":{},"方":{"docs":{},"式":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"，":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"编":{"docs":{},"码":{"docs":{},"方":{"docs":{},"式":{"docs":{},"编":{"docs":{},"码":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"结":{"docs":{},"果":{"docs":{},"写":{"docs":{},"入":{"docs":{},"到":{"docs":{},"报":{"docs":{},"文":{"docs":{},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"帧":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"操":{"docs":{},"作":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"有":{"docs":{},"两":{"docs":{},"种":{"docs":{},"：":{"docs":{},"追":{"docs":{},"加":{"docs":{},"和":{"docs":{},"随":{"docs":{},"机":{"docs":{},"写":{"docs":{},"入":{"docs":{},"。":{"docs":{},"任":{"docs":{},"何":{"docs":{},"一":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"响":{"docs":{},"应":{"docs":{},"并":{"docs":{},"结":{"docs":{},"束":{"docs":{},"处":{"docs":{},"理":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"指":{"docs":{},"定":{"docs":{},"编":{"docs":{},"码":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"数":{"docs":{},"据":{"docs":{},"到":{"docs":{},"磁":{"docs":{},"盘":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"文":{"docs":{},"件":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"最":{"docs":{},"终":{"docs":{},"帧":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"头":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"操":{"docs":{},"作":{"docs":{},"的":{"docs":{},"可":{"docs":{},"靠":{"docs":{},"性":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"源":{"docs":{},"码":{"docs":{},"中":{"docs":{},"是":{"docs":{},"用":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}},"的":{"docs":{},"异":{"docs":{},"步":{"docs":{},"驱":{"docs":{},"动":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}},"好":{"docs":{},"的":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}},"出":{"docs":{},"了":{"docs":{},"些":{"docs":{},"问":{"docs":{},"题":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}}}}}},"现":{"docs":{},"一":{"docs":{},"些":{"docs":{},"错":{"docs":{},"误":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"来":{"docs":{},"继":{"docs":{},"续":{"docs":{},"等":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"超":{"docs":{},"过":{"docs":{},"了":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"错":{"docs":{},"了":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"函":{"docs":{},"数":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"完":{"docs":{},"成":{"docs":{},"写":{"docs":{},"入":{"docs":{},"和":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"发":{"docs":{},"送":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"只":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"或":{"docs":{},"者":{"docs":{},"存":{"docs":{},"储":{"docs":{},"过":{"docs":{},"程":{"docs":{},"。":{"docs":{},"此":{"docs":{},"方":{"docs":{},"法":{"docs":{},"接":{"docs":{},"受":{"docs":{},"以":{"docs":{},"下":{"docs":{},"参":{"docs":{},"数":{"docs":{},"：":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"当":{"docs":{},"前":{"docs":{},"线":{"docs":{},"程":{"docs":{},"切":{"docs":{},"换":{"docs":{},"回":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"用":{"docs":{},"于":{"docs":{},"将":{"docs":{},"数":{"docs":{},"据":{"docs":{},"实":{"docs":{},"体":{"docs":{},"类":{"docs":{},"转":{"docs":{},"换":{"docs":{},"为":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}},"列":{"docs":{},"表":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"或":{"docs":{},"者":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"响":{"docs":{},"应":{"docs":{},"中":{"docs":{},"自":{"docs":{},"己":{"docs":{},"解":{"docs":{},"析":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"传":{"docs":{},"参":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"（":{"docs":{},"可":{"docs":{},"能":{"docs":{},"为":{"docs":{},"空":{"docs":{},"）":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"的":{"docs":{},"每":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"代":{"docs":{},"表":{"docs":{},"一":{"docs":{},"行":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}},"举":{"docs":{},"目":{"docs":{},"录":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"创":{"docs":{},"建":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0010218300046446818},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},"一":{"docs":{},"个":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},"指":{"docs":{},"定":{"docs":{},"初":{"docs":{},"始":{"docs":{},"大":{"docs":{},"小":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"空":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"k":{"docs":{},"a":{"docs":{},"f":{"docs":{},"k":{"docs":{},"a":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}},"可":{"docs":{},"以":{"docs":{},"反":{"docs":{},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"成":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"成":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"的":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"的":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"继":{"docs":{},"承":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"的":{"docs":{},"类":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"对":{"docs":{},"类":{"docs":{},"进":{"docs":{},"行":{"docs":{},"参":{"docs":{},"数":{"docs":{},"化":{"docs":{},"，":{"docs":{},"添":{"docs":{},"加":{"docs":{},"上":{"docs":{},"你":{"docs":{},"要":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"你":{"docs":{},"必":{"docs":{},"须":{"docs":{},"实":{"docs":{},"现":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"#":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"创":{"docs":{},"建":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"只":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"一":{"docs":{},"次":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"需":{"docs":{},"要":{"docs":{},"释":{"docs":{},"放":{"docs":{},"资":{"docs":{},"源":{"docs":{},"，":{"docs":{},"那":{"docs":{},"另":{"docs":{},"外":{"docs":{},"还":{"docs":{},"需":{"docs":{},"要":{"docs":{},"覆":{"docs":{},"写":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"，":{"docs":{},"并":{"docs":{},"配":{"docs":{},"置":{"docs":{},"成":{"docs":{},"你":{"docs":{},"所":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"(":{"docs":{},"超":{"docs":{},"时":{"docs":{},"，":{"docs":{},"最":{"docs":{},"大":{"docs":{},"故":{"docs":{},"障":{"docs":{},"次":{"docs":{},"数":{"docs":{},")":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"新":{"docs":{},"的":{"docs":{},"可":{"docs":{},"用":{"docs":{},"请":{"docs":{},"求":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"时":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"对":{"docs":{},"象":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}},"的":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635}},"时":{"docs":{},"候":{"docs":{},"设":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"虚":{"docs":{},"拟":{"docs":{},"网":{"docs":{},"络":{"docs":{},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}},"空":{"docs":{},"的":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"区":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"连":{"docs":{},"接":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.0035294117647058825}}}},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"完":{"docs":{},"整":{"docs":{},"的":{"docs":{},"控":{"docs":{},"制":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"您":{"docs":{},"期":{"docs":{},"望":{"docs":{},"它":{"docs":{},"在":{"docs":{},"处":{"docs":{},"理":{"docs":{},"链":{"docs":{},"中":{"docs":{},"首":{"docs":{},"先":{"docs":{},"被":{"docs":{},"执":{"docs":{},"行":{"docs":{},"）":{"docs":{},"，":{"docs":{},"您":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"先":{"docs":{},"创":{"docs":{},"建":{"docs":{},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"集":{"docs":{},"群":{"docs":{},"会":{"docs":{},"话":{"docs":{},"存":{"docs":{},"储":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"会":{"docs":{},"话":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"认":{"docs":{},"证":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"不":{"docs":{},"共":{"docs":{},"享":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"的":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"对":{"docs":{},"象":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}},"或":{"docs":{},"者":{"docs":{},"部":{"docs":{},"署":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"应":{"docs":{},"该":{"docs":{},"把":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"参":{"docs":{},"数":{"docs":{},"传":{"docs":{},"给":{"docs":{},"它":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}}}}}}},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"认":{"docs":{},"证":{"docs":{},"实":{"docs":{},"现":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}},"好":{"docs":{},"上":{"docs":{},"边":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"过":{"docs":{},"后":{"docs":{},"你":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"如":{"docs":{},"使":{"docs":{},"用":{"docs":{},"任":{"docs":{},"何":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"执":{"docs":{},"行":{"docs":{},"认":{"docs":{},"证":{"docs":{},"和":{"docs":{},"授":{"docs":{},"权":{"docs":{},"功":{"docs":{},"能":{"docs":{},"了":{"docs":{},"。":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"你":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"任":{"docs":{},"何":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"针":{"docs":{},"对":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"执":{"docs":{},"行":{"docs":{},"认":{"docs":{},"证":{"docs":{},"和":{"docs":{},"授":{"docs":{},"权":{"docs":{},"功":{"docs":{},"能":{"docs":{},"了":{"docs":{},"。":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"时":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"同":{"docs":{},"时":{"docs":{},"指":{"docs":{},"明":{"docs":{},"了":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"（":{"docs":{},"p":{"docs":{},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"）":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"这":{"docs":{},"不":{"docs":{},"是":{"docs":{},"必":{"docs":{},"须":{"docs":{},"的":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"，":{"docs":{},"并":{"docs":{},"分":{"docs":{},"配":{"docs":{},"路":{"docs":{},"由":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"时":{"docs":{},"分":{"docs":{},"配":{"docs":{},"了":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"内":{"docs":{},"存":{"docs":{},"，":{"docs":{},"比":{"docs":{},"数":{"docs":{},"据":{"docs":{},"写":{"docs":{},"入":{"docs":{},"时":{"docs":{},"重":{"docs":{},"新":{"docs":{},"调":{"docs":{},"整":{"docs":{},"大":{"docs":{},"小":{"docs":{},"的":{"docs":{},"效":{"docs":{},"率":{"docs":{},"更":{"docs":{},"高":{"docs":{},"。":{"docs":{},"注":{"docs":{},"意":{"docs":{},"以":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"创":{"docs":{},"建":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"探":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}},"前":{"docs":{},"缀":{"docs":{},"，":{"docs":{},"而":{"docs":{},"短":{"docs":{},"名":{"docs":{},"称":{"docs":{},"与":{"docs":{},"单":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"环":{"docs":{},"境":{"docs":{},"变":{"docs":{},"量":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}},"面":{"docs":{},"提":{"docs":{},"到":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"概":{"docs":{},"念":{"docs":{},"，":{"docs":{},"来":{"docs":{},"封":{"docs":{},"装":{"docs":{},"各":{"docs":{},"种":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"差":{"docs":{},"异":{"docs":{},"性":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"功":{"docs":{},"能":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"加":{"docs":{},"入":{"docs":{},"多":{"docs":{},"播":{"docs":{},"组":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"某":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"载":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}},"包":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},"或":{"docs":{},"任":{"docs":{},"意":{"docs":{},"子":{"docs":{},"包":{"docs":{},"中":{"docs":{},"的":{"docs":{},"任":{"docs":{},"意":{"docs":{},"类":{"docs":{},"名":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"里":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"含":{"docs":{},"输":{"docs":{},"出":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"输":{"docs":{},"出":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"（":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"）":{"docs":{},"，":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"形":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"的":{"docs":{},"错":{"docs":{},"误":{"docs":{},"状":{"docs":{},"态":{"docs":{},"码":{"docs":{},"、":{"docs":{},"一":{"docs":{},"条":{"docs":{},"消":{"docs":{},"息":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"加":{"docs":{},"入":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},"到":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},"：":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}},"(":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"设":{"docs":{},"置":{"docs":{},"启":{"docs":{},"动":{"docs":{},"参":{"docs":{},"数":{"docs":{},":":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}},"中":{"docs":{},"内":{"docs":{},"嵌":{"docs":{},"的":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"两":{"docs":{},"个":{"docs":{},"文":{"docs":{},"件":{"docs":{},"来":{"docs":{},"配":{"docs":{},"置":{"docs":{},"自":{"docs":{},"身":{"docs":{},"属":{"docs":{},"性":{"docs":{},"：":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}},"区":{"docs":{},"域":{"docs":{},"（":{"docs":{},"参":{"docs":{},"数":{"docs":{},"选":{"docs":{},"项":{"docs":{},"卡":{"docs":{},"中":{"docs":{},"）":{"docs":{},"，":{"docs":{},"写":{"docs":{},"入":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"升":{"docs":{},"级":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"单":{"docs":{},"一":{"docs":{},"线":{"docs":{},"程":{"docs":{},"的":{"docs":{},"问":{"docs":{},"题":{"docs":{},"在":{"docs":{},"于":{"docs":{},"它":{"docs":{},"在":{"docs":{},"任":{"docs":{},"意":{"docs":{},"时":{"docs":{},"刻":{"docs":{},"只":{"docs":{},"能":{"docs":{},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"核":{"docs":{},"上":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"希":{"docs":{},"望":{"docs":{},"单":{"docs":{},"线":{"docs":{},"程":{"docs":{},"反":{"docs":{},"应":{"docs":{},"器":{"docs":{},"应":{"docs":{},"用":{"docs":{},"（":{"docs":{},"如":{"docs":{},"您":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"个":{"docs":{},"连":{"docs":{},"字":{"docs":{},"符":{"docs":{},"的":{"docs":{},"长":{"docs":{},"选":{"docs":{},"项":{"docs":{},"（":{"docs":{},"即":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"接":{"docs":{},"的":{"docs":{},"管":{"docs":{},"道":{"docs":{},"请":{"docs":{},"求":{"docs":{},"限":{"docs":{},"制":{"docs":{},"数":{"docs":{},"由":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"即":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"使":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"配":{"docs":{},"置":{"docs":{},"成":{"docs":{},"不":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"异":{"docs":{},"步":{"docs":{},"开":{"docs":{},"发":{"docs":{},"模":{"docs":{},"式":{"docs":{},"中":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"最":{"docs":{},"初":{"docs":{},"不":{"docs":{},"运":{"docs":{},"行":{"docs":{},"任":{"docs":{},"何":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"也":{"docs":{},"将":{"docs":{},"为":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"的":{"docs":{},"节":{"docs":{},"点":{"docs":{},"进":{"docs":{},"行":{"docs":{},"故":{"docs":{},"障":{"docs":{},"转":{"docs":{},"移":{"docs":{},"。":{"docs":{},"要":{"docs":{},"启":{"docs":{},"动":{"docs":{},"一":{"docs":{},"个":{"docs":{},"裸":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"您":{"docs":{},"只":{"docs":{},"需":{"docs":{},"做":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"达":{"docs":{},"到":{"docs":{},"目":{"docs":{},"的":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}},"压":{"docs":{},"缩":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"功":{"docs":{},"能":{"docs":{},"。":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"可":{"docs":{},"以":{"docs":{},"让":{"docs":{},"远":{"docs":{},"程":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"知":{"docs":{},"道":{"docs":{},"它":{"docs":{},"支":{"docs":{},"持":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"能":{"docs":{},"处":{"docs":{},"理":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"过":{"docs":{},"的":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"（":{"docs":{},"数":{"docs":{},"据":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"将":{"docs":{},"检":{"docs":{},"查":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"中":{"docs":{},"是":{"docs":{},"否":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"和":{"docs":{},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"算":{"docs":{},"法":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"级":{"docs":{},"别":{"docs":{},"允":{"docs":{},"许":{"docs":{},"根":{"docs":{},"据":{"docs":{},"所":{"docs":{},"得":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"比":{"docs":{},"和":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"/":{"docs":{},"解":{"docs":{},"压":{"docs":{},"的":{"docs":{},"计":{"docs":{},"算":{"docs":{},"成":{"docs":{},"本":{"docs":{},"来":{"docs":{},"配":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"从":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"，":{"docs":{},"则":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"发":{"docs":{},"回":{"docs":{},"没":{"docs":{},"有":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"过":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"它":{"docs":{},"将":{"docs":{},"包":{"docs":{},"含":{"docs":{},"例":{"docs":{},"如":{"docs":{},"下":{"docs":{},"边":{"docs":{},"的":{"docs":{},"头":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"原":{"docs":{},"文":{"docs":{},"档":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"更":{"docs":{},"新":{"docs":{},"于":{"2":{"0":{"1":{"7":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"：":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}},"最":{"docs":{},"后":{"docs":{},"更":{"docs":{},"新":{"docs":{},"于":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}},"上":{"docs":{},"次":{"docs":{},"编":{"docs":{},"辑":{"docs":{},"于":{"2":{"0":{"1":{"7":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}},"生":{"docs":{},"对":{"docs":{},"象":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"去":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"线":{"docs":{},"程":{"docs":{},"和":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"问":{"docs":{},"题":{"docs":{},"。":{"docs":{},"您":{"docs":{},"不":{"docs":{},"用":{"docs":{},"再":{"docs":{},"考":{"docs":{},"虑":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"掉":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}},"参":{"docs":{},"数":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.002036659877800407}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"因":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"表":{"docs":{},"单":{"docs":{},"中":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"就":{"docs":{},"不":{"docs":{},"再":{"docs":{},"有":{"docs":{},"作":{"docs":{},"用":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.004975124378109453}}}}}}}}}},"没":{"docs":{},"有":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"基":{"docs":{},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"值":{"docs":{},"设":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"以":{"docs":{},"指":{"docs":{},"定":{"docs":{},"多":{"docs":{},"个":{"docs":{},"的":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"来":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"查":{"docs":{},"询":{"docs":{},"解":{"docs":{},"析":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"。":{"docs":{},"它":{"docs":{},"将":{"docs":{},"按":{"docs":{},"照":{"docs":{},"此":{"docs":{},"处":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"相":{"docs":{},"同":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"查":{"docs":{},"询":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"，":{"docs":{},"若":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"docs":{},"上":{"docs":{},"一":{"docs":{},"个":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"解":{"docs":{},"析":{"docs":{},"时":{"docs":{},"出":{"docs":{},"现":{"docs":{},"了":{"docs":{},"错":{"docs":{},"误":{"docs":{},"，":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"继":{"docs":{},"续":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"是":{"docs":{},"命":{"docs":{},"令":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"，":{"docs":{},"为":{"docs":{},"了":{"docs":{},"明":{"docs":{},"确":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}},"元":{"docs":{},"素":{"docs":{},"值":{"docs":{},"不":{"docs":{},"是":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"也":{"docs":{},"是":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"将":{"docs":{},"被":{"docs":{},"注":{"docs":{},"册":{"docs":{},"为":{"docs":{},"输":{"docs":{},"出":{"docs":{},"参":{"docs":{},"数":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}},"，":{"docs":{},"再":{"docs":{},"做":{"docs":{},"判":{"docs":{},"断":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}},"将":{"docs":{},"被":{"docs":{},"当":{"docs":{},"作":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}},"是":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.005471956224350205}}}}},"重":{"docs":{},"载":{"docs":{},"方":{"docs":{},"法":{"docs":{},"用":{"docs":{},"于":{"docs":{},"设":{"docs":{},"定":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}},"中":{"docs":{},"添":{"docs":{},"加":{"docs":{},"数":{"docs":{},"据":{"docs":{},"即":{"docs":{},"可":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"任":{"docs":{},"何":{"docs":{},"的":{"docs":{},"会":{"docs":{},"话":{"docs":{},"状":{"docs":{},"态":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"不":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"集":{"docs":{},"群":{"docs":{},"会":{"docs":{},"话":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"对":{"docs":{},"应":{"docs":{},"用":{"docs":{},"进":{"docs":{},"行":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"这":{"docs":{},"么":{"docs":{},"做":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"决":{"docs":{},"定":{"docs":{},"了":{"docs":{},"要":{"docs":{},"删":{"docs":{},"除":{"docs":{},"集":{"docs":{},"合":{"docs":{},"中":{"docs":{},"的":{"docs":{},"哪":{"docs":{},"些":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}},"更":{"docs":{},"新":{"docs":{},"集":{"docs":{},"合":{"docs":{},"中":{"docs":{},"的":{"docs":{},"哪":{"docs":{},"个":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.004975124378109453}}}}}}}}}},"找":{"docs":{},"到":{"docs":{},"的":{"docs":{},"整":{"docs":{},"个":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"用":{"docs":{},"来":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"集":{"docs":{},"合":{"docs":{},"中":{"docs":{},"的":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"指":{"docs":{},"示":{"docs":{},"存":{"docs":{},"储":{"docs":{},"配":{"docs":{},"置":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}},"，":{"docs":{},"就":{"docs":{},"会":{"docs":{},"忽":{"docs":{},"略":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"会":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"传":{"docs":{},"给":{"docs":{},"此":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}},"是":{"docs":{},"必":{"docs":{},"须":{"docs":{},"的":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"确":{"docs":{},"定":{"docs":{},"哪":{"docs":{},"一":{"docs":{},"个":{"docs":{},"才":{"docs":{},"是":{"docs":{},"我":{"docs":{},"们":{"docs":{},"要":{"docs":{},"读":{"docs":{},"取":{"docs":{},"的":{"docs":{},"。":{"docs":{},"另":{"docs":{},"外":{"docs":{},"，":{"docs":{},"应":{"docs":{},"用":{"docs":{},"必":{"docs":{},"须":{"docs":{},"要":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"对":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"以":{"docs":{},"下":{"docs":{},"类":{"docs":{},"型":{"docs":{},"中":{"docs":{},"任":{"docs":{},"意":{"docs":{},"一":{"docs":{},"个":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}},"和":{"docs":{},"异":{"docs":{},"步":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}},"考":{"docs":{},"这":{"docs":{},"里":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"代":{"docs":{},"码":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}},"又":{"docs":{},"或":{"docs":{},"者":{"docs":{},"收":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"请":{"docs":{},"求":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"例":{"docs":{},"如":{"docs":{},"匹":{"docs":{},"配":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"的":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"如":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"消":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"订":{"docs":{},"阅":{"docs":{},"/":{"docs":{},"离":{"docs":{},"开":{"docs":{},"多":{"docs":{},"播":{"docs":{},"组":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"发":{"docs":{},"布":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"得":{"docs":{},"可":{"docs":{},"访":{"docs":{},"问":{"docs":{},"的":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"受":{"docs":{},"信":{"docs":{},"存":{"docs":{},"储":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"另":{"docs":{},"一":{"docs":{},"种":{"docs":{},"单":{"docs":{},"独":{"docs":{},"提":{"docs":{},"供":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"私":{"docs":{},"钥":{"docs":{},"和":{"docs":{},"证":{"docs":{},"书":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"证":{"docs":{},"书":{"docs":{},"颁":{"docs":{},"发":{"docs":{},"机":{"docs":{},"构":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"文":{"docs":{},"件":{"docs":{},"列":{"docs":{},"表":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"访":{"docs":{},"问":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"个":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}},"外":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}},"一":{"docs":{},"种":{"docs":{},"分":{"docs":{},"别":{"docs":{},"提":{"docs":{},"供":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"私":{"docs":{},"钥":{"docs":{},"和":{"docs":{},"证":{"docs":{},"书":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"写":{"docs":{},"法":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"接":{"docs":{},"口":{"docs":{},"获":{"docs":{},"取":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"对":{"docs":{},"基":{"docs":{},"于":{"docs":{},"角":{"docs":{},"色":{"docs":{},"模":{"docs":{},"型":{"docs":{},"的":{"docs":{},"用":{"docs":{},"户":{"docs":{},"进":{"docs":{},"行":{"docs":{},"授":{"docs":{},"权":{"docs":{},"就":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"，":{"docs":{},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"就":{"docs":{},"像":{"docs":{},"上":{"docs":{},"边":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"的":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"权":{"docs":{},"限":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"如":{"docs":{},"何":{"docs":{},"被":{"docs":{},"解":{"docs":{},"释":{"docs":{},"完":{"docs":{},"全":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"底":{"docs":{},"层":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"不":{"docs":{},"对":{"docs":{},"解":{"docs":{},"释":{"docs":{},"细":{"docs":{},"节":{"docs":{},"提":{"docs":{},"供":{"docs":{},"假":{"docs":{},"设":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"如":{"docs":{},"果":{"docs":{},"想":{"docs":{},"知":{"docs":{},"道":{"docs":{},"消":{"docs":{},"息":{"docs":{},"是":{"docs":{},"否":{"docs":{},"成":{"docs":{},"功":{"docs":{},"被":{"docs":{},"消":{"docs":{},"费":{"docs":{},"掉":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"如":{"docs":{},"果":{"docs":{},"需":{"docs":{},"要":{"docs":{},"修":{"docs":{},"改":{"docs":{},"打":{"docs":{},"包":{"docs":{},"好":{"docs":{},"的":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}},"只":{"docs":{},"要":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"循":{"docs":{},"环":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"商":{"docs":{},"被":{"docs":{},"配":{"docs":{},"置":{"docs":{},"为":{"docs":{},"支":{"docs":{},"持":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"您":{"docs":{},"从":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"从":{"docs":{},"获":{"docs":{},"取":{"docs":{},"时":{"docs":{},"间":{"docs":{},"格":{"docs":{},"式":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"此":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"都":{"docs":{},"将":{"docs":{},"会":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"将":{"docs":{},"它":{"docs":{},"们":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"向":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}},"匹":{"docs":{},"配":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"是":{"docs":{},"在":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"查":{"docs":{},"找":{"docs":{},"实":{"docs":{},"际":{"docs":{},"的":{"docs":{},"会":{"docs":{},"话":{"docs":{},"数":{"docs":{},"据":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"标":{"docs":{},"示":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"标":{"docs":{},"示":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"通":{"docs":{},"过":{"docs":{},"安":{"docs":{},"全":{"docs":{},"的":{"docs":{},"随":{"docs":{},"机":{"docs":{},"过":{"docs":{},"程":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"做":{"docs":{},"了":{"docs":{},"一":{"docs":{},"层":{"docs":{},"异":{"docs":{},"步":{"docs":{},"封":{"docs":{},"装":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},"有":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"在":{"docs":{},"第":{"docs":{},"一":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.004975124378109453}}}}}}}},"当":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"发":{"docs":{},"生":{"docs":{},"时":{"docs":{},"，":{"docs":{},"才":{"docs":{},"会":{"docs":{},"开":{"docs":{},"始":{"docs":{},"发":{"docs":{},"射":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"而":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"需":{"docs":{},"要":{"docs":{},"调":{"docs":{},"用":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}},"在":{"docs":{},"构":{"docs":{},"建":{"docs":{},"配":{"docs":{},"置":{"docs":{},"中":{"docs":{},"加":{"docs":{},"上":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"读":{"docs":{},"取":{"docs":{},"一":{"docs":{},"个":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"而":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"会":{"docs":{},"从":{"docs":{},"一":{"docs":{},"个":{"docs":{},"目":{"docs":{},"录":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{},"一":{"docs":{},"批":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"同":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"一":{"docs":{},"个":{"docs":{},"地":{"docs":{},"址":{"docs":{},"可":{"docs":{},"以":{"docs":{},"注":{"docs":{},"册":{"docs":{},"许":{"docs":{},"多":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"注":{"docs":{},"册":{"docs":{},"在":{"docs":{},"多":{"docs":{},"个":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"上":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"任":{"docs":{},"何":{"docs":{},"花":{"docs":{},"哨":{"docs":{},"的":{"docs":{},"寻":{"docs":{},"址":{"docs":{},"方":{"docs":{},"案":{"docs":{},"相":{"docs":{},"比":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"格":{"docs":{},"式":{"docs":{},"并":{"docs":{},"不":{"docs":{},"麻":{"docs":{},"烦":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"，":{"docs":{},"任":{"docs":{},"意":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"都":{"docs":{},"合":{"docs":{},"法":{"docs":{},"。":{"docs":{},"当":{"docs":{},"然":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"某":{"docs":{},"种":{"docs":{},"模":{"docs":{},"式":{"docs":{},"来":{"docs":{},"命":{"docs":{},"名":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"是":{"docs":{},"明":{"docs":{},"智":{"docs":{},"的":{"docs":{},"。":{"docs":{},"如":{"docs":{},"：":{"docs":{},"使":{"docs":{},"用":{"docs":{},"点":{"docs":{},"号":{"docs":{},"来":{"docs":{},"划":{"docs":{},"分":{"docs":{},"命":{"docs":{},"名":{"docs":{},"空":{"docs":{},"间":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"也":{"docs":{},"表":{"docs":{},"示":{"docs":{},"（":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"）":{"docs":{},"可":{"docs":{},"以":{"docs":{},"发":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"剩":{"docs":{},"余":{"docs":{},"部":{"docs":{},"分":{"docs":{},"。":{"docs":{},"通":{"docs":{},"常":{"docs":{},"将":{"docs":{},"其":{"docs":{},"与":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"编":{"docs":{},"程":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"达":{"docs":{},"到":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"目":{"docs":{},"的":{"docs":{},"：":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"作":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"这":{"docs":{},"些":{"docs":{},"配":{"docs":{},"置":{"docs":{},"近":{"docs":{},"似":{"docs":{},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"要":{"docs":{},"确":{"docs":{},"保":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}},"样":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"中":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"代":{"docs":{},"码":{"docs":{},"用":{"docs":{},"单":{"docs":{},"线":{"docs":{},"程":{"docs":{},"方":{"docs":{},"式":{"docs":{},"编":{"docs":{},"写":{"docs":{},"，":{"docs":{},"让":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"，":{"docs":{},"这":{"docs":{},"儿":{"docs":{},"也":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"异":{"docs":{},"步":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"我":{"docs":{},"们":{"docs":{},"为":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}},"（":{"docs":{},"与":{"docs":{},"默":{"docs":{},"认":{"docs":{},"使":{"docs":{},"用":{"docs":{},"共":{"docs":{},"享":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"）":{"docs":{},"，":{"docs":{},"只":{"docs":{},"有":{"docs":{},"在":{"docs":{},"第":{"docs":{},"一":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"才":{"docs":{},"会":{"docs":{},"真":{"docs":{},"正":{"docs":{},"的":{"docs":{},"根":{"docs":{},"据":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"才":{"docs":{},"会":{"docs":{},"真":{"docs":{},"正":{"docs":{},"的":{"docs":{},"根":{"docs":{},"据":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"重":{"docs":{},"要":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"代":{"docs":{},"表":{"docs":{},"输":{"docs":{},"出":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"应":{"docs":{},"该":{"docs":{},"设":{"docs":{},"置":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"的":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"需":{"docs":{},"要":{"docs":{},"设":{"docs":{},"置":{"docs":{},"项":{"docs":{},"目":{"docs":{},"命":{"docs":{},"名":{"docs":{},"空":{"docs":{},"间":{"docs":{},"作":{"docs":{},"为":{"docs":{},"发":{"docs":{},"现":{"docs":{},"范":{"docs":{},"围":{"docs":{},"：":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}}},"步":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"从":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"到":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"其":{"docs":{},"他":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"亦":{"docs":{},"可":{"docs":{},"通":{"docs":{},"过":{"docs":{},"编":{"docs":{},"程":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"来":{"docs":{},"进":{"docs":{},"行":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"举":{"docs":{},"例":{"docs":{},"：":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"名":{"docs":{},"称":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"不":{"docs":{},"在":{"docs":{},"区":{"docs":{},"域":{"docs":{},"内":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"可":{"docs":{},"以":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"前":{"docs":{},"缀":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"或":{"docs":{},"传":{"docs":{},"入":{"docs":{},"您":{"docs":{},"已":{"docs":{},"经":{"docs":{},"创":{"docs":{},"建":{"docs":{},"好":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"来":{"docs":{},"记":{"docs":{},"录":{"docs":{},"网":{"docs":{},"络":{"docs":{},"活":{"docs":{},"动":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"网":{"docs":{},"络":{"docs":{},"活":{"docs":{},"动":{"docs":{},"记":{"docs":{},"录":{"docs":{},"时":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"注":{"docs":{},"意":{"docs":{},"以":{"docs":{},"下":{"docs":{},"几":{"docs":{},"点":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"错":{"docs":{},"误":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"本":{"docs":{},"地":{"docs":{},"会":{"docs":{},"话":{"docs":{},"存":{"docs":{},"储":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}},"集":{"docs":{},"群":{"docs":{},"会":{"docs":{},"话":{"docs":{},"存":{"docs":{},"储":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"后":{"docs":{},"缀":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"如":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"续":{"docs":{},"的":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"的":{"docs":{},"值":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"让":{"docs":{},"文":{"docs":{},"档":{"docs":{},"基":{"docs":{},"于":{"docs":{},"创":{"docs":{},"建":{"docs":{},"时":{"docs":{},"间":{"docs":{},"排":{"docs":{},"序":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"前":{"4":{"docs":{},"个":{"docs":{},"字":{"docs":{},"节":{"docs":{},"用":{"docs":{},"来":{"docs":{},"存":{"docs":{},"储":{"docs":{},"创":{"docs":{},"建":{"docs":{},"的":{"docs":{},"时":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"戳":{"docs":{},"，":{"docs":{},"精":{"docs":{},"确":{"docs":{},"到":{"docs":{},"秒":{"docs":{},"）":{"docs":{},"。":{"docs":{},"您":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"直":{"docs":{},"接":{"docs":{},"调":{"docs":{},"用":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"向":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281}},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"写":{"docs":{},"入":{"docs":{},"数":{"docs":{},"据":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"中":{"docs":{},"写":{"docs":{},"入":{"docs":{},"数":{"docs":{},"据":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"其":{"docs":{},"泵":{"docs":{},"送":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"如":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"帧":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"会":{"docs":{},"话":{"docs":{},"中":{"docs":{},"设":{"docs":{},"置":{"docs":{},"值":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"响":{"docs":{},"应":{"docs":{},"里":{"docs":{},"写":{"docs":{},"入":{"docs":{},"了":{"docs":{},"数":{"docs":{},"据":{"docs":{},"并":{"docs":{},"结":{"docs":{},"束":{"docs":{},"了":{"docs":{},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"，":{"5":{"docs":{},"秒":{"docs":{},"之":{"docs":{},"后":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"docs":{},"再":{"5":{"docs":{},"秒":{"docs":{},"之":{"docs":{},"后":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"docs":{}}}}}}}}}}},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"中":{"docs":{},"存":{"docs":{},"储":{"docs":{},"一":{"docs":{},"些":{"docs":{},"数":{"docs":{},"据":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}},"否":{"docs":{},"则":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"d":{"docs":{},"k":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"失":{"docs":{},"败":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"若":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"4":{"docs":{},"j":{"docs":{},"可":{"docs":{},"见":{"docs":{},"，":{"docs":{},"再":{"docs":{},"使":{"docs":{},"用":{"docs":{},"该":{"docs":{},"库":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"docs":{}}}}},"退":{"docs":{},"回":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"周":{"docs":{},"期":{"docs":{},"性":{"docs":{},"、":{"docs":{},"延":{"docs":{},"迟":{"docs":{},"性":{"docs":{},"动":{"docs":{},"作":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"的":{"docs":{},"任":{"docs":{},"务":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}},"、":{"docs":{},"异":{"docs":{},"步":{"docs":{},"文":{"docs":{},"件":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"若":{"docs":{},"底":{"docs":{},"层":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"支":{"docs":{},"持":{"docs":{},"，":{"docs":{},"这":{"docs":{},"会":{"docs":{},"导":{"docs":{},"致":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"不":{"docs":{},"通":{"docs":{},"过":{"docs":{},"用":{"docs":{},"户":{"docs":{},"空":{"docs":{},"间":{"docs":{},"复":{"docs":{},"制":{"docs":{},"而":{"docs":{},"直":{"docs":{},"接":{"docs":{},"将":{"docs":{},"文":{"docs":{},"件":{"docs":{},"内":{"docs":{},"容":{"docs":{},"中":{"docs":{},"字":{"docs":{},"节":{"docs":{},"数":{"docs":{},"据":{"docs":{},"从":{"docs":{},"文":{"docs":{},"件":{"docs":{},"传":{"docs":{},"输":{"docs":{},"到":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"会":{"docs":{},"显":{"docs":{},"示":{"docs":{},"一":{"docs":{},"个":{"docs":{},"登":{"docs":{},"录":{"docs":{},"窗":{"docs":{},"口":{"docs":{},"并":{"docs":{},"提":{"docs":{},"示":{"docs":{},"用":{"docs":{},"户":{"docs":{},"输":{"docs":{},"入":{"docs":{},"他":{"docs":{},"们":{"docs":{},"的":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"和":{"docs":{},"密":{"docs":{},"码":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"写":{"docs":{},"入":{"docs":{},"任":{"docs":{},"意":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"通":{"docs":{},"常":{"docs":{},"直":{"docs":{},"接":{"docs":{},"操":{"docs":{},"作":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"体":{"docs":{},"以":{"docs":{},"块":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"写":{"docs":{},"入":{"docs":{},"，":{"docs":{},"通":{"docs":{},"常":{"docs":{},"在":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"预":{"docs":{},"先":{"docs":{},"不":{"docs":{},"知":{"docs":{},"道":{"docs":{},"尺":{"docs":{},"寸":{"docs":{},"、":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"很":{"docs":{},"大":{"docs":{},"响":{"docs":{},"应":{"docs":{},"正":{"docs":{},"文":{"docs":{},"以":{"docs":{},"流":{"docs":{},"式":{"docs":{},"传":{"docs":{},"输":{"docs":{},"到":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"编":{"docs":{},"解":{"docs":{},"码":{"docs":{},"器":{"docs":{},"对":{"docs":{},"二":{"docs":{},"进":{"docs":{},"制":{"docs":{},"数":{"docs":{},"据":{"docs":{},"流":{"docs":{},"解":{"docs":{},"码":{"docs":{},"，":{"docs":{},"以":{"docs":{},"节":{"docs":{},"省":{"docs":{},"您":{"docs":{},"在":{"docs":{},"响":{"docs":{},"应":{"docs":{},"处":{"docs":{},"理":{"docs":{},"中":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"。":{"docs":{},"其":{"docs":{},"间":{"docs":{},"，":{"docs":{},"背":{"docs":{},"压":{"docs":{},"机":{"docs":{},"制":{"docs":{},"是":{"docs":{},"自":{"docs":{},"动":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"。":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}},"写":{"docs":{},"入":{"docs":{},"数":{"docs":{},"据":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"在":{"docs":{},"写":{"docs":{},"操":{"docs":{},"作":{"docs":{},"进":{"docs":{},"入":{"docs":{},"队":{"docs":{},"列":{"docs":{},"之":{"docs":{},"后":{"docs":{},"会":{"docs":{},"立":{"docs":{},"即":{"docs":{},"返":{"docs":{},"回":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"包":{"docs":{},"含":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"（":{"docs":{},"正":{"docs":{},"文":{"docs":{},"）":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"在":{"docs":{},"响":{"docs":{},"应":{"docs":{},"头":{"docs":{},"被":{"docs":{},"读":{"docs":{},"取":{"docs":{},"后":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"时":{"docs":{},"间":{"docs":{},"以":{"docs":{},"分":{"docs":{},"片":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"到":{"docs":{},"达":{"docs":{},"。":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{},"响":{"docs":{},"应":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"不":{"docs":{},"要":{"docs":{},"等":{"docs":{},"待":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"到":{"docs":{},"达":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"可":{"docs":{},"能":{"docs":{},"非":{"docs":{},"常":{"docs":{},"大":{"docs":{},"而":{"docs":{},"要":{"docs":{},"等":{"docs":{},"待":{"docs":{},"很":{"docs":{},"长":{"docs":{},"时":{"docs":{},"间":{"docs":{},"、":{"docs":{},"又":{"docs":{},"或":{"docs":{},"者":{"docs":{},"会":{"docs":{},"花":{"docs":{},"费":{"docs":{},"大":{"docs":{},"量":{"docs":{},"内":{"docs":{},"存":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"送":{"docs":{},"回":{"docs":{},"来":{"docs":{},"时":{"docs":{},"调":{"docs":{},"用":{"docs":{},"该":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"响":{"docs":{},"应":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"包":{"docs":{},"含":{"docs":{},"头":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"和":{"docs":{},"附":{"docs":{},"加":{"docs":{},"尾":{"docs":{},"部":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"头":{"docs":{},"中":{"docs":{},"单":{"docs":{},"个":{"docs":{},"键":{"docs":{},"可":{"docs":{},"以":{"docs":{},"关":{"docs":{},"联":{"docs":{},"多":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"可":{"docs":{},"直":{"docs":{},"接":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"和":{"docs":{},"尾":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"写":{"docs":{},"入":{"docs":{},"响":{"docs":{},"应":{"docs":{},"正":{"docs":{},"文":{"docs":{},"消":{"docs":{},"息":{"docs":{},"之":{"docs":{},"前":{"docs":{},"进":{"docs":{},"行":{"docs":{},"设":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"响":{"docs":{},"应":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"将":{"docs":{},"传":{"docs":{},"递":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"响":{"docs":{},"应":{"docs":{},"以":{"docs":{},"替":{"docs":{},"代":{"docs":{},"原":{"docs":{},"始":{"docs":{},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"完":{"docs":{},"成":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"模":{"docs":{},"式":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"响":{"docs":{},"应":{"docs":{},"尾":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"附":{"docs":{},"加":{"docs":{},"尾":{"docs":{},"部":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{},"写":{"docs":{},"入":{"docs":{},"响":{"docs":{},"应":{"docs":{},"，":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"是":{"docs":{},"在":{"docs":{},"写":{"docs":{},"入":{"docs":{},"响":{"docs":{},"应":{"docs":{},"的":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"块":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"则":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"可":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"时":{"docs":{},"间":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}},"变":{"docs":{},"得":{"docs":{},"更":{"docs":{},"加":{"docs":{},"便":{"docs":{},"捷":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"额":{"docs":{},"外":{"docs":{},"的":{"docs":{},"高":{"docs":{},"级":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}},"编":{"docs":{},"解":{"docs":{},"码":{"docs":{},"器":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}},"唯":{"docs":{},"一":{"docs":{},"的":{"docs":{},"保":{"docs":{},"证":{"docs":{},"是":{"docs":{},"，":{"docs":{},"它":{"docs":{},"既":{"docs":{},"不":{"docs":{},"会":{"docs":{},"被":{"docs":{},"完":{"docs":{},"全":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"，":{"docs":{},"也":{"docs":{},"不":{"docs":{},"会":{"docs":{},"完":{"docs":{},"全":{"docs":{},"不":{"docs":{},"被":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"，":{"docs":{},"即":{"docs":{},"只":{"docs":{},"有":{"docs":{},"部":{"docs":{},"分":{"docs":{},"会":{"docs":{},"被":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"区":{"docs":{},"别":{"docs":{},"是":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"多":{"docs":{},"播":{"docs":{},"组":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"因":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"允":{"docs":{},"许":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"键":{"docs":{},"支":{"docs":{},"持":{"docs":{},"多":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"既":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"也":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"协":{"docs":{},"议":{"docs":{},"不":{"docs":{},"会":{"docs":{},"将":{"docs":{},"消":{"docs":{},"息":{"docs":{},"发":{"docs":{},"送":{"docs":{},"回":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"将":{"docs":{},"会":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"包":{"docs":{},"发":{"docs":{},"送":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"在":{"docs":{},"通":{"docs":{},"常":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"您":{"docs":{},"不":{"docs":{},"能":{"docs":{},"发":{"docs":{},"送":{"docs":{},"大":{"docs":{},"于":{"docs":{},"网":{"docs":{},"络":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"传":{"docs":{},"输":{"docs":{},"单":{"docs":{},"元":{"docs":{},"（":{"docs":{},"m":{"docs":{},"t":{"docs":{},"u":{"docs":{},"）":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"其":{"docs":{},"具":{"docs":{},"有":{"docs":{},"更":{"docs":{},"高":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"会":{"docs":{},"共":{"docs":{},"享":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}},"此":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"可":{"docs":{},"直":{"docs":{},"接":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"核":{"docs":{},"，":{"docs":{},"而":{"docs":{},"每":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"要":{"docs":{},"监":{"docs":{},"听":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"和":{"docs":{},"端":{"docs":{},"口":{"docs":{},"、":{"docs":{},"并":{"docs":{},"且":{"docs":{},"接":{"docs":{},"收":{"docs":{},"多":{"docs":{},"播":{"docs":{},"组":{"2":{"3":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"报":{"docs":{},"，":{"docs":{},"您":{"docs":{},"将":{"docs":{},"执":{"docs":{},"行":{"docs":{},"如":{"docs":{},"下":{"docs":{},"操":{"docs":{},"作":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"构":{"docs":{},"建":{"docs":{},"容":{"docs":{},"器":{"docs":{},"镜":{"docs":{},"像":{"docs":{},"时":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"显":{"docs":{},"式":{"docs":{},"声":{"docs":{},"明":{"docs":{},"：":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}}},"地":{"docs":{},"址":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}},"获":{"docs":{},"得":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"任":{"docs":{},"何":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"格":{"docs":{},"式":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}},"）":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}},"配":{"docs":{},"置":{"docs":{},"有":{"docs":{},"难":{"docs":{},"点":{"docs":{},"，":{"docs":{},"请":{"docs":{},"强":{"docs":{},"制":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}},"列":{"docs":{},"表":{"docs":{},"。":{"docs":{},"具":{"docs":{},"体":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}},"块":{"docs":{},"被":{"docs":{},"写":{"docs":{},"出":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"域":{"docs":{},"名":{"docs":{},"不":{"docs":{},"应":{"docs":{},"该":{"docs":{},"存":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"基":{"docs":{},"本":{"docs":{},"概":{"docs":{},"念":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"术":{"docs":{},"语":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}},"于":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"可":{"docs":{},"接":{"docs":{},"受":{"docs":{},"媒":{"docs":{},"体":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"m":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"正":{"docs":{},"则":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"路":{"docs":{},"径":{"docs":{},"匹":{"docs":{},"配":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"由":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"精":{"docs":{},"确":{"docs":{},"路":{"docs":{},"径":{"docs":{},"的":{"docs":{},"路":{"docs":{},"由":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"媒":{"docs":{},"体":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"m":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"路":{"docs":{},"径":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"的":{"docs":{},"路":{"docs":{},"由":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"通":{"docs":{},"配":{"docs":{},"符":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"型":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"也":{"docs":{},"是":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"的":{"docs":{},"认":{"docs":{},"证":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"一":{"docs":{},"个":{"docs":{},"命":{"docs":{},"名":{"docs":{},"的":{"docs":{},"工":{"docs":{},"作":{"docs":{},"线":{"docs":{},"程":{"docs":{},"池":{"docs":{},"（":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}},"础":{"docs":{},"认":{"docs":{},"证":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"声":{"docs":{},"明":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"选":{"docs":{},"项":{"docs":{},"会":{"docs":{},"接":{"docs":{},"受":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"了":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"存":{"docs":{},"储":{"docs":{},"源":{"docs":{},"就":{"docs":{},"必":{"docs":{},"须":{"docs":{},"要":{"docs":{},"指":{"docs":{},"明":{"docs":{},"存":{"docs":{},"储":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"）":{"docs":{},"。":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"指":{"docs":{},"定":{"docs":{},"格":{"docs":{},"式":{"docs":{},"（":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"）":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"3":{"0":{"docs":{},"x":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}},"docs":{}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"响":{"docs":{},"应":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"中":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"压":{"docs":{},"缩":{"docs":{},"体":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0024342745861733205}},"只":{"docs":{},"是":{"docs":{},"接":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"，":{"docs":{},"确":{"docs":{},"认":{"docs":{},"被":{"docs":{},"发":{"docs":{},"送":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"功":{"docs":{},"能":{"docs":{},"旨":{"docs":{},"在":{"docs":{},"基":{"docs":{},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"由":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"处":{"docs":{},"理":{"docs":{},"这":{"docs":{},"个":{"docs":{},"问":{"docs":{},"题":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"器":{"docs":{},"能":{"docs":{},"够":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"所":{"docs":{},"有":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"这":{"docs":{},"个":{"docs":{},"功":{"docs":{},"能":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"直":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"它":{"docs":{},"读":{"docs":{},"取":{"docs":{},"到":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"进":{"docs":{},"行":{"docs":{},"回":{"docs":{},"写":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"会":{"docs":{},"话":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"之":{"docs":{},"前":{"docs":{},"被":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"类":{"docs":{},"，":{"docs":{},"用":{"docs":{},"于":{"docs":{},"响":{"docs":{},"应":{"docs":{},"由":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"发":{"docs":{},"送":{"docs":{},"的":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}},"完":{"docs":{},"成":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"请":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"异":{"docs":{},"常":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}},"数":{"docs":{},"据":{"docs":{},"报":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"文":{"docs":{},"件":{"docs":{},"上":{"docs":{},"传":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"网":{"docs":{},"络":{"docs":{},"分":{"docs":{},"区":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"请":{"docs":{},"求":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"并":{"docs":{},"调":{"docs":{},"用":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"逻":{"docs":{},"辑":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"。":{"docs":{},"原":{"docs":{},"文":{"docs":{},"中":{"docs":{},"的":{"docs":{},"动":{"docs":{},"词":{"docs":{},"统":{"docs":{},"一":{"docs":{},"译":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"会":{"docs":{},"话":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"登":{"docs":{},"录":{"docs":{},"请":{"docs":{},"求":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"跨":{"docs":{},"域":{"docs":{},"资":{"docs":{},"源":{"docs":{},"共":{"docs":{},"享":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"静":{"docs":{},"态":{"docs":{},"资":{"docs":{},"源":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"您":{"docs":{},"的":{"docs":{},"登":{"docs":{},"录":{"docs":{},"页":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"响":{"docs":{},"应":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}},"失":{"docs":{},"败":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"事":{"docs":{},"务":{"docs":{},"的":{"docs":{},"相":{"docs":{},"关":{"docs":{},"命":{"docs":{},"令":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}},"响":{"docs":{},"应":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"对":{"docs":{},"象":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}},"结":{"docs":{},"果":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.008403361344537815}}}}}},"多":{"docs":{},"个":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"播":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"允":{"docs":{},"许":{"docs":{},"多":{"docs":{},"个":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"接":{"docs":{},"收":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"，":{"docs":{},"该":{"docs":{},"目":{"docs":{},"标":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"加":{"docs":{},"入":{"docs":{},"到":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"发":{"docs":{},"送":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"的":{"docs":{},"多":{"docs":{},"播":{"docs":{},"组":{"docs":{},"来":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"不":{"docs":{},"可":{"docs":{},"用":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}},"路":{"docs":{},"复":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"大":{"docs":{},"多":{"docs":{},"数":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"流":{"docs":{},"式":{"docs":{},"传":{"docs":{},"输":{"docs":{},"方":{"docs":{},"式":{"docs":{},"会":{"docs":{},"在":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"保":{"docs":{},"存":{"docs":{},"响":{"docs":{},"应":{"docs":{},"的":{"docs":{},"内":{"docs":{},"容":{"docs":{},"并":{"docs":{},"且":{"docs":{},"不":{"docs":{},"会":{"docs":{},"释":{"docs":{},"放":{"docs":{},"派":{"docs":{},"发":{"docs":{},"消":{"docs":{},"息":{"docs":{},"所":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"内":{"docs":{},"存":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"传":{"docs":{},"输":{"docs":{},"方":{"docs":{},"式":{"docs":{},"需":{"docs":{},"要":{"docs":{},"定":{"docs":{},"期":{"docs":{},"执":{"docs":{},"行":{"docs":{},"垃":{"docs":{},"圾":{"docs":{},"回":{"docs":{},"收":{"docs":{},"。":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"_":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"户":{"docs":{},"并":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"配":{"docs":{},"置":{"docs":{},"这":{"docs":{},"些":{"docs":{},"值":{"docs":{},"，":{"docs":{},"除":{"docs":{},"非":{"docs":{},"您":{"docs":{},"发":{"docs":{},"现":{"docs":{},"应":{"docs":{},"用":{"docs":{},"的":{"docs":{},"性":{"docs":{},"能":{"docs":{},"被":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}},"小":{"docs":{},"为":{"docs":{},"q":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"部":{"docs":{},"分":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"都":{"docs":{},"是":{"docs":{},"事":{"docs":{},"件":{"docs":{},"驱":{"docs":{},"动":{"docs":{},"的":{"docs":{},"。":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"当":{"docs":{},"您":{"docs":{},"感":{"docs":{},"兴":{"docs":{},"趣":{"docs":{},"的":{"docs":{},"事":{"docs":{},"情":{"docs":{},"发":{"docs":{},"生":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"以":{"docs":{},"事":{"docs":{},"件":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"发":{"docs":{},"送":{"docs":{},"给":{"docs":{},"您":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"您":{"docs":{},"希":{"docs":{},"望":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"之":{"docs":{},"间":{"docs":{},"共":{"docs":{},"享":{"docs":{},"一":{"docs":{},"个":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}},"都":{"docs":{},"将":{"docs":{},"希":{"docs":{},"望":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"实":{"docs":{},"例":{"docs":{},"（":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"共":{"docs":{},"享":{"docs":{},"一":{"docs":{},"个":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"希":{"docs":{},"望":{"docs":{},"在":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}},"失":{"docs":{},"败":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"和":{"docs":{},"普":{"docs":{},"通":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"具":{"docs":{},"有":{"docs":{},"完":{"docs":{},"全":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"路":{"docs":{},"由":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"规":{"docs":{},"则":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"!":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.009575923392612859}}},"回":{"docs":{},"调":{"docs":{},"可":{"docs":{},"以":{"docs":{},"直":{"docs":{},"接":{"docs":{},"设":{"docs":{},"置":{"docs":{},"在":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"系":{"docs":{},"统":{"docs":{},"将":{"docs":{},"选":{"docs":{},"取":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}},"头":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"若":{"docs":{},"您":{"docs":{},"不":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"当":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"时":{"docs":{},"自":{"docs":{},"动":{"docs":{},"发":{"docs":{},"回":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"，":{"docs":{},"其":{"docs":{},"值":{"docs":{},"为":{"docs":{},"可":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"算":{"docs":{},"法":{"docs":{},"，":{"docs":{},"（":{"docs":{},"该":{"docs":{},"值":{"docs":{},"可":{"docs":{},"）":{"docs":{},"支":{"docs":{},"持":{"docs":{},"多":{"docs":{},"种":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"算":{"docs":{},"法":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"否":{"docs":{},"则":{"docs":{},"会":{"docs":{},"太":{"docs":{},"迟":{"docs":{},"。":{"docs":{},"若":{"docs":{},"您":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"因":{"docs":{},"此":{"docs":{},"您":{"docs":{},"不":{"docs":{},"必":{"docs":{},"先":{"docs":{},"计":{"docs":{},"算":{"docs":{},"大":{"docs":{},"小":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"妙":{"docs":{},"极":{"docs":{},"！":{"docs":{},"—":{"docs":{},"—":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"始":{"docs":{},"终":{"docs":{},"会":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"根":{"docs":{},"据":{"docs":{},"需":{"docs":{},"要":{"docs":{},"进":{"docs":{},"行":{"docs":{},"自":{"docs":{},"动":{"docs":{},"扩":{"docs":{},"容":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"子":{"docs":{},"类":{"docs":{},"可":{"docs":{},"以":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"路":{"docs":{},"由":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}},"径":{"docs":{},"用":{"docs":{},"来":{"docs":{},"存":{"docs":{},"储":{"docs":{},"用":{"docs":{},"于":{"docs":{},"管":{"docs":{},"理":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}},"它":{"docs":{},"不":{"docs":{},"会":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"，":{"docs":{},"但":{"docs":{},"当":{"docs":{},"锁":{"docs":{},"可":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"也":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"支":{"docs":{},"持":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"会":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"响":{"docs":{},"应":{"docs":{},"结":{"docs":{},"束":{"docs":{},"之":{"docs":{},"前":{"docs":{},"被":{"docs":{},"多":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"以":{"docs":{},"下":{"docs":{},"几":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"调":{"docs":{},"用":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"永":{"docs":{},"远":{"docs":{},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"还":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"直":{"docs":{},"接":{"docs":{},"读":{"docs":{},"写":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"只":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"标":{"docs":{},"准":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"密":{"docs":{},"钥":{"docs":{},"存":{"docs":{},"储":{"docs":{},"，":{"docs":{},"与":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"端":{"docs":{},"的":{"docs":{},"密":{"docs":{},"钥":{"docs":{},"存":{"docs":{},"储":{"docs":{},"相":{"docs":{},"同":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"在":{"docs":{},"j":{"docs":{},"s":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"失":{"docs":{},"败":{"docs":{},"的":{"docs":{},"尺":{"docs":{},"寸":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"等":{"docs":{},"（":{"docs":{},"其":{"docs":{},"他":{"docs":{},"原":{"docs":{},"因":{"docs":{},"）":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"按":{"docs":{},"照":{"docs":{},"经":{"docs":{},"验":{"docs":{},"法":{"docs":{},"则":{"docs":{},"就":{"docs":{},"是":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"发":{"docs":{},"送":{"docs":{},"小":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"输":{"docs":{},"入":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"区":{"docs":{},"序":{"docs":{},"列":{"docs":{},"转":{"docs":{},"换":{"docs":{},"为":{"docs":{},"已":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"区":{"docs":{},"序":{"docs":{},"列":{"docs":{},"（":{"docs":{},"固":{"docs":{},"定":{"docs":{},"大":{"docs":{},"小":{"docs":{},"或":{"docs":{},"带":{"docs":{},"分":{"docs":{},"隔":{"docs":{},"符":{"docs":{},"的":{"docs":{},"记":{"docs":{},"录":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"增":{"docs":{},"益":{"docs":{},"不":{"docs":{},"是":{"docs":{},"线":{"docs":{},"性":{"docs":{},"的":{"docs":{},"，":{"docs":{},"并":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"要":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"的":{"docs":{},"特":{"docs":{},"定":{"docs":{},"数":{"docs":{},"据":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"键":{"docs":{},"值":{"docs":{},"不":{"docs":{},"区":{"docs":{},"分":{"docs":{},"大":{"docs":{},"小":{"docs":{},"写":{"docs":{},"，":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"执":{"docs":{},"行":{"docs":{},"以":{"docs":{},"下":{"docs":{},"操":{"docs":{},"作":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"打":{"docs":{},"印":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"信":{"docs":{},"息":{"docs":{},"—":{"docs":{},"—":{"docs":{},"详":{"docs":{},"细":{"docs":{},"说":{"docs":{},"明":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"工":{"docs":{},"具":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"选":{"docs":{},"项":{"docs":{},"。":{"docs":{},"即":{"docs":{},"使":{"docs":{},"这":{"docs":{},"些":{"docs":{},"功":{"docs":{},"能":{"docs":{},"远":{"docs":{},"离":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"做":{"docs":{},"了":{"docs":{},"和":{"docs":{},"上":{"docs":{},"文":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"若":{"docs":{},"干":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"传":{"docs":{},"输":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"根":{"docs":{},"据":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"和":{"docs":{},"网":{"docs":{},"络":{"docs":{},"的":{"docs":{},"兼":{"docs":{},"容":{"docs":{},"性":{"docs":{},"来":{"docs":{},"选":{"docs":{},"择":{"docs":{},"使":{"docs":{},"用":{"docs":{},"哪":{"docs":{},"种":{"docs":{},"传":{"docs":{},"输":{"docs":{},"方":{"docs":{},"式":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"继":{"docs":{},"承":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"可":{"docs":{},"以":{"docs":{},"让":{"docs":{},"你":{"docs":{},"验":{"docs":{},"证":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"的":{"docs":{},"真":{"docs":{},"实":{"docs":{},"性":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}},"完":{"docs":{},"全":{"docs":{},"是":{"docs":{},"无":{"docs":{},"状":{"docs":{},"态":{"docs":{},"的":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"结":{"docs":{},"构":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"任":{"docs":{},"何":{"docs":{},"你":{"docs":{},"想":{"docs":{},"要":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"和":{"docs":{},"大":{"docs":{},"量":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}},"包":{"docs":{},"含":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}},"是":{"docs":{},"如":{"docs":{},"何":{"docs":{},"工":{"docs":{},"作":{"docs":{},"的":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"完":{"docs":{},"全":{"docs":{},"限":{"docs":{},"定":{"docs":{},"类":{"docs":{},"名":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"指":{"docs":{},"定":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"非":{"docs":{},"阻":{"docs":{},"塞":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"一":{"docs":{},"样":{"docs":{},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"时":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"，":{"docs":{},"执":{"docs":{},"行":{"docs":{},"相":{"docs":{},"关":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"并":{"docs":{},"完":{"docs":{},"成":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"返":{"docs":{},"回":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"组":{"docs":{},"合":{"docs":{},"完":{"docs":{},"成":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"，":{"docs":{},"无":{"docs":{},"论":{"docs":{},"成":{"docs":{},"败":{"docs":{},"。":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"整":{"docs":{},"的":{"docs":{},"细":{"docs":{},"节":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"接":{"docs":{},"口":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"阶":{"docs":{},"段":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"一":{"docs":{},"个":{"docs":{},"失":{"docs":{},"败":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"上":{"docs":{},"述":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"发":{"docs":{},"生":{"docs":{},"错":{"docs":{},"误":{"docs":{},"时":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"了":{"docs":{},"使":{"docs":{},"用":{"docs":{},"模":{"docs":{},"板":{"docs":{},"引":{"docs":{},"擎":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"当":{"docs":{},"渲":{"docs":{},"染":{"docs":{},"模":{"docs":{},"板":{"docs":{},"时":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"和":{"docs":{},"语":{"docs":{},"法":{"docs":{},"（":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}},"时":{"docs":{},"器":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"。":{"docs":{},"定":{"docs":{},"时":{"docs":{},"器":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"一":{"docs":{},"次":{"docs":{},"性":{"docs":{},"或":{"docs":{},"周":{"docs":{},"期":{"docs":{},"性":{"docs":{},"的":{"docs":{},"，":{"docs":{},"两":{"docs":{},"者":{"docs":{},"我":{"docs":{},"们":{"docs":{},"都":{"docs":{},"会":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"到":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"任":{"docs":{},"务":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.007462686567164179}},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"轻":{"docs":{},"松":{"docs":{},"地":{"docs":{},"配":{"docs":{},"置":{"docs":{},"为":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"和":{"docs":{},"使":{"docs":{},"用":{"docs":{},"标":{"docs":{},"准":{"docs":{},"套":{"docs":{},"接":{"docs":{},"字":{"docs":{},"具":{"docs":{},"有":{"docs":{},"完":{"docs":{},"全":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"为":{"docs":{},"信":{"docs":{},"任":{"docs":{},"所":{"docs":{},"有":{"docs":{},"证":{"docs":{},"书":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"会":{"docs":{},"发":{"docs":{},"送":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"受":{"docs":{},"信":{"docs":{},"配":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"可":{"docs":{},"配":{"docs":{},"置":{"docs":{},"成":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"向":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"主":{"docs":{},"机":{"docs":{},"/":{"docs":{},"端":{"docs":{},"口":{"docs":{},"发":{"docs":{},"送":{"docs":{},"很":{"docs":{},"多":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{},"为":{"docs":{},"避":{"docs":{},"免":{"docs":{},"每":{"docs":{},"次":{"docs":{},"发":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"重":{"docs":{},"复":{"docs":{},"设":{"docs":{},"主":{"docs":{},"机":{"docs":{},"/":{"docs":{},"端":{"docs":{},"口":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"配":{"docs":{},"置":{"docs":{},"默":{"docs":{},"认":{"docs":{},"主":{"docs":{},"机":{"docs":{},"/":{"docs":{},"端":{"docs":{},"口":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"启":{"docs":{},"用":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"/":{"docs":{},"t":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"压":{"docs":{},"缩":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"配":{"docs":{},"置":{"docs":{},"来":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"都":{"docs":{},"支":{"docs":{},"持":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"推":{"docs":{},"送":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"支":{"docs":{},"持":{"docs":{},"开":{"docs":{},"箱":{"docs":{},"即":{"docs":{},"用":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"，":{"docs":{},"它":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"重":{"docs":{},"用":{"docs":{},"请":{"docs":{},"求":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"是":{"docs":{},"很":{"docs":{},"灵":{"docs":{},"活":{"docs":{},"的":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"各":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"发":{"docs":{},"出":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"先":{"docs":{},"在":{"docs":{},"本":{"docs":{},"地":{"docs":{},"解":{"docs":{},"析":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}},"最":{"docs":{},"简":{"docs":{},"单":{"docs":{},"方":{"docs":{},"法":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"地":{"docs":{},"址":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"配":{"docs":{},"置":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"参":{"docs":{},"数":{"docs":{},"一":{"docs":{},"样":{"docs":{},"：":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"指":{"docs":{},"定":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"还":{"docs":{},"支":{"docs":{},"持":{"docs":{},"连":{"docs":{},"接":{"docs":{},"上":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"管":{"docs":{},"道":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"连":{"docs":{},"接":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"使":{"docs":{},"用":{"docs":{},"代":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"到":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"针":{"docs":{},"对":{"docs":{},"每":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"都":{"docs":{},"使":{"docs":{},"用":{"docs":{},"单":{"docs":{},"一":{"docs":{},"连":{"docs":{},"接":{"docs":{},"，":{"docs":{},"同":{"docs":{},"样":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"流":{"docs":{},"都":{"docs":{},"会":{"docs":{},"复":{"docs":{},"用":{"docs":{},"到":{"docs":{},"对":{"docs":{},"应":{"docs":{},"连":{"docs":{},"接":{"docs":{},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"通":{"docs":{},"常":{"docs":{},"是":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"）":{"docs":{},"之":{"docs":{},"间":{"docs":{},"实":{"docs":{},"现":{"docs":{},"全":{"docs":{},"双":{"docs":{},"工":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"生":{"docs":{},"产":{"docs":{},"者":{"docs":{},"和":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"）":{"docs":{},"和":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"来":{"docs":{},"访":{"docs":{},"问":{"docs":{},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"（":{"docs":{},"请":{"docs":{},"看":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"）":{"docs":{},"。":{"docs":{},"你":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"配":{"docs":{},"置":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}},"将":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"最":{"docs":{},"多":{"docs":{},"达":{"1":{"6":{"docs":{},"次":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"，":{"docs":{},"该":{"docs":{},"参":{"docs":{},"数":{"docs":{},"亦":{"docs":{},"可":{"docs":{},"在":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}},"把":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"信":{"docs":{},"息":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"利":{"docs":{},"于":{"docs":{},"理":{"docs":{},"解":{"docs":{},"的":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}},"不":{"docs":{},"知":{"docs":{},"道":{"docs":{},"如":{"docs":{},"何":{"docs":{},"修":{"docs":{},"复":{"docs":{},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"配":{"docs":{},"置":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"为":{"docs":{},"执":{"docs":{},"行":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"在":{"docs":{},"连":{"docs":{},"接":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"执":{"docs":{},"行":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"一":{"docs":{},"次":{"docs":{},"查":{"docs":{},"询":{"docs":{},"或":{"docs":{},"者":{"docs":{},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"添":{"docs":{},"加":{"docs":{},"下":{"docs":{},"列":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"：":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"把":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}},"因":{"docs":{},"为":{"docs":{},"他":{"docs":{},"们":{"docs":{},"不":{"docs":{},"会":{"docs":{},"通":{"docs":{},"知":{"docs":{},"他":{"docs":{},"们":{"docs":{},"何":{"docs":{},"时":{"docs":{},"离":{"docs":{},"开":{"docs":{},"集":{"docs":{},"群":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"丢":{"docs":{},"失":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"还":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"将":{"docs":{},"集":{"docs":{},"群":{"docs":{},"置":{"docs":{},"于":{"docs":{},"不":{"docs":{},"一":{"docs":{},"致":{"docs":{},"的":{"docs":{},"状":{"docs":{},"态":{"docs":{},"。":{"docs":{},"更":{"docs":{},"多":{"docs":{},"情":{"docs":{},"况":{"docs":{},"请":{"docs":{},"翻":{"docs":{},"阅":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"此":{"docs":{},"需":{"docs":{},"要":{"docs":{},"依":{"docs":{},"赖":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}},"给":{"docs":{},"需":{"docs":{},"要":{"docs":{},"与":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}},"证":{"docs":{},"书":{"docs":{},"—":{"docs":{},"—":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}},"流":{"docs":{},"程":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"须":{"docs":{},"用":{"docs":{},"于":{"docs":{},"且":{"docs":{},"仅":{"docs":{},"用":{"docs":{},"于":{"docs":{},"机":{"docs":{},"密":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"。":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}},"以":{"docs":{},"及":{"docs":{},"存":{"docs":{},"储":{"docs":{},"我":{"docs":{},"们":{"docs":{},"配":{"docs":{},"置":{"docs":{},"内":{"docs":{},"容":{"docs":{},"的":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}},"密":{"docs":{},"码":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"套":{"docs":{},"件":{"docs":{},"可":{"docs":{},"在":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"或":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"中":{"docs":{},"指":{"docs":{},"定":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"该":{"docs":{},"密":{"docs":{},"码":{"docs":{},"套":{"docs":{},"件":{"docs":{},"可":{"docs":{},"以":{"docs":{},"配":{"docs":{},"置":{"docs":{},"一":{"docs":{},"套":{"docs":{},"启":{"docs":{},"用":{"docs":{},"的":{"docs":{},"密":{"docs":{},"码":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"证":{"docs":{},"书":{"docs":{},"—":{"docs":{},"—":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}},"流":{"docs":{},"程":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}},"钥":{"docs":{},"存":{"docs":{},"储":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"库":{"docs":{},"的":{"docs":{},"位":{"docs":{},"置":{"docs":{},"，":{"docs":{},"它":{"docs":{},"只":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"常":{"docs":{},"规":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{},"连":{"docs":{},"接":{"docs":{},"进":{"docs":{},"行":{"docs":{},"全":{"docs":{},"面":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"，":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"将":{"docs":{},"被":{"docs":{},"评":{"docs":{},"定":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{},"o":{"docs":{},"n":{"docs":{},"，":{"docs":{},"y":{"docs":{},"e":{"docs":{},"s":{"docs":{},"，":{"1":{"docs":{},"，":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"确":{"docs":{},"定":{"docs":{},"连":{"docs":{},"接":{"docs":{},"往":{"docs":{},"返":{"docs":{},"时":{"docs":{},"间":{"docs":{},"或":{"docs":{},"检":{"docs":{},"查":{"docs":{},"连":{"docs":{},"接":{"docs":{},"有":{"docs":{},"效":{"docs":{},"性":{"docs":{},"很":{"docs":{},"有":{"docs":{},"用":{"docs":{},"：":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"需":{"docs":{},"要":{"docs":{},"完":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"这":{"docs":{},"点":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"正":{"docs":{},"在":{"docs":{},"接":{"docs":{},"收":{"docs":{},"响":{"docs":{},"应":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"连":{"docs":{},"接":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"一":{"docs":{},"段":{"docs":{},"时":{"docs":{},"间":{"docs":{},"内":{"docs":{},"没":{"docs":{},"有":{"docs":{},"动":{"docs":{},"作":{"docs":{},"，":{"docs":{},"则":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"会":{"docs":{},"发":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"输":{"docs":{},"入":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"通":{"docs":{},"过":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"出":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"通":{"docs":{},"过":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"端":{"docs":{},"发":{"docs":{},"送":{"docs":{},"给":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"些":{"docs":{},"基":{"docs":{},"于":{"docs":{},"j":{"docs":{},"w":{"docs":{},"t":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}},"任":{"docs":{},"意":{"docs":{},"以":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"大":{"docs":{},"多":{"docs":{},"数":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"，":{"docs":{},"您":{"docs":{},"应":{"docs":{},"该":{"docs":{},"不":{"docs":{},"希":{"docs":{},"望":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"没":{"docs":{},"有":{"docs":{},"提":{"docs":{},"供":{"docs":{},"原":{"docs":{},"生":{"docs":{},"的":{"docs":{},"跨":{"docs":{},"域":{"docs":{},"通":{"docs":{},"信":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"，":{"docs":{},"会":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"，":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"以":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"消":{"docs":{},"费":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"生":{"docs":{},"产":{"docs":{},"者":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"，":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"提":{"docs":{},"供":{"docs":{},"发":{"docs":{},"送":{"docs":{},"信":{"docs":{},"息":{"docs":{},"到":{"docs":{},"指":{"docs":{},"定":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}},"已":{"docs":{},"经":{"docs":{},"认":{"docs":{},"证":{"docs":{},"过":{"docs":{},"的":{"docs":{},"用":{"docs":{},"户":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"l":{"docs":{},"方":{"docs":{},"法":{"docs":{},"获":{"docs":{},"取":{"docs":{},"用":{"docs":{},"户":{"docs":{},"的":{"docs":{},"凭":{"docs":{},"证":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"获":{"docs":{},"取":{"docs":{},"凭":{"docs":{},"证":{"docs":{},"信":{"docs":{},"息":{"docs":{},"的":{"docs":{},"内":{"docs":{},"容":{"docs":{},"同":{"docs":{},"样":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"底":{"docs":{},"层":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"执":{"docs":{},"行":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}},"阻":{"docs":{},"塞":{"docs":{},"型":{"docs":{},"的":{"docs":{},"可":{"docs":{},"调":{"docs":{},"度":{"docs":{},"操":{"docs":{},"作":{"docs":{},"（":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"需":{"docs":{},"使":{"docs":{},"用":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}},"包":{"docs":{},"进":{"docs":{},"行":{"docs":{},"处":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"应":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"发":{"docs":{},"送":{"docs":{},"或":{"docs":{},"发":{"docs":{},"布":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"头":{"docs":{},"信":{"docs":{},"息":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"如":{"docs":{},"果":{"docs":{},"有":{"docs":{},"）":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"以":{"docs":{},"此":{"docs":{},"类":{"docs":{},"推":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}},"版":{"docs":{},"本":{"docs":{},"：":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}}}}}}}}}}},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"进":{"docs":{},"行":{"docs":{},"处":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"此":{"docs":{},"并":{"docs":{},"不":{"docs":{},"关":{"docs":{},"心":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"用":{"docs":{},"单":{"docs":{},"个":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"区":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"等":{"docs":{},"连":{"docs":{},"接":{"docs":{},"重":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"象":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.000557361820715281},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"该":{"docs":{},"对":{"docs":{},"象":{"docs":{},"随":{"docs":{},"后":{"docs":{},"可":{"docs":{},"用":{"docs":{},"于":{"docs":{},"撤":{"docs":{},"销":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"、":{"docs":{},"或":{"docs":{},"将":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"用":{"docs":{},"作":{"docs":{},"流":{"docs":{},"式":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"它":{"docs":{},"不":{"docs":{},"仅":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"这":{"docs":{},"也":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"基":{"docs":{},"于":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"里":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"信":{"docs":{},"息":{"docs":{},"来":{"docs":{},"渲":{"docs":{},"染":{"docs":{},"模":{"docs":{},"板":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"请":{"docs":{},"求":{"docs":{},"、":{"docs":{},"响":{"docs":{},"应":{"docs":{},"、":{"docs":{},"会":{"docs":{},"话":{"docs":{},"或":{"docs":{},"者":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"类":{"docs":{},"似":{"docs":{},"套":{"docs":{},"接":{"docs":{},"字":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"向":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"样":{"docs":{},"，":{"docs":{},"您":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}},"这":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"如":{"docs":{},"果":{"docs":{},"端":{"docs":{},"口":{"docs":{},"监":{"docs":{},"听":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"者":{"docs":{},"将":{"docs":{},"会":{"docs":{},"得":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"调":{"docs":{},"用":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"创":{"docs":{},"建":{"docs":{},"这":{"docs":{},"样":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"上":{"docs":{},"注":{"docs":{},"册":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"调":{"docs":{},"用":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"基":{"docs":{},"础":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}},"之":{"docs":{},"前":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"间":{"docs":{},"共":{"docs":{},"享":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"。":{"docs":{},"但":{"docs":{},"有":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"却":{"docs":{},"恰":{"docs":{},"恰":{"docs":{},"相":{"docs":{},"反":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"共":{"docs":{},"享":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}},"也":{"docs":{},"支":{"docs":{},"持":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"作":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"最":{"docs":{},"多":{"6":{"docs":{},"个":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"传":{"docs":{},"入":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"docs":{}}}},"，":{"docs":{},"并":{"docs":{},"返":{"docs":{},"回":{"docs":{},"预":{"docs":{},"期":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"​":{"docs":{},"​":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"被":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"安":{"docs":{},"全":{"docs":{},"地":{"docs":{},"访":{"docs":{},"问":{"docs":{},"，":{"docs":{},"但":{"docs":{},"在":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"中":{"docs":{},"访":{"docs":{},"问":{"docs":{},"它":{"docs":{},"们":{"docs":{},"时":{"docs":{},"，":{"docs":{},"性":{"docs":{},"能":{"docs":{},"才":{"docs":{},"是":{"docs":{},"最":{"docs":{},"优":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"/":{"docs":{},"反":{"docs":{},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"为":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"的":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"轻":{"docs":{},"松":{"docs":{},"地":{"docs":{},"转":{"docs":{},"换":{"docs":{},"为":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}}}}}}}},"和":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"它":{"docs":{},"们":{"docs":{},"将":{"docs":{},"共":{"docs":{},"享":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}}},"基":{"docs":{},"本":{"docs":{},"上":{"docs":{},"只":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"并":{"docs":{},"填":{"docs":{},"充":{"docs":{},"字":{"docs":{},"段":{"docs":{},"值":{"docs":{},"。":{"docs":{},"如":{"docs":{},"下":{"docs":{},"所":{"docs":{},"示":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"或":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"打":{"docs":{},"开":{"docs":{},"并":{"docs":{},"其":{"docs":{},"传":{"docs":{},"送":{"docs":{},"到":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"存":{"docs":{},"储":{"docs":{},"和":{"docs":{},"读":{"docs":{},"取":{"docs":{},"共":{"docs":{},"享":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"举":{"docs":{},"例":{"docs":{},"来":{"docs":{},"说":{"docs":{},"，":{"docs":{},"它":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"将":{"docs":{},"数":{"docs":{},"据":{"docs":{},"传":{"docs":{},"递":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"许":{"docs":{},"多":{"docs":{},"操":{"docs":{},"作":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"时":{"docs":{},"指":{"docs":{},"定":{"docs":{},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"，":{"docs":{},"不":{"docs":{},"要":{"docs":{},"忘":{"docs":{},"记":{"docs":{},"关":{"docs":{},"掉":{"docs":{},"它":{"docs":{},"（":{"docs":{},"通":{"docs":{},"过":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}},"来":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"现":{"docs":{},"文":{"docs":{},"件":{"docs":{},"读":{"docs":{},"写":{"docs":{},"。":{"docs":{},"从":{"docs":{},"现":{"docs":{},"在":{"docs":{},"开":{"docs":{},"始":{"docs":{},"，":{"docs":{},"流":{"docs":{},"不":{"docs":{},"再":{"docs":{},"与":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"通":{"docs":{},"常":{"docs":{},"来":{"docs":{},"说":{"docs":{},"这":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"配":{"docs":{},"置":{"docs":{},"选":{"docs":{},"项":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"描":{"docs":{},"述":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"可":{"docs":{},"以":{"docs":{},"获":{"docs":{},"得":{"docs":{},"名":{"docs":{},"称":{"docs":{},"、":{"docs":{},"文":{"docs":{},"件":{"docs":{},"名":{"docs":{},"、":{"docs":{},"大":{"docs":{},"小":{"docs":{},"等":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"表":{"docs":{},"述":{"docs":{},"的":{"docs":{},"。":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"它":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"名":{"docs":{},"称":{"docs":{},"、":{"docs":{},"值":{"docs":{},"、":{"docs":{},"域":{"docs":{},"名":{"docs":{},"、":{"docs":{},"路":{"docs":{},"径":{"docs":{},"或":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"进":{"docs":{},"行":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"上":{"docs":{},"述":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"若":{"docs":{},"干":{"docs":{},"选":{"docs":{},"项":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"这":{"docs":{},"样":{"docs":{},"一":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"要":{"docs":{},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"同":{"docs":{},"时":{"docs":{},"指":{"docs":{},"定":{"docs":{},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"字":{"docs":{},"段":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"几":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}},"时":{"docs":{},"候":{"docs":{},"就":{"docs":{},"直":{"docs":{},"接":{"docs":{},"指":{"docs":{},"定":{"docs":{},"它":{"docs":{},"：":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"：":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}},"每":{"docs":{},"个":{"docs":{},"部":{"docs":{},"分":{"docs":{},"都":{"docs":{},"包":{"docs":{},"装":{"docs":{},"着":{"docs":{},"属":{"docs":{},"于":{"docs":{},"着":{"docs":{},"这":{"docs":{},"部":{"docs":{},"分":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"不":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"部":{"docs":{},"分":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"以":{"docs":{},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{},"顶":{"docs":{},"级":{"docs":{},"对":{"docs":{},"象":{"docs":{},"部":{"docs":{},"分":{"docs":{},"展":{"docs":{},"现":{"docs":{},"：":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"写":{"docs":{},"流":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"读":{"docs":{},"流":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"读":{"docs":{},"到":{"docs":{},"的":{"docs":{},"是":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},"一":{"docs":{},"次":{"docs":{},"性":{"docs":{},"回":{"docs":{},"调":{"docs":{},"，":{"docs":{},"请":{"docs":{},"求":{"docs":{},"错":{"docs":{},"误":{"docs":{},"同":{"docs":{},"样":{"docs":{},"会":{"docs":{},"在":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"（":{"docs":{},"就":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}},"直":{"docs":{},"接":{"docs":{},"设":{"docs":{},"置":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"编":{"docs":{},"码":{"docs":{},"成":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"获":{"docs":{},"取":{"docs":{},"值":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"配":{"docs":{},"置":{"docs":{},"来":{"docs":{},"配":{"docs":{},"置":{"docs":{},"代":{"docs":{},"理":{"docs":{},"（":{"docs":{},"包":{"docs":{},"括":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"型":{"docs":{},"、":{"docs":{},"主":{"docs":{},"机":{"docs":{},"名":{"docs":{},"、":{"docs":{},"端":{"docs":{},"口":{"docs":{},"和":{"docs":{},"可":{"docs":{},"选":{"docs":{},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"和":{"docs":{},"密":{"docs":{},"码":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"间":{"docs":{},"的":{"docs":{},"映":{"docs":{},"射":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"（":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"）":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"返":{"docs":{},"回":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"下":{"docs":{},"边":{"docs":{},"代":{"docs":{},"码":{"docs":{},"读":{"docs":{},"取":{"docs":{},"数":{"docs":{},"据":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"进":{"docs":{},"行":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}},"参":{"docs":{},"考":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"比":{"docs":{},"如":{"docs":{},"在":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}},"用":{"docs":{},"于":{"docs":{},"传":{"docs":{},"递":{"docs":{},"参":{"docs":{},"数":{"docs":{},"）":{"docs":{},"或":{"docs":{},"参":{"docs":{},"数":{"docs":{},"值":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}}}}}}}}}}},"包":{"docs":{},"含":{"docs":{},"额":{"docs":{},"外":{"docs":{},"的":{"docs":{},"重":{"docs":{},"要":{"docs":{},"信":{"docs":{},"息":{"docs":{},"）":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"方":{"docs":{},"便":{"docs":{},"起":{"docs":{},"见":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"领":{"docs":{},"域":{"docs":{},"中":{"docs":{},"您":{"docs":{},"做":{"docs":{},"不":{"docs":{},"了":{"docs":{},"太":{"docs":{},"多":{"docs":{},"的":{"docs":{},"事":{"docs":{},"情":{"docs":{},"。":{"docs":{},"它":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"下":{"docs":{},"所":{"docs":{},"示":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"果":{"docs":{},"没":{"docs":{},"有":{"docs":{},"则":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"。":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"检":{"docs":{},"查":{"docs":{},"获":{"docs":{},"取":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"可":{"docs":{},"直":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{},"该":{"docs":{},"内":{"docs":{},"置":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"无":{"docs":{},"需":{"docs":{},"重":{"docs":{},"新":{"docs":{},"创":{"docs":{},"建":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"编":{"docs":{},"程":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"的":{"docs":{},"相":{"docs":{},"关":{"docs":{},"方":{"docs":{},"法":{"docs":{},"为":{"docs":{},"用":{"docs":{},"户":{"docs":{},"授":{"docs":{},"权":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"然":{"docs":{},"后":{"docs":{},"将":{"docs":{},"引":{"docs":{},"用":{"docs":{},"传":{"docs":{},"进":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"里":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"增":{"docs":{},"加":{"docs":{},"、":{"docs":{},"设":{"docs":{},"置":{"docs":{},"以":{"docs":{},"及":{"docs":{},"删":{"docs":{},"除":{"docs":{},"头":{"docs":{},"属":{"docs":{},"性":{"docs":{},"操":{"docs":{},"作":{"docs":{},"的":{"docs":{},"入":{"docs":{},"口":{"docs":{},"。":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"头":{"docs":{},"的":{"docs":{},"某":{"docs":{},"些":{"docs":{},"特":{"docs":{},"定":{"docs":{},"属":{"docs":{},"性":{"docs":{},"允":{"docs":{},"许":{"docs":{},"设":{"docs":{},"置":{"docs":{},"多":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"必":{"docs":{},"须":{"docs":{},"包":{"docs":{},"含":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"会":{"docs":{},"在":{"docs":{},"这":{"docs":{},"些":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}},"但":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"是":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"。":{"docs":{},"这":{"docs":{},"时":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725}}}}}}}}}}}}}}}},"且":{"docs":{},"下":{"docs":{},"标":{"docs":{},"为":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}},"它":{"docs":{},"的":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}}},"这":{"docs":{},"个":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{},"的":{"docs":{},"作":{"docs":{},"用":{"docs":{},"是":{"docs":{},"将":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}},"里":{"docs":{},"面":{"docs":{},"需":{"docs":{},"要":{"docs":{},"包":{"docs":{},"含":{"docs":{},"操":{"docs":{},"作":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"，":{"docs":{},"则":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"成":{"docs":{},"功":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}},"，":{"docs":{},"有":{"docs":{},"以":{"docs":{},"下":{"docs":{},"这":{"docs":{},"些":{"docs":{},"参":{"docs":{},"数":{"docs":{},"：":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}},"变":{"docs":{},"得":{"docs":{},"更":{"docs":{},"加":{"docs":{},"便":{"docs":{},"捷":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}},"共":{"docs":{},"享":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"对":{"docs":{},"象":{"docs":{},"维":{"docs":{},"护":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"引":{"docs":{},"用":{"docs":{},"计":{"docs":{},"数":{"docs":{},"器":{"docs":{},"。":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"此":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"个":{"docs":{},"引":{"docs":{},"用":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"后":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"也":{"docs":{},"就":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"了":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"后":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}},"拥":{"docs":{},"有":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"采":{"docs":{},"用":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"它":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"它":{"docs":{},"们":{"docs":{},"要":{"docs":{},"与":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"进":{"docs":{},"行":{"docs":{},"交":{"docs":{},"互":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"列":{"docs":{},"表":{"docs":{},"（":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"）":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"能":{"docs":{},"让":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}},"以":{"docs":{},"在":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0064794816414686825}}}},"）":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"服":{"docs":{},"务":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"它":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"服":{"docs":{},"务":{"docs":{},"名":{"docs":{},"称":{"docs":{},"、":{"docs":{},"一":{"docs":{},"些":{"docs":{},"元":{"docs":{},"数":{"docs":{},"据":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"描":{"docs":{},"述":{"docs":{},"服":{"docs":{},"务":{"docs":{},"所":{"docs":{},"在":{"docs":{},"位":{"docs":{},"置":{"docs":{},"的":{"docs":{},"位":{"docs":{},"置":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},")":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"取":{"docs":{},"出":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}},"传":{"docs":{},"入":{"docs":{},"，":{"docs":{},"作":{"docs":{},"为":{"docs":{},"全":{"docs":{},"局":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}}}}}}}}},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"进":{"docs":{},"行":{"docs":{},"配":{"docs":{},"置":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.004570383912248629}}}}}}}}}}},"寻":{"docs":{},"址":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"小":{"docs":{},"而":{"docs":{},"轻":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"只":{"docs":{},"使":{"docs":{},"用":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"部":{"docs":{},"分":{"docs":{},"。":{"docs":{},"它":{"docs":{},"可":{"docs":{},"整":{"docs":{},"体":{"docs":{},"嵌":{"docs":{},"入":{"docs":{},"现":{"docs":{},"存":{"docs":{},"应":{"docs":{},"用":{"docs":{},"中":{"docs":{},"。":{"docs":{},"我":{"docs":{},"们":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"强":{"docs":{},"迫":{"docs":{},"您":{"docs":{},"用":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"构":{"docs":{},"造":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"尝":{"docs":{},"试":{"docs":{},"对":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"进":{"docs":{},"行":{"docs":{},"反":{"docs":{},"向":{"docs":{},"查":{"docs":{},"找":{"docs":{},"，":{"docs":{},"这":{"docs":{},"与":{"docs":{},"解":{"docs":{},"析":{"docs":{},"p":{"docs":{},"t":{"docs":{},"r":{"docs":{},"记":{"docs":{},"录":{"docs":{},"类":{"docs":{},"似":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"只":{"docs":{},"传":{"docs":{},"递":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"有":{"docs":{},"效":{"docs":{},"的":{"docs":{},"p":{"docs":{},"t":{"docs":{},"r":{"docs":{},"查":{"docs":{},"询":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"查":{"docs":{},"找":{"docs":{},"给":{"docs":{},"定":{"docs":{},"名":{"docs":{},"称":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"a":{"docs":{},"（":{"docs":{},"i":{"docs":{},"p":{"docs":{},"v":{"4":{"docs":{},"）":{"docs":{},"记":{"docs":{},"录":{"docs":{},"。":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"（":{"docs":{},"记":{"docs":{},"录":{"docs":{},"）":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"它":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"方":{"docs":{},"式":{"docs":{},"与":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{},"n":{"docs":{},"s":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"u":{"docs":{},"p":{"docs":{},"类":{"docs":{},"似":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}},"解":{"docs":{},"析":{"docs":{},"给":{"docs":{},"定":{"docs":{},"名":{"docs":{},"称":{"docs":{},"的":{"docs":{},"p":{"docs":{},"t":{"docs":{},"r":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"p":{"docs":{},"t":{"docs":{},"r":{"docs":{},"记":{"docs":{},"录":{"docs":{},"将":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"映":{"docs":{},"射":{"docs":{},"到":{"docs":{},"名":{"docs":{},"称":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"a":{"docs":{},"a":{"docs":{},"a":{"docs":{},"a":{"docs":{},"（":{"docs":{},"i":{"docs":{},"p":{"docs":{},"v":{"6":{"docs":{},"）":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"这":{"docs":{},"与":{"docs":{},"在":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"x":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"类":{"docs":{},"似":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}},"（":{"docs":{},"i":{"docs":{},"p":{"docs":{},"v":{"4":{"docs":{},"）":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"这":{"docs":{},"与":{"docs":{},"在":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"x":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"类":{"docs":{},"似":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}},"c":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"这":{"docs":{},"与":{"docs":{},"在":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"x":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"类":{"docs":{},"似":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"x":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"m":{"docs":{},"x":{"docs":{},"记":{"docs":{},"录":{"docs":{},"用":{"docs":{},"于":{"docs":{},"定":{"docs":{},"义":{"docs":{},"哪":{"docs":{},"个":{"docs":{},"邮":{"docs":{},"件":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"接":{"docs":{},"受":{"docs":{},"给":{"docs":{},"定":{"docs":{},"域":{"docs":{},"的":{"docs":{},"电":{"docs":{},"子":{"docs":{},"邮":{"docs":{},"件":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"s":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"n":{"docs":{},"s":{"docs":{},"记":{"docs":{},"录":{"docs":{},"指":{"docs":{},"定":{"docs":{},"哪":{"docs":{},"个":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"托":{"docs":{},"管":{"docs":{},"给":{"docs":{},"定":{"docs":{},"域":{"docs":{},"的":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"v":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"s":{"docs":{},"r":{"docs":{},"v":{"docs":{},"记":{"docs":{},"录":{"docs":{},"用":{"docs":{},"于":{"docs":{},"定":{"docs":{},"义":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"口":{"docs":{},"和":{"docs":{},"主":{"docs":{},"机":{"docs":{},"名":{"docs":{},"等":{"docs":{},"额":{"docs":{},"外":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{},"一":{"docs":{},"些":{"docs":{},"协":{"docs":{},"议":{"docs":{},"需":{"docs":{},"要":{"docs":{},"这":{"docs":{},"个":{"docs":{},"额":{"docs":{},"外":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"记":{"docs":{},"录":{"docs":{},"通":{"docs":{},"常":{"docs":{},"用":{"docs":{},"于":{"docs":{},"定":{"docs":{},"义":{"docs":{},"域":{"docs":{},"的":{"docs":{},"额":{"docs":{},"外":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"尽":{"docs":{},"力":{"docs":{},"传":{"docs":{},"输":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"(":{"docs":{},"b":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"管":{"docs":{},"我":{"docs":{},"们":{"docs":{},"已":{"docs":{},"经":{"docs":{},"知":{"docs":{},"道":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}},"自":{"docs":{},"身":{"docs":{},"并":{"docs":{},"不":{"docs":{},"要":{"docs":{},"求":{"docs":{},"使":{"docs":{},"用":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"许":{"docs":{},"可":{"docs":{},"模":{"docs":{},"型":{"docs":{},"（":{"docs":{},"它":{"docs":{},"本":{"docs":{},"身":{"docs":{},"只":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"不":{"docs":{},"透":{"docs":{},"明":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"）":{"docs":{},"，":{"docs":{},"但":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"认":{"docs":{},"证":{"docs":{},"中":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"比":{"docs":{},"较":{"docs":{},"熟":{"docs":{},"悉":{"docs":{},"的":{"docs":{},"：":{"docs":{},"用":{"docs":{},"户":{"docs":{},"/":{"docs":{},"角":{"docs":{},"色":{"docs":{},"/":{"docs":{},"许":{"docs":{},"可":{"docs":{},"模":{"docs":{},"型":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"在":{"docs":{},"应":{"docs":{},"用":{"docs":{},"里":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"或":{"docs":{},"者":{"docs":{},"多":{"docs":{},"个":{"docs":{},"角":{"docs":{},"色":{"docs":{},"，":{"docs":{},"而":{"docs":{},"一":{"docs":{},"个":{"docs":{},"角":{"docs":{},"色":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"或":{"docs":{},"者":{"docs":{},"多":{"docs":{},"个":{"docs":{},"许":{"docs":{},"可":{"docs":{},"。":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"屏":{"docs":{},"蔽":{"docs":{},"多":{"docs":{},"播":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"属":{"docs":{},"性":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"值":{"docs":{},"为":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}},"链":{"docs":{},"接":{"docs":{},"着":{"docs":{},"。":{"docs":{},"一":{"docs":{},"种":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"遍":{"docs":{},"历":{"docs":{},"所":{"docs":{},"有":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"致":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"中":{"docs":{},"记":{"docs":{},"录":{"docs":{},"了":{"docs":{},"事":{"docs":{},"件":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"类":{"docs":{},"型":{"docs":{},"分":{"docs":{},"为":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"和":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"i":{"docs":{},"d":{"docs":{},"（":{"docs":{},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"或":{"docs":{},"节":{"docs":{},"点":{"docs":{},"i":{"docs":{},"d":{"docs":{},"）":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"信":{"docs":{},"息":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}},"，":{"docs":{},"配":{"docs":{},"置":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"扫":{"docs":{},"描":{"docs":{},"的":{"docs":{},"频":{"docs":{},"率":{"docs":{},"，":{"docs":{},"扫":{"docs":{},"描":{"docs":{},"的":{"docs":{},"单":{"docs":{},"位":{"docs":{},"是":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"（":{"docs":{},"m":{"docs":{},"s":{"docs":{},"）":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}},"为":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}},"包":{"docs":{},"含":{"docs":{},"连":{"docs":{},"接":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}},"进":{"docs":{},"行":{"docs":{},"配":{"docs":{},"置":{"docs":{},"（":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}},"工":{"docs":{},"作":{"docs":{},"，":{"docs":{},"如":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"原":{"docs":{},"理":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}},"程":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}},"厂":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"已":{"docs":{},"经":{"docs":{},"是":{"docs":{},"失":{"docs":{},"败":{"docs":{},"状":{"docs":{},"态":{"docs":{},"并":{"docs":{},"且":{"docs":{},"包":{"docs":{},"装":{"docs":{},"着":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}},"带":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"的":{"docs":{},"非":{"docs":{},"分":{"docs":{},"块":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"超":{"docs":{},"时":{"docs":{},"的":{"docs":{},"发":{"docs":{},"送":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"帧":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}},"不":{"docs":{},"受":{"docs":{},"流":{"docs":{},"量":{"docs":{},"控":{"docs":{},"制":{"docs":{},"限":{"docs":{},"制":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"之":{"docs":{},"前":{"docs":{},"完":{"docs":{},"成":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"到":{"docs":{},"远":{"docs":{},"程":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"，":{"docs":{},"要":{"docs":{},"求":{"docs":{},"其":{"docs":{},"停":{"docs":{},"止":{"docs":{},"创":{"docs":{},"建":{"docs":{},"流":{"docs":{},"：":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"将":{"docs":{},"停":{"docs":{},"止":{"docs":{},"发":{"docs":{},"送":{"docs":{},"新":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"将":{"docs":{},"停":{"docs":{},"止":{"docs":{},"推":{"docs":{},"送":{"docs":{},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{},"发":{"docs":{},"送":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"端":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"后":{"docs":{},"，":{"docs":{},"连":{"docs":{},"接":{"docs":{},"将":{"docs":{},"等":{"docs":{},"待":{"docs":{},"一":{"docs":{},"段":{"docs":{},"时":{"docs":{},"间":{"docs":{},"（":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"3":{"0":{"docs":{},"秒":{"docs":{},"）":{"docs":{},"，":{"docs":{},"直":{"docs":{},"到":{"docs":{},"所":{"docs":{},"有":{"docs":{},"当":{"docs":{},"前":{"docs":{},"流":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"和":{"docs":{},"连":{"docs":{},"接":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"将":{"docs":{},"会":{"docs":{},"在":{"docs":{},"连":{"docs":{},"接":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"之":{"docs":{},"前":{"docs":{},"被":{"docs":{},"发":{"docs":{},"送":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"时":{"docs":{},"发":{"docs":{},"送":{"docs":{},"通":{"docs":{},"知":{"docs":{},"调":{"docs":{},"用":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"，":{"docs":{},"和":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"主":{"docs":{},"要":{"docs":{},"的":{"docs":{},"区":{"docs":{},"别":{"docs":{},"在":{"docs":{},"于":{"docs":{},"它":{"docs":{},"将":{"docs":{},"只":{"docs":{},"是":{"docs":{},"告":{"docs":{},"诉":{"docs":{},"远":{"docs":{},"程":{"docs":{},"连":{"docs":{},"接":{"docs":{},"停":{"docs":{},"止":{"docs":{},"创":{"docs":{},"建":{"docs":{},"新":{"docs":{},"流":{"docs":{},"，":{"docs":{},"而":{"docs":{},"没":{"docs":{},"有":{"docs":{},"计":{"docs":{},"划":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"连":{"docs":{},"接":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"并":{"docs":{},"且":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"完":{"docs":{},"成":{"docs":{},"了":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"行":{"docs":{},"表":{"docs":{},"示":{"docs":{},"工":{"docs":{},"厂":{"docs":{},"类":{"docs":{},"的":{"docs":{},"完":{"docs":{},"全":{"docs":{},"限":{"docs":{},"定":{"docs":{},"名":{"docs":{},"称":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"读":{"docs":{},"取":{"docs":{},"它":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},"值":{"docs":{},"为":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},"的":{"docs":{},"记":{"docs":{},"录":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}},"能":{"docs":{},"够":{"docs":{},"读":{"docs":{},"取":{"docs":{},"所":{"docs":{},"选":{"docs":{},"择":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"空":{"docs":{},"间":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}},"占":{"docs":{},"用":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"发":{"docs":{},"合":{"docs":{},"并":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"在":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"最":{"docs":{},"后":{"docs":{},"发":{"docs":{},"出":{"docs":{},"成":{"docs":{},"功":{"docs":{},"或":{"docs":{},"失":{"docs":{},"败":{"docs":{},"的":{"docs":{},"信":{"docs":{},"号":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"它":{"docs":{},"的":{"docs":{},"大":{"docs":{},"小":{"docs":{},"。":{"docs":{},"这":{"docs":{},"使":{"docs":{},"得":{"docs":{},"这":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{},"常":{"docs":{},"用":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"由":{"docs":{},"其":{"docs":{},"索":{"docs":{},"引":{"docs":{},"标":{"docs":{},"识":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"在":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"写":{"docs":{},"入":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"查":{"docs":{},"找":{"docs":{},"会":{"docs":{},"话":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"您":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"自":{"docs":{},"己":{"docs":{},"来":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"包":{"docs":{},"含":{"docs":{},"部":{"docs":{},"署":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}},"是":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}},"应":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"中":{"docs":{},"处":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"安":{"docs":{},"全":{"docs":{},"调":{"docs":{},"用":{"docs":{},"\"":{"docs":{},"传":{"docs":{},"统":{"docs":{},"\"":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"记":{"docs":{},"录":{"docs":{},"日":{"docs":{},"志":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"层":{"docs":{},"协":{"docs":{},"议":{"docs":{},"协":{"docs":{},"商":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"需":{"docs":{},"要":{"docs":{},"添":{"docs":{},"加":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"构":{"docs":{},"建":{"docs":{},"模":{"docs":{},"块":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"瑞":{"docs":{},"士":{"docs":{},"军":{"docs":{},"刀":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"方":{"docs":{},"式":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}},"程":{"docs":{},"序":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"时":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"是":{"docs":{},"很":{"docs":{},"常":{"docs":{},"见":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"我":{"docs":{},"们":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"p":{"docs":{},"u":{"docs":{},"m":{"docs":{},"p":{"docs":{},"的":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"类":{"docs":{},"，":{"docs":{},"它":{"docs":{},"为":{"docs":{},"您":{"docs":{},"完":{"docs":{},"成":{"docs":{},"所":{"docs":{},"有":{"docs":{},"这":{"docs":{},"些":{"docs":{},"艰":{"docs":{},"苦":{"docs":{},"的":{"docs":{},"工":{"docs":{},"作":{"docs":{},"。":{"docs":{},"您":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"给":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"强":{"docs":{},"烈":{"docs":{},"建":{"docs":{},"议":{"docs":{},"您":{"docs":{},"直":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"但":{"docs":{},"是":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"首":{"docs":{},"先":{"docs":{},"部":{"docs":{},"署":{"docs":{},"它":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"。":{"docs":{},"但":{"docs":{},"有":{"docs":{},"些":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"要":{"docs":{},"求":{"docs":{},"必":{"docs":{},"须":{"docs":{},"从":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"打":{"docs":{},"包":{"docs":{},"成":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}},"通":{"docs":{},"过":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"与":{"docs":{},"任":{"docs":{},"何":{"docs":{},"支":{"docs":{},"持":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}},"）":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"到":{"docs":{},"多":{"docs":{},"核":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"，":{"docs":{},"则":{"docs":{},"需":{"docs":{},"要":{"docs":{},"启":{"docs":{},"动":{"docs":{},"并":{"docs":{},"且":{"docs":{},"管":{"docs":{},"理":{"docs":{},"多":{"docs":{},"个":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"进":{"docs":{},"程":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"、":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"实":{"docs":{},"时":{"docs":{},"的":{"docs":{},"（":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"推":{"docs":{},"送":{"docs":{},"）":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"应":{"docs":{},"用":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"选":{"docs":{},"择":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"您":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"所":{"docs":{},"有":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"里":{"docs":{},"设":{"docs":{},"置":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"或":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"您":{"docs":{},"所":{"docs":{},"能":{"docs":{},"想":{"docs":{},"到":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"加":{"docs":{},"入":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"：":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"进":{"docs":{},"行":{"docs":{},"数":{"docs":{},"据":{"docs":{},"持":{"docs":{},"久":{"docs":{},"化":{"docs":{},"时":{"docs":{},"的":{"docs":{},"最":{"docs":{},"佳":{"docs":{},"选":{"docs":{},"择":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}},"能":{"docs":{},"够":{"docs":{},"以":{"docs":{},"异":{"docs":{},"步":{"docs":{},"、":{"docs":{},"非":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"访":{"docs":{},"问":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"以":{"docs":{},"及":{"docs":{},"使":{"docs":{},"用":{"docs":{},"；":{"docs":{},"它":{"docs":{},"配":{"docs":{},"置":{"docs":{},"了":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}},"答":{"docs":{},"消":{"docs":{},"息":{"docs":{},"/":{"docs":{},"发":{"docs":{},"送":{"docs":{},"回":{"docs":{},"复":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"该":{"docs":{},"使":{"docs":{},"用":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"异":{"docs":{},"常":{"docs":{},"。":{"docs":{},"幸":{"docs":{},"运":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"步":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},"协":{"docs":{},"调":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"启":{"docs":{},"动":{"docs":{},"和":{"docs":{},"停":{"docs":{},"止":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"地":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"文":{"docs":{},"件":{"docs":{},"访":{"docs":{},"问":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"版":{"docs":{},"本":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"结":{"docs":{},"果":{"docs":{},"支":{"docs":{},"持":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"r":{"docs":{},"p":{"docs":{},"c":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}},"接":{"docs":{},"口":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"仅":{"docs":{},"通":{"docs":{},"知":{"docs":{},"调":{"docs":{},"用":{"docs":{},"是":{"docs":{},"否":{"docs":{},"完":{"docs":{},"成":{"docs":{},"，":{"docs":{},"不":{"docs":{},"返":{"docs":{},"回":{"docs":{},"结":{"docs":{},"果":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}},"包":{"docs":{},"含":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"结":{"docs":{},"果":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}},"引":{"docs":{},"擎":{"docs":{},"实":{"docs":{},"现":{"docs":{},"可":{"docs":{},"以":{"docs":{},"配":{"docs":{},"置":{"docs":{},"为":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"选":{"docs":{},"项":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{},":":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"入":{"docs":{},"的":{"docs":{},"新":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"用":{"docs":{},"：":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"/":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"s":{"docs":{},"/":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374},"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"强":{"docs":{},"制":{"docs":{},"使":{"docs":{},"用":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"4":{"docs":{},"j":{"docs":{},"日":{"docs":{},"志":{"docs":{},"记":{"docs":{},"录":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"docs":{}}}}}}},"烈":{"docs":{},"建":{"docs":{},"议":{"docs":{},"在":{"docs":{},"存":{"docs":{},"储":{"docs":{},"密":{"docs":{},"码":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{},"哈":{"docs":{},"希":{"docs":{},"算":{"docs":{},"法":{"docs":{},"加":{"docs":{},"密":{"docs":{},"过":{"docs":{},"后":{"docs":{},"保":{"docs":{},"存":{"docs":{},"在":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"中":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"哈":{"docs":{},"希":{"docs":{},"值":{"docs":{},"是":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"这":{"docs":{},"一":{"docs":{},"行":{"docs":{},"记":{"docs":{},"录":{"docs":{},"时":{"docs":{},"基":{"docs":{},"于":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"值":{"docs":{},"计":{"docs":{},"算":{"docs":{},"的":{"docs":{},"，":{"docs":{},"应":{"docs":{},"用":{"docs":{},"中":{"docs":{},"应":{"docs":{},"该":{"docs":{},"使":{"docs":{},"用":{"docs":{},"强":{"docs":{},"壮":{"docs":{},"的":{"docs":{},"密":{"docs":{},"码":{"docs":{},"算":{"docs":{},"法":{"docs":{},"，":{"docs":{},"在":{"docs":{},"存":{"docs":{},"储":{"docs":{},"密":{"docs":{},"码":{"docs":{},"时":{"docs":{},"绝":{"docs":{},"对":{"docs":{},"不":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"明":{"docs":{},"文":{"docs":{},"。":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"“":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"\"":{"docs":{},"值":{"docs":{},"时":{"docs":{},"候":{"docs":{},"使":{"docs":{},"用":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"选":{"docs":{},"项":{"docs":{},"。":{"docs":{},"n":{"docs":{},"o":{"docs":{},"_":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"选":{"docs":{},"项":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"推":{"docs":{},"荐":{"docs":{},"在":{"docs":{},"开":{"docs":{},"发":{"docs":{},"阶":{"docs":{},"段":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"不":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"如":{"docs":{},"此":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"方":{"docs":{},"式":{"docs":{},"也":{"docs":{},"不":{"docs":{},"推":{"docs":{},"荐":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"会":{"docs":{},"导":{"docs":{},"致":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"和":{"docs":{},"密":{"docs":{},"码":{"docs":{},"都":{"docs":{},"存":{"docs":{},"储":{"docs":{},"在":{"docs":{},"了":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"地":{"docs":{},"方":{"docs":{},"！":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"待":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}},"撤":{"docs":{},"销":{"docs":{},"证":{"docs":{},"书":{"docs":{},"颁":{"docs":{},"发":{"docs":{},"机":{"docs":{},"构":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"很":{"docs":{},"像":{"docs":{},"，":{"docs":{},"但":{"docs":{},"它":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"由":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"多":{"docs":{},"时":{"docs":{},"候":{"docs":{},"我":{"docs":{},"们":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"集":{"docs":{},"群":{"docs":{},"范":{"docs":{},"围":{"docs":{},"内":{"docs":{},"维":{"docs":{},"护":{"docs":{},"一":{"docs":{},"个":{"docs":{},"原":{"docs":{},"子":{"docs":{},"计":{"docs":{},"数":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}},"类":{"docs":{},"似":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"容":{"docs":{},"易":{"docs":{},"定":{"docs":{},"位":{"docs":{},"此":{"docs":{},"类":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}},"自":{"docs":{},"然":{"docs":{},"地":{"docs":{},"，":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"错":{"docs":{},"误":{"docs":{},"的":{"docs":{},"网":{"docs":{},"络":{"docs":{},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}}}}}}},"必":{"docs":{},"须":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"为":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"或":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"配":{"docs":{},"置":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"/":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"才":{"docs":{},"能":{"docs":{},"正":{"docs":{},"常":{"docs":{},"工":{"docs":{},"作":{"docs":{},"。":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"/":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"章":{"docs":{},"节":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"详":{"docs":{},"细":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"与":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}},"您":{"docs":{},"不":{"docs":{},"能":{"docs":{},"在":{"docs":{},"您":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"普":{"docs":{},"通":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"里":{"docs":{},"执":{"docs":{},"行":{"docs":{},"这":{"docs":{},"些":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"我":{"docs":{},"们":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"向":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"毕":{"docs":{},"时":{"docs":{},"调":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"之":{"docs":{},"前":{"docs":{},"也":{"docs":{},"许":{"docs":{},"听":{"docs":{},"说":{"docs":{},"过":{"docs":{},"它":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"不":{"docs":{},"设":{"docs":{},"置":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"而":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"以":{"docs":{},"编":{"docs":{},"程":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"在":{"docs":{},"嵌":{"docs":{},"入":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}},"启":{"docs":{},"动":{"docs":{},"裸":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"和":{"docs":{},"调":{"docs":{},"用":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"一":{"docs":{},"样":{"docs":{},"传":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"直":{"docs":{},"接":{"docs":{},"发":{"docs":{},"送":{"docs":{},"故":{"docs":{},"障":{"docs":{},"状":{"docs":{},"态":{"docs":{},"代":{"docs":{},"码":{"docs":{},"来":{"docs":{},"拒":{"docs":{},"绝":{"docs":{},"该":{"docs":{},"请":{"docs":{},"求":{"docs":{},"：":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"应":{"docs":{},"该":{"docs":{},"被":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"或":{"docs":{},"连":{"docs":{},"接":{"docs":{},"应":{"docs":{},"该":{"docs":{},"被":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"（":{"1":{"0":{"0":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"处":{"docs":{},"理":{"docs":{},"事":{"docs":{},"件":{"docs":{},"时":{"docs":{},"修":{"docs":{},"改":{"docs":{},"原":{"docs":{},"始":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"内":{"docs":{},"容":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"修":{"docs":{},"改":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"从":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"发":{"docs":{},"送":{"docs":{},"来":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"，":{"docs":{},"您":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"修":{"docs":{},"改":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"捕":{"docs":{},"捉":{"docs":{},"通":{"docs":{},"过":{"docs":{},"正":{"docs":{},"则":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"路":{"docs":{},"径":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}},"标":{"docs":{},"记":{"docs":{},"您":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"用":{"docs":{},"通":{"docs":{},"配":{"docs":{},"符":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"顶":{"docs":{},"级":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"许":{"docs":{},"注":{"docs":{},"意":{"docs":{},"到":{"docs":{},"前":{"docs":{},"边":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"里":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"流":{"docs":{},"式":{"docs":{},"（":{"docs":{},"f":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"亦":{"docs":{},"可":{"docs":{},"在":{"docs":{},"其":{"docs":{},"它":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"语":{"docs":{},"言":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"配":{"docs":{},"置":{"docs":{},"选":{"docs":{},"项":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}},"会":{"docs":{},"在":{"docs":{},"读":{"docs":{},"取":{"docs":{},"任":{"docs":{},"何":{"docs":{},"正":{"docs":{},"文":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"锁":{"docs":{},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{},"超":{"docs":{},"时":{"docs":{},"，":{"docs":{},"若":{"docs":{},"在":{"docs":{},"超":{"docs":{},"时":{"docs":{},"时":{"docs":{},"间":{"docs":{},"期":{"docs":{},"间":{"docs":{},"无":{"docs":{},"法":{"docs":{},"获":{"docs":{},"取":{"docs":{},"锁":{"docs":{},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"进":{"docs":{},"入":{"docs":{},"失":{"docs":{},"败":{"docs":{},"状":{"docs":{},"态":{"docs":{},"，":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"去":{"docs":{},"处":{"docs":{},"理":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"异":{"docs":{},"常":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"从":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"格":{"docs":{},"式":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"数":{"docs":{},"组":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"一":{"docs":{},"个":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"创":{"docs":{},"建":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0010218300046446818},"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.00746775288526816},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.006839945280437756},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},"i":{"docs":{},"s":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"来":{"docs":{},"检":{"docs":{},"查":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"是":{"docs":{},"否":{"docs":{},"有":{"docs":{},"效":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"下":{"docs":{},"边":{"docs":{},"命":{"docs":{},"令":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"对":{"docs":{},"象":{"docs":{},"回":{"docs":{},"写":{"docs":{},"一":{"docs":{},"个":{"docs":{},"响":{"docs":{},"应":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"值":{"docs":{},"覆":{"docs":{},"盖":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"确":{"docs":{},"保":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"路":{"docs":{},"径":{"docs":{},"或":{"docs":{},"者":{"docs":{},"同":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{},"路":{"docs":{},"径":{"docs":{},"和":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"转":{"docs":{},"发":{"docs":{},"。":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"基":{"docs":{},"于":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"带":{"docs":{},"来":{"docs":{},"安":{"docs":{},"全":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{},"通":{"docs":{},"常":{"docs":{},"安":{"docs":{},"全":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"静":{"docs":{},"态":{"docs":{},"资":{"docs":{},"源":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"像":{"docs":{},"下":{"docs":{},"边":{"docs":{},"代":{"docs":{},"码":{"docs":{},"打":{"docs":{},"开":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"主":{"docs":{},"类":{"docs":{},"并":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"上":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"指":{"docs":{},"定":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"或":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"端":{"docs":{},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"在":{"docs":{},"每":{"docs":{},"次":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"创":{"docs":{},"建":{"docs":{},"连":{"docs":{},"接":{"docs":{},"时":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"将":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"此":{"docs":{},"（":{"docs":{},"文":{"docs":{},"件":{"docs":{},"）":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"行":{"docs":{},"为":{"docs":{},"。":{"docs":{},"文":{"docs":{},"件":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"的":{"docs":{},"路":{"docs":{},"径":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"设":{"docs":{},"置":{"docs":{},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"进":{"docs":{},"行":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"其":{"docs":{},"他":{"docs":{},"语":{"docs":{},"言":{"docs":{},"的":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"来":{"docs":{},"指":{"docs":{},"定":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"进":{"docs":{},"行":{"docs":{},"部":{"docs":{},"署":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{},"若":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"编":{"docs":{},"译":{"docs":{},"的":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"组":{"docs":{},"合":{"docs":{},"上":{"docs":{},"述":{"docs":{},"的":{"docs":{},"路":{"docs":{},"由":{"docs":{},"规":{"docs":{},"则":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"模":{"docs":{},"板":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"渲":{"docs":{},"染":{"docs":{},"错":{"docs":{},"误":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"直":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"看":{"docs":{},"到":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"。":{"docs":{},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"是":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"。":{"docs":{},"创":{"docs":{},"建":{"docs":{},"后":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"置":{"docs":{},"摘":{"docs":{},"要":{"docs":{},"和":{"docs":{},"描":{"docs":{},"述":{"docs":{},"，":{"docs":{},"摘":{"docs":{},"要":{"docs":{},"的":{"docs":{},"目":{"docs":{},"的":{"docs":{},"是":{"docs":{},"简":{"docs":{},"短":{"docs":{},"（":{"docs":{},"一":{"docs":{},"行":{"docs":{},"）":{"docs":{},"，":{"docs":{},"而":{"docs":{},"描":{"docs":{},"述":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"更":{"docs":{},"多":{"docs":{},"细":{"docs":{},"节":{"docs":{},"。":{"docs":{},"每":{"docs":{},"个":{"docs":{},"选":{"docs":{},"项":{"docs":{},"和":{"docs":{},"参":{"docs":{},"数":{"docs":{},"也":{"docs":{},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"和":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"方":{"docs":{},"法":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"对":{"docs":{},"象":{"docs":{},"上":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"r":{"docs":{},"e":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"其":{"docs":{},"中":{"docs":{},"任":{"docs":{},"意":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0009289363678588017},"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0019880715705765406}},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"获":{"docs":{},"取":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"以":{"docs":{},"下":{"docs":{},"命":{"docs":{},"令":{"docs":{},"以":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"运":{"docs":{},"行":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"如":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"开":{"docs":{},"启":{"docs":{},"分":{"docs":{},"块":{"docs":{},"模":{"docs":{},"式":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"调":{"docs":{},"用":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"并":{"docs":{},"释":{"docs":{},"放":{"docs":{},"所":{"docs":{},"有":{"docs":{},"资":{"docs":{},"源":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"时":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"依":{"docs":{},"赖":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"库":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"设":{"docs":{},"置":{"docs":{},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"绑":{"docs":{},"定":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"配":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"对":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"认":{"docs":{},"证":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"配":{"docs":{},"置":{"docs":{},"访":{"docs":{},"问":{"docs":{},"资":{"docs":{},"源":{"docs":{},"所":{"docs":{},"需":{"docs":{},"的":{"docs":{},"权":{"docs":{},"限":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"这":{"docs":{},"段":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"并":{"docs":{},"打":{"docs":{},"开":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"访":{"docs":{},"问":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"向":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0064794816414686825}}},"较":{"docs":{},"长":{"docs":{},"时":{"docs":{},"间":{"docs":{},"的":{"docs":{},"持":{"docs":{},"有":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"对":{"docs":{},"象":{"docs":{},"（":{"docs":{},"比":{"docs":{},"如":{"docs":{},"在":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}},"利":{"docs":{},"用":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"以":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"填":{"docs":{},"充":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"缺":{"docs":{},"省":{"docs":{},"设":{"docs":{},"置":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"通":{"docs":{},"过":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"以":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"具":{"docs":{},"有":{"docs":{},"默":{"docs":{},"认":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"每":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"单":{"docs":{},"独":{"docs":{},"设":{"docs":{},"置":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"用":{"docs":{},"以":{"docs":{},"下":{"docs":{},"链":{"docs":{},"式":{"docs":{},"方":{"docs":{},"式":{"docs":{},"向":{"docs":{},"请":{"docs":{},"求":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"添":{"docs":{},"加":{"docs":{},"查":{"docs":{},"询":{"docs":{},"参":{"docs":{},"数":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}},"同":{"docs":{},"样":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"编":{"docs":{},"程":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"去":{"docs":{},"注":{"docs":{},"册":{"docs":{},"或":{"docs":{},"注":{"docs":{},"销":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"重":{"docs":{},"写":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"在":{"docs":{},"此":{"docs":{},"不":{"docs":{},"会":{"docs":{},"找":{"docs":{},"到":{"docs":{},"诸":{"docs":{},"如":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"访":{"docs":{},"问":{"docs":{},"、":{"docs":{},"授":{"docs":{},"权":{"docs":{},"或":{"docs":{},"高":{"docs":{},"层":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"应":{"docs":{},"用":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"。":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"中":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"用":{"docs":{},"完":{"docs":{},"连":{"docs":{},"接":{"docs":{},"后":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}},"应":{"docs":{},"该":{"docs":{},"阅":{"docs":{},"读":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"响":{"docs":{},"应":{"docs":{},"结":{"docs":{},"束":{"docs":{},"之":{"docs":{},"前":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"使":{"docs":{},"用":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"给":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"甚":{"docs":{},"至":{"docs":{},"可":{"docs":{},"以":{"docs":{},"不":{"docs":{},"必":{"docs":{},"编":{"docs":{},"译":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"的":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"一":{"docs":{},"个":{"docs":{},"选":{"docs":{},"项":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"标":{"docs":{},"记":{"docs":{},"为":{"docs":{},"“":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"”":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"用":{"docs":{},"户":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"启":{"docs":{},"用":{"docs":{},"“":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"”":{"docs":{},"选":{"docs":{},"项":{"docs":{},"，":{"docs":{},"验":{"docs":{},"证":{"docs":{},"将":{"docs":{},"不":{"docs":{},"会":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"让":{"docs":{},"您":{"docs":{},"有":{"docs":{},"机":{"docs":{},"会":{"docs":{},"检":{"docs":{},"查":{"docs":{},"用":{"docs":{},"户":{"docs":{},"是":{"docs":{},"否":{"docs":{},"需":{"docs":{},"要":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"应":{"docs":{},"用":{"docs":{},"中":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"部":{"docs":{},"分":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"处":{"docs":{},"理":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"登":{"docs":{},"录":{"docs":{},"页":{"docs":{},"需":{"docs":{},"要":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"要":{"docs":{},"等":{"docs":{},"多":{"docs":{},"久":{"docs":{},"？":{"docs":{},"它":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"和":{"docs":{},"所":{"docs":{},"需":{"docs":{},"的":{"docs":{},"并":{"docs":{},"发":{"docs":{},"数":{"docs":{},"量":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"异":{"docs":{},"步":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"中":{"docs":{},"删":{"docs":{},"除":{"docs":{},"条":{"docs":{},"目":{"docs":{},"、":{"docs":{},"清":{"docs":{},"除":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"、":{"docs":{},"读":{"docs":{},"取":{"docs":{},"它":{"docs":{},"的":{"docs":{},"大":{"docs":{},"小":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"一":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"列":{"docs":{},"出":{"docs":{},"后":{"docs":{},"台":{"docs":{},"启":{"docs":{},"动":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"下":{"docs":{},"边":{"docs":{},"方":{"docs":{},"式":{"docs":{},"设":{"docs":{},"置":{"docs":{},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"注":{"docs":{},"解":{"docs":{},"定":{"docs":{},"义":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"。":{"docs":{},"在":{"docs":{},"类":{"docs":{},"和":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"泵":{"docs":{},"将":{"docs":{},"文":{"docs":{},"件":{"docs":{},"内":{"docs":{},"容":{"docs":{},"写":{"docs":{},"入":{"docs":{},"到":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"在":{"docs":{},"后":{"docs":{},"台":{"docs":{},"启":{"docs":{},"动":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"重":{"docs":{},"新":{"docs":{},"部":{"docs":{},"署":{"docs":{},"周":{"docs":{},"期":{"docs":{},"中":{"docs":{},"挂":{"docs":{},"接":{"docs":{},"（":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"）":{"docs":{},"构":{"docs":{},"建":{"docs":{},"过":{"docs":{},"程":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"索":{"docs":{},"引":{"docs":{},"值":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"您":{"docs":{},"将":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"来":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"整":{"docs":{},"个":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"解":{"docs":{},"析":{"docs":{},"功":{"docs":{},"能":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"样":{"docs":{},"，":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"指":{"docs":{},"定":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"指":{"docs":{},"定":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"：":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"控":{"docs":{},"制":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"需":{"docs":{},"要":{"docs":{},"实":{"docs":{},"现":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"配":{"docs":{},"置":{"docs":{},"用":{"docs":{},"于":{"docs":{},"处":{"docs":{},"理":{"docs":{},"登":{"docs":{},"录":{"docs":{},"页":{"docs":{},"面":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"实":{"docs":{},"际":{"docs":{},"处":{"docs":{},"理":{"docs":{},"登":{"docs":{},"录":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"我":{"docs":{},"们":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"内":{"docs":{},"置":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"确":{"docs":{},"在":{"docs":{},"您":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"设":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"保":{"docs":{},"证":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"能":{"docs":{},"够":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"所":{"docs":{},"有":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"这":{"docs":{},"个":{"docs":{},"功":{"docs":{},"能":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"模":{"docs":{},"板":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"时":{"docs":{},"提":{"docs":{},"供":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"模":{"docs":{},"板":{"docs":{},"引":{"docs":{},"擎":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"您":{"docs":{},"的":{"docs":{},"项":{"docs":{},"目":{"docs":{},"中":{"docs":{},"添":{"docs":{},"加":{"docs":{},"这":{"docs":{},"些":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"来":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922}}}}}}}}}}}}}}}}},"将":{"docs":{},"表":{"docs":{},"单":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"填":{"docs":{},"充":{"docs":{},"这":{"docs":{},"个":{"docs":{},"值":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"的":{"docs":{},"办":{"docs":{},"法":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"键":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"手":{"docs":{},"工":{"docs":{},"提":{"docs":{},"供":{"docs":{},"所":{"docs":{},"有":{"docs":{},"关":{"docs":{},"于":{"docs":{},"您":{"docs":{},"所":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"提":{"docs":{},"供":{"docs":{},"商":{"docs":{},"的":{"docs":{},"细":{"docs":{},"节":{"docs":{},"，":{"docs":{},"但":{"docs":{},"结":{"docs":{},"果":{"docs":{},"是":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"会":{"docs":{},"话":{"docs":{},"存":{"docs":{},"储":{"docs":{},"对":{"docs":{},"象":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"会":{"docs":{},"话":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"会":{"docs":{},"话":{"docs":{},"存":{"docs":{},"储":{"docs":{},"用":{"docs":{},"于":{"docs":{},"维":{"docs":{},"持":{"docs":{},"会":{"docs":{},"话":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"经":{"docs":{},"常":{"docs":{},"需":{"docs":{},"要":{"docs":{},"为":{"docs":{},"所":{"docs":{},"有":{"docs":{},"以":{"docs":{},"某":{"docs":{},"些":{"docs":{},"路":{"docs":{},"径":{"docs":{},"开":{"docs":{},"始":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"设":{"docs":{},"置":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"有":{"docs":{},"以":{"docs":{},"下":{"docs":{},"几":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}},"想":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"要":{"docs":{},"将":{"docs":{},"数":{"docs":{},"据":{"docs":{},"写":{"docs":{},"入":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"正":{"docs":{},"确":{"docs":{},"地":{"docs":{},"生":{"docs":{},"成":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"设":{"docs":{},"计":{"docs":{},"必":{"docs":{},"须":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"一":{"docs":{},"些":{"docs":{},"规":{"docs":{},"则":{"docs":{},"。":{"docs":{},"首":{"docs":{},"先":{"docs":{},"是":{"docs":{},"需":{"docs":{},"要":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"异":{"docs":{},"步":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"需":{"docs":{},"要":{"docs":{},"返":{"docs":{},"回":{"docs":{},"结":{"docs":{},"果":{"docs":{},"，":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"需":{"docs":{},"要":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"象":{"docs":{},"成":{"docs":{},"字":{"docs":{},"节":{"docs":{},"数":{"docs":{},"组":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"类":{"docs":{},"似":{"docs":{},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"成":{"docs":{},"功":{"docs":{},"得":{"docs":{},"到":{"docs":{},"结":{"docs":{},"果":{"docs":{},"，":{"docs":{},"则":{"docs":{},"该":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"成":{"docs":{},"，":{"docs":{},"得":{"docs":{},"到":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"（":{"docs":{},"或":{"docs":{},"任":{"docs":{},"一":{"docs":{},"失":{"docs":{},"败":{"docs":{},"）":{"docs":{},"，":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"放":{"docs":{},"入":{"docs":{},"值":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"读":{"docs":{},"取":{"docs":{},"值":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"，":{"docs":{},"它":{"docs":{},"只":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"它":{"docs":{},"可":{"docs":{},"能":{"docs":{},"已":{"docs":{},"经":{"docs":{},"写":{"docs":{},"入":{"docs":{},"了":{"docs":{},"网":{"docs":{},"络":{"docs":{},"堆":{"docs":{},"栈":{"docs":{},"，":{"docs":{},"但":{"docs":{},"不":{"docs":{},"保":{"docs":{},"证":{"docs":{},"它":{"docs":{},"已":{"docs":{},"经":{"docs":{},"到":{"docs":{},"达":{"docs":{},"或":{"docs":{},"者":{"docs":{},"将":{"docs":{},"到":{"docs":{},"达":{"docs":{},"远":{"docs":{},"端":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"；":{"docs":{},"当":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"!":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}},"！":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"为":{"docs":{},"其":{"docs":{},"发":{"docs":{},"现":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"代":{"docs":{},"码":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}},"或":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.002136553646075244},"web/Web.html":{"ref":"web/Web.html","tf":0.0021908471275559884},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"一":{"docs":{},"个":{"docs":{},"其":{"docs":{},"他":{"docs":{},"通":{"docs":{},"用":{"docs":{},"请":{"docs":{},"求":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"如":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"事":{"docs":{},"情":{"docs":{},"更":{"docs":{},"简":{"docs":{},"单":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"从":{"docs":{},"输":{"docs":{},"入":{"docs":{},"流":{"docs":{},"读":{"docs":{},"取":{"docs":{},"文":{"docs":{},"件":{"docs":{},"是":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"的":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"为":{"docs":{},"了":{"docs":{},"避":{"docs":{},"免":{"docs":{},"每":{"docs":{},"次":{"docs":{},"都":{"docs":{},"付":{"docs":{},"出":{"docs":{},"代":{"docs":{},"价":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"绝":{"docs":{},"对":{"docs":{},"路":{"docs":{},"径":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"些":{"docs":{},"值":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"进":{"docs":{},"行":{"docs":{},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"称":{"docs":{},"之":{"docs":{},"为":{"docs":{},"不":{"docs":{},"可":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"的":{"docs":{},"。":{"docs":{},"可":{"docs":{},"防":{"docs":{},"止":{"docs":{},"碰":{"docs":{},"撞":{"docs":{},"攻":{"docs":{},"击":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"者":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.014925373134328358},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}},"使":{"docs":{},"用":{"docs":{},"编":{"docs":{},"程":{"docs":{},"方":{"docs":{},"式":{"docs":{},"部":{"docs":{},"署":{"docs":{},"您":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"当":{"docs":{},"响":{"docs":{},"应":{"docs":{},"已":{"docs":{},"被":{"docs":{},"完":{"docs":{},"全":{"docs":{},"读":{"docs":{},"取":{"docs":{},"时":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"您":{"docs":{},"发":{"docs":{},"现":{"docs":{},"自":{"docs":{},"己":{"docs":{},"使":{"docs":{},"用":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"向":{"docs":{},"不":{"docs":{},"同":{"docs":{},"主":{"docs":{},"机":{"docs":{},"的":{"docs":{},"主":{"docs":{},"机":{"docs":{},"/":{"docs":{},"端":{"docs":{},"口":{"docs":{},"发":{"docs":{},"送":{"docs":{},"大":{"docs":{},"量":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"发":{"docs":{},"出":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"简":{"docs":{},"单":{"docs":{},"指":{"docs":{},"定":{"docs":{},"主":{"docs":{},"机":{"docs":{},"/":{"docs":{},"端":{"docs":{},"口":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"自":{"docs":{},"己":{"docs":{},"读":{"docs":{},"取":{"docs":{},"受":{"docs":{},"信":{"docs":{},"存":{"docs":{},"储":{"docs":{},"到":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"它":{"docs":{},"直":{"docs":{},"接":{"docs":{},"提":{"docs":{},"供":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"设":{"docs":{},"置":{"docs":{},"空":{"docs":{},"闲":{"docs":{},"时":{"docs":{},"间":{"docs":{},"—":{"docs":{},"—":{"docs":{},"这":{"docs":{},"个":{"docs":{},"时":{"docs":{},"间":{"docs":{},"内":{"docs":{},"没":{"docs":{},"有":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"连":{"docs":{},"接":{"docs":{},"将":{"docs":{},"被":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"，":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"空":{"docs":{},"闲":{"docs":{},"时":{"docs":{},"间":{"docs":{},"以":{"docs":{},"秒":{"docs":{},"为":{"docs":{},"单":{"docs":{},"位":{"docs":{},"，":{"docs":{},"不":{"docs":{},"是":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"自":{"docs":{},"己":{"docs":{},"读":{"docs":{},"取":{"docs":{},"密":{"docs":{},"钥":{"docs":{},"库":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"它":{"docs":{},"直":{"docs":{},"接":{"docs":{},"提":{"docs":{},"供":{"docs":{},"给":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"编":{"docs":{},"辑":{"docs":{},"位":{"docs":{},"于":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"设":{"docs":{},"置":{"docs":{},"空":{"docs":{},"闲":{"docs":{},"时":{"docs":{},"间":{"docs":{},"—":{"docs":{},"—":{"docs":{},"在":{"docs":{},"设":{"docs":{},"置":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"内":{"docs":{},"然":{"docs":{},"后":{"docs":{},"没":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"将":{"docs":{},"被":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"。":{"docs":{},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"空":{"docs":{},"闲":{"docs":{},"超":{"docs":{},"时":{"docs":{},"值":{"docs":{},"以":{"docs":{},"秒":{"docs":{},"为":{"docs":{},"单":{"docs":{},"位":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"执":{"docs":{},"行":{"docs":{},"密":{"docs":{},"集":{"docs":{},"计":{"docs":{},"算":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"其":{"docs":{},"它":{"docs":{},"任":{"docs":{},"意":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}},"你":{"docs":{},"甚":{"docs":{},"至":{"docs":{},"可":{"docs":{},"以":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"工":{"docs":{},"厂":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"m":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"其":{"docs":{},"他":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"静":{"docs":{},"态":{"docs":{},"资":{"docs":{},"源":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"完":{"docs":{},"整":{"docs":{},"的":{"docs":{},"域":{"docs":{},"名":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"所":{"docs":{},"以":{"docs":{},"不":{"docs":{},"要":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"！":{"docs":{},"这":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"警":{"docs":{},"告":{"docs":{},"!":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"您":{"docs":{},"要":{"docs":{},"怎":{"docs":{},"么":{"docs":{},"做":{"docs":{},"？":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"，":{"docs":{},"什":{"docs":{},"么":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"您":{"docs":{},"发":{"docs":{},"送":{"docs":{},"和":{"docs":{},"接":{"docs":{},"收":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"都":{"docs":{},"要":{"docs":{},"包":{"docs":{},"含":{"docs":{},"有":{"docs":{},"远":{"docs":{},"程":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"的":{"docs":{},"软":{"docs":{},"件":{"docs":{},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}},"有":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0017039922103213243}},"已":{"docs":{},"经":{"docs":{},"加":{"docs":{},"入":{"docs":{},"多":{"docs":{},"播":{"docs":{},"组":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"启":{"docs":{},"动":{"docs":{},"完":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"流":{"docs":{},"被":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"，":{"docs":{},"连":{"docs":{},"接":{"docs":{},"也":{"docs":{},"关":{"docs":{},"闭":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"代":{"docs":{},"码":{"docs":{},"都":{"docs":{},"是":{"docs":{},"在":{"docs":{},"相":{"docs":{},"同":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"都":{"docs":{},"失":{"docs":{},"败":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"请":{"docs":{},"求":{"docs":{},"都":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"处":{"docs":{},"理":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"账":{"docs":{},"号":{"docs":{},"：":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}},"被":{"docs":{},"合":{"docs":{},"并":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"这":{"docs":{},"些":{"docs":{},"错":{"docs":{},"误":{"docs":{},"都":{"docs":{},"由":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"本":{"docs":{},"身":{"docs":{},"“":{"docs":{},"生":{"docs":{},"成":{"docs":{},"”":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"您":{"docs":{},"是":{"docs":{},"透":{"docs":{},"明":{"docs":{},"的":{"docs":{},"，":{"docs":{},"您":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"简":{"docs":{},"单":{"docs":{},"地":{"docs":{},"使":{"docs":{},"用":{"docs":{},"类":{"docs":{},"似":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}},"都":{"docs":{},"成":{"docs":{},"功":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"以":{"docs":{},"下":{"docs":{},"路":{"docs":{},"径":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"都":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},":":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"访":{"docs":{},"问":{"docs":{},"根":{"docs":{},"路":{"docs":{},"径":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"路":{"docs":{},"径":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}},"以":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}}}}},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"，":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"回":{"docs":{},"调":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"得":{"docs":{},"到":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}},"工":{"docs":{},"作":{"docs":{},"都":{"docs":{},"在":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"监":{"docs":{},"听":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"和":{"docs":{},"端":{"docs":{},"口":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"数":{"docs":{},"据":{"docs":{},"报":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"接":{"docs":{},"收":{"docs":{},"被":{"docs":{},"发":{"docs":{},"送":{"docs":{},"到":{"docs":{},"该":{"docs":{},"多":{"docs":{},"播":{"docs":{},"组":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"报":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"表":{"docs":{},"示":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"来":{"docs":{},"返":{"docs":{},"回":{"docs":{},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"授":{"docs":{},"权":{"docs":{},"认":{"docs":{},"证":{"docs":{},"机":{"docs":{},"制":{"docs":{},"。":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}},"传":{"docs":{},"递":{"docs":{},"的":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"打":{"docs":{},"开":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"选":{"docs":{},"项":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"连":{"docs":{},"接":{"docs":{},"超":{"docs":{},"时":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"，":{"docs":{},"单":{"docs":{},"位":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"1":{"0":{"0":{"0":{"0":{"docs":{},"（":{"1":{"0":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}},"包":{"docs":{},"和":{"docs":{},"部":{"docs":{},"署":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"独":{"docs":{},"立":{"docs":{},"服":{"docs":{},"务":{"docs":{},"。":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}},"扩":{"docs":{},"展":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"到":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"的":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"库":{"docs":{},"需":{"docs":{},"要":{"docs":{},"执":{"docs":{},"行":{"docs":{},"一":{"docs":{},"些":{"docs":{},"可":{"docs":{},"调":{"docs":{},"度":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}},"拒":{"docs":{},"绝":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"该":{"docs":{},"消":{"docs":{},"息":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"拷":{"docs":{},"贝":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"完":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"文":{"docs":{},"件":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"指":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"i":{"docs":{},"d":{"docs":{},"并":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"外":{"docs":{},"部":{"docs":{},"文":{"docs":{},"件":{"docs":{},"为":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{},"密":{"docs":{},"钥":{"docs":{},"/":{"docs":{},"证":{"docs":{},"书":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"信":{"docs":{},"任":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"端":{"docs":{},"的":{"docs":{},"密":{"docs":{},"钥":{"docs":{},"/":{"docs":{},"证":{"docs":{},"书":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"端":{"docs":{},"口":{"docs":{},"和":{"docs":{},"主":{"docs":{},"机":{"docs":{},"名":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"都":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"排":{"docs":{},"序":{"docs":{},"字":{"docs":{},"段":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"名":{"docs":{},"称":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}},"返":{"docs":{},"回":{"docs":{},"哪":{"docs":{},"些":{"docs":{},"域":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"条":{"docs":{},"数":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"位":{"docs":{},"置":{"1":{"0":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"docs":{}},"docs":{}}}}}}}}}},"允":{"docs":{},"许":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"向":{"docs":{},"这":{"docs":{},"里":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"控":{"docs":{},"制":{"docs":{},"台":{"docs":{},"中":{"docs":{},"显":{"docs":{},"示":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"推":{"docs":{},"送":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"到":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"客":{"docs":{},"户":{"docs":{},"能":{"docs":{},"会":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"如":{"docs":{},"：":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"可":{"docs":{},"能":{"docs":{},"取":{"docs":{},"消":{"docs":{},"推":{"docs":{},"送":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"已":{"docs":{},"经":{"docs":{},"在":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"断":{"docs":{},"出":{"docs":{},"来":{"docs":{},"的":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"该":{"docs":{},"属":{"docs":{},"性":{"docs":{},"没":{"docs":{},"有":{"docs":{},"设":{"docs":{},"置":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"。":{"docs":{},"目":{"docs":{},"前":{"docs":{},"暂":{"docs":{},"时":{"docs":{},"只":{"docs":{},"支":{"docs":{},"持":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"荐":{"docs":{},"命":{"docs":{},"名":{"docs":{},"：":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"描":{"docs":{},"述":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"和":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"是":{"docs":{},"无":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"，":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"仅":{"docs":{},"读":{"docs":{},"取":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"值":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"了":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"能":{"docs":{},"够":{"docs":{},"处":{"docs":{},"理":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"获":{"docs":{},"得":{"docs":{},"最":{"docs":{},"后":{"docs":{},"插":{"docs":{},"入":{"docs":{},"的":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}},"握":{"docs":{},"手":{"docs":{},"中":{"docs":{},"的":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"搜":{"docs":{},"索":{"docs":{},"域":{"docs":{},"名":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"搭":{"docs":{},"配":{"docs":{},"其":{"docs":{},"它":{"docs":{},"工":{"docs":{},"具":{"docs":{},"包":{"docs":{},"，":{"docs":{},"使":{"docs":{},"得":{"docs":{},"编":{"docs":{},"写":{"docs":{},"不":{"docs":{},"安":{"docs":{},"全":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"成":{"docs":{},"为":{"docs":{},"可":{"docs":{},"能":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"开":{"docs":{},"发":{"docs":{},"时":{"docs":{},"需":{"docs":{},"谨":{"docs":{},"慎":{"docs":{},"，":{"docs":{},"尤":{"docs":{},"其":{"docs":{},"是":{"docs":{},"当":{"docs":{},"您":{"docs":{},"将":{"docs":{},"其":{"docs":{},"对":{"docs":{},"公":{"docs":{},"众":{"docs":{},"发":{"docs":{},"布":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"（":{"docs":{},"如":{"docs":{},"在":{"docs":{},"互":{"docs":{},"联":{"docs":{},"网":{"docs":{},"上":{"docs":{},"发":{"docs":{},"布":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"撤":{"docs":{},"销":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"操":{"docs":{},"作":{"docs":{},"也":{"docs":{},"是":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"若":{"docs":{},"您":{"docs":{},"想":{"docs":{},"要":{"docs":{},"在":{"docs":{},"撤":{"docs":{},"销":{"docs":{},"完":{"docs":{},"成":{"docs":{},"过":{"docs":{},"后":{"docs":{},"收":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"指":{"docs":{},"定":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"完":{"docs":{},"成":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"自":{"docs":{},"动":{"docs":{},"被":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"操":{"docs":{},"作":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0064794816414686825}},"系":{"docs":{},"统":{"docs":{},"的":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"文":{"docs":{},"件":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"用":{"docs":{},"于":{"docs":{},"对":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"执":{"docs":{},"行":{"docs":{},"主":{"docs":{},"机":{"docs":{},"名":{"docs":{},"查":{"docs":{},"找":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"到":{"docs":{},"底":{"docs":{},"是":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"的":{"docs":{},"相":{"docs":{},"关":{"docs":{},"命":{"docs":{},"令":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}},"无":{"docs":{},"序":{"docs":{},"集":{"docs":{},"合":{"docs":{},"的":{"docs":{},"相":{"docs":{},"关":{"docs":{},"命":{"docs":{},"令":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}},"有":{"docs":{},"序":{"docs":{},"集":{"docs":{},"合":{"docs":{},"的":{"docs":{},"相":{"docs":{},"关":{"docs":{},"命":{"docs":{},"令":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}},"也":{"docs":{},"能":{"docs":{},"获":{"docs":{},"得":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"流":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}},"符":{"docs":{},"）":{"docs":{},"供":{"docs":{},"重":{"docs":{},"组":{"docs":{},"操":{"docs":{},"作":{"docs":{},"使":{"docs":{},"用":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}},"这":{"docs":{},"里":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"型":{"docs":{},"的":{"docs":{},"调":{"docs":{},"度":{"docs":{},"器":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"以":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"提":{"docs":{},"供":{"docs":{},"：":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}},"都":{"docs":{},"将":{"docs":{},"通":{"docs":{},"过":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}},"支":{"docs":{},"持":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"/":{"1":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"docs":{}}}}}},"基":{"docs":{},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"单":{"docs":{},"个":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"请":{"docs":{},"求":{"docs":{},"并":{"docs":{},"行":{"docs":{},"发":{"docs":{},"送":{"docs":{},"多":{"docs":{},"个":{"docs":{},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"语":{"docs":{},"言":{"docs":{},"都":{"docs":{},"是":{"docs":{},"非":{"docs":{},"常":{"docs":{},"容":{"docs":{},"易":{"docs":{},"创":{"docs":{},"建":{"docs":{},"、":{"docs":{},"读":{"docs":{},"取":{"docs":{},"和":{"docs":{},"解":{"docs":{},"析":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"它":{"docs":{},"已":{"docs":{},"经":{"docs":{},"成":{"docs":{},"为":{"docs":{},"了":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"的":{"docs":{},"通":{"docs":{},"用":{"docs":{},"语":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"如":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"编":{"docs":{},"程":{"docs":{},"语":{"docs":{},"言":{"docs":{},"编":{"docs":{},"写":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"多":{"docs":{},"种":{"docs":{},"语":{"docs":{},"言":{"docs":{},"编":{"docs":{},"写":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"模":{"docs":{},"板":{"docs":{},"渲":{"docs":{},"染":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"以":{"docs":{},"下":{"docs":{},"开":{"docs":{},"箱":{"docs":{},"即":{"docs":{},"用":{"docs":{},"的":{"docs":{},"模":{"docs":{},"板":{"docs":{},"引":{"docs":{},"擎":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"本":{"docs":{},"地":{"docs":{},"会":{"docs":{},"话":{"docs":{},"和":{"docs":{},"集":{"docs":{},"群":{"docs":{},"会":{"docs":{},"话":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"超":{"docs":{},"时":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"编":{"docs":{},"解":{"docs":{},"码":{"docs":{},"器":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"实":{"docs":{},"现":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"处":{"docs":{},"理":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"和":{"docs":{},"配":{"docs":{},"置":{"docs":{},"重":{"docs":{},"载":{"docs":{},"(":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"布":{"docs":{},"／":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"模":{"docs":{},"式":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"队":{"docs":{},"列":{"docs":{},"。":{"docs":{},"需":{"docs":{},"要":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"一":{"docs":{},"个":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}}}},"多":{"docs":{},"种":{"docs":{},"存":{"docs":{},"储":{"docs":{},"方":{"docs":{},"式":{"docs":{},"（":{"docs":{},"文":{"docs":{},"件":{"docs":{},"、":{"docs":{},"目":{"docs":{},"录":{"docs":{},"、":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"、":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"（":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"）":{"docs":{},"、":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"（":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"）":{"docs":{},"、":{"docs":{},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{},"、":{"docs":{},"环":{"docs":{},"境":{"docs":{},"变":{"docs":{},"量":{"docs":{},"等":{"docs":{},"）":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"语":{"docs":{},"法":{"docs":{},"（":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"、":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"、":{"docs":{},"y":{"docs":{},"a":{"docs":{},"m":{"docs":{},"l":{"docs":{},"（":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"）":{"docs":{},"、":{"docs":{},"h":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"（":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"）":{"docs":{},"等":{"docs":{},"）":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"重":{"docs":{},"新":{"docs":{},"配":{"docs":{},"置":{"docs":{},"(":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}},"收":{"docs":{},"到":{"docs":{},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"数":{"docs":{},"据":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"传":{"docs":{},"入":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"通":{"docs":{},"知":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"的":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"中":{"docs":{},"有":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"字":{"docs":{},"段":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"状":{"docs":{},"态":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"包":{"docs":{},"含":{"docs":{},"如":{"docs":{},"下":{"docs":{},"内":{"docs":{},"容":{"docs":{},"的":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"对":{"docs":{},"象":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"放":{"docs":{},"在":{"docs":{},"它":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"故":{"docs":{},"事":{"docs":{},"从":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"障":{"docs":{},"排":{"docs":{},"除":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}},"转":{"docs":{},"移":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"仍":{"docs":{},"然":{"docs":{},"适":{"docs":{},"用":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"列":{"docs":{},"表":{"docs":{},"中":{"docs":{},"的":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"的":{"docs":{},"数":{"docs":{},"量":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}},"数":{"docs":{},"据":{"docs":{},"块":{"docs":{},"，":{"docs":{},"分":{"docs":{},"块":{"docs":{},"传":{"docs":{},"输":{"docs":{},"、":{"docs":{},"分":{"docs":{},"块":{"docs":{},"模":{"docs":{},"式":{"docs":{},"中":{"docs":{},"会":{"docs":{},"用":{"docs":{},"到":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"对":{"docs":{},"象":{"docs":{},"来":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"报":{"docs":{},"套":{"docs":{},"接":{"docs":{},"字":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"（":{"docs":{},"u":{"docs":{},"d":{"docs":{},"p":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"库":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725}},"密":{"docs":{},"码":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},")":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"不":{"docs":{},"设":{"docs":{},"置":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725}},"，":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}},"主":{"docs":{},"机":{"docs":{},"地":{"docs":{},"址":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}},"交":{"docs":{},"互":{"docs":{},"的":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}},"端":{"docs":{},"口":{"docs":{},"，":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}},"源":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}},"可":{"docs":{},"以":{"docs":{},"代":{"docs":{},"表":{"docs":{},"各":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"，":{"docs":{},"而":{"docs":{},"这":{"docs":{},"些":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"的":{"docs":{},"访":{"docs":{},"问":{"docs":{},"方":{"docs":{},"式":{"docs":{},"一":{"docs":{},"般":{"docs":{},"是":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"很":{"docs":{},"难":{"docs":{},"有":{"docs":{},"统":{"docs":{},"一":{"docs":{},"结":{"docs":{},"构":{"docs":{},"。":{"docs":{},"在":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"中":{"docs":{},"，":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"指":{"docs":{},"的":{"docs":{},"是":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"或":{"docs":{},"数":{"docs":{},"据":{"docs":{},"存":{"docs":{},"储":{"docs":{},"。":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"通":{"docs":{},"过":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"驱":{"docs":{},"动":{"docs":{},"访":{"docs":{},"问":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"，":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"是":{"docs":{},"是":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0030659172202350538}},"共":{"docs":{},"两":{"docs":{},"个":{"docs":{},"步":{"docs":{},"骤":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}}}}},"是":{"docs":{},"专":{"docs":{},"门":{"docs":{},"为":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"对":{"docs":{},"应":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"是":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"两":{"docs":{},"步":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}},"组":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"中":{"docs":{},"获":{"docs":{},"取":{"docs":{},"值":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"同":{"docs":{},"样":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"的":{"docs":{},"序":{"docs":{},"列":{"docs":{},"（":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"编":{"docs":{},"码":{"docs":{},"成":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"文":{"docs":{},"件":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"图":{"docs":{},"标":{"docs":{},"打":{"docs":{},"包":{"docs":{},"到":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"果":{"docs":{},"想":{"docs":{},"在":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}},"此":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}},"列":{"docs":{},"表":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"系":{"docs":{},"统":{"docs":{},"支":{"docs":{},"持":{"docs":{},"诸":{"docs":{},"如":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"访":{"docs":{},"问":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"被":{"docs":{},"移":{"docs":{},"走":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"f":{"docs":{},"u":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"（":{"docs":{},"这":{"docs":{},"里":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"或":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"j":{"docs":{},"u":{"docs":{},"l":{"docs":{},"记":{"docs":{},"录":{"docs":{},"时":{"docs":{},"）":{"docs":{},"，":{"docs":{},"这":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"标":{"docs":{},"准":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}},"上":{"docs":{},"传":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"中":{"docs":{},"）":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.011363636363636364},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.002043944813490036}}}}}}}}}},")":{"docs":{},":":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.004319654427645789},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.004975124378109453},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.014625228519195612}}},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.004705882352941176}}}}},"里":{"docs":{},"）":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"设":{"docs":{},"置":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}},"但":{"docs":{},"是":{"docs":{},"如":{"docs":{},"果":{"docs":{},"加":{"docs":{},"载":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"设":{"docs":{},"置":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}},"所":{"docs":{},"在":{"docs":{},"的":{"docs":{},"根":{"docs":{},"结":{"docs":{},"点":{"docs":{},"路":{"docs":{},"径":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"描":{"docs":{},"述":{"docs":{},"符":{"docs":{},"文":{"docs":{},"件":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"内":{"docs":{},"容":{"docs":{},"为":{"docs":{},"有":{"docs":{},"效":{"docs":{},"的":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"中":{"docs":{},"至":{"docs":{},"少":{"docs":{},"必":{"docs":{},"须":{"docs":{},"提":{"docs":{},"供":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"用":{"docs":{},"于":{"docs":{},"指":{"docs":{},"定":{"docs":{},"实":{"docs":{},"际":{"docs":{},"被":{"docs":{},"部":{"docs":{},"署":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"档":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211}}},"手":{"docs":{},"册":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.11764705882352941}},"中":{"docs":{},"的":{"docs":{},"相":{"docs":{},"关":{"docs":{},"章":{"docs":{},"节":{"docs":{},"。":{"docs":{"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353}}}}}}}}}}},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"您":{"docs":{},"又":{"docs":{},"希":{"docs":{},"望":{"docs":{},"他":{"docs":{},"可":{"docs":{},"以":{"docs":{},"作":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"计":{"docs":{},"数":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"中":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}},"日":{"docs":{},"志":{"docs":{},"的":{"docs":{},"记":{"docs":{},"录":{"docs":{},"是":{"docs":{},"由":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"日":{"docs":{},"志":{"docs":{},"来":{"docs":{},"执":{"docs":{},"行":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"记":{"docs":{},"录":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"、":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"4":{"docs":{},"j":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"docs":{}}}}},"来":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"配":{"docs":{},"置":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152}}}},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"给":{"docs":{},"予":{"docs":{},"很":{"docs":{},"大":{"docs":{},"的":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"。":{"docs":{},"在":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}},"文":{"docs":{},"档":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}},"期":{"docs":{},"和":{"docs":{},"时":{"docs":{},"间":{"docs":{},"戳":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}},"时":{"docs":{},"也":{"docs":{},"适":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"它":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"成":{"docs":{},"后":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"都":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"收":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"直":{"docs":{},"接":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},",":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"遇":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"，":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"处":{"docs":{},"理":{"docs":{},"原":{"docs":{},"始":{"docs":{},"响":{"docs":{},"应":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"它":{"docs":{},"们":{"docs":{},"将":{"docs":{},"共":{"docs":{},"享":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"会":{"docs":{},"将":{"docs":{},"数":{"docs":{},"据":{"docs":{},"写":{"docs":{},"入":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"传":{"docs":{},"递":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"指":{"docs":{},"定":{"docs":{},"您":{"docs":{},"想":{"docs":{},"要":{"docs":{},"部":{"docs":{},"署":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"流":{"docs":{},"量":{"docs":{},"将":{"docs":{},"通":{"docs":{},"过":{"docs":{},"未":{"docs":{},"加":{"docs":{},"密":{"docs":{},"报":{"docs":{},"文":{"docs":{},"发":{"docs":{},"送":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"若":{"docs":{},"您":{"docs":{},"有":{"docs":{},"要":{"docs":{},"发":{"docs":{},"送":{"docs":{},"的":{"docs":{},"机":{"docs":{},"密":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"而":{"docs":{},"您":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"失":{"docs":{},"败":{"docs":{},"时":{"docs":{},"调":{"docs":{},"用":{"docs":{},"设":{"docs":{},"置":{"docs":{},"的":{"docs":{},"异":{"docs":{},"常":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"将":{"docs":{},"在":{"docs":{},"它":{"docs":{},"成":{"docs":{},"功":{"docs":{},"完":{"docs":{},"成":{"docs":{},"后":{"docs":{},"发":{"docs":{},"送":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"应":{"docs":{},"使":{"docs":{},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"设":{"docs":{},"置":{"docs":{},"了":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"将":{"docs":{},"进":{"docs":{},"一":{"docs":{},"步":{"docs":{},"去":{"docs":{},"检":{"docs":{},"查":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}},"此":{"docs":{},"元":{"docs":{},"素":{"docs":{},"将":{"docs":{},"被":{"docs":{},"注":{"docs":{},"册":{"docs":{},"为":{"docs":{},"输":{"docs":{},"入":{"docs":{},"参":{"docs":{},"数":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}},"错":{"docs":{},"误":{"docs":{},"的":{"docs":{},"传":{"docs":{},"递":{"docs":{},"也":{"docs":{},"会":{"docs":{},"变":{"docs":{},"得":{"docs":{},"更":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"方":{"docs":{},"法":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}},"通":{"docs":{},"过":{"docs":{},"编":{"docs":{},"程":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"创":{"docs":{},"建":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}},"停":{"docs":{},"止":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}},"建":{"docs":{},"立":{"docs":{},"连":{"docs":{},"接":{"docs":{},"后":{"docs":{},"，":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"将":{"docs":{},"发":{"docs":{},"送":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"和":{"docs":{},"路":{"docs":{},"径":{"docs":{},"一":{"docs":{},"起":{"docs":{},"指":{"docs":{},"定":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"指":{"docs":{},"定":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"正":{"docs":{},"则":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"的":{"docs":{},"序":{"docs":{},"号":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"间":{"docs":{},"戳":{"docs":{},"被":{"docs":{},"更":{"docs":{},"新":{"docs":{},"时":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"该":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}},"将":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}},"作":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}},"失":{"docs":{},"败":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}},"关":{"docs":{},"闭":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.002770083102493075}},"一":{"docs":{},"个":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"所":{"docs":{},"有":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"项":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"的":{"docs":{},"可":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"，":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"您":{"docs":{},"不":{"docs":{},"必":{"docs":{},"在":{"docs":{},"执":{"docs":{},"行":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"的":{"docs":{},"机":{"docs":{},"器":{"docs":{},"上":{"docs":{},"预":{"docs":{},"先":{"docs":{},"安":{"docs":{},"装":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"。":{"docs":{},"它":{"docs":{},"像":{"docs":{},"任":{"docs":{},"何":{"docs":{},"可":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"下":{"docs":{},"面":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}},"工":{"docs":{},"具":{"docs":{},"包":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"来":{"docs":{},"强":{"docs":{},"迫":{"docs":{},"您":{"docs":{},"以":{"docs":{},"某":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"做":{"docs":{},"事":{"docs":{},"情":{"docs":{},"的":{"docs":{},"框":{"docs":{},"架":{"docs":{},"。":{"docs":{},"这":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"了":{"docs":{},"开":{"docs":{},"发":{"docs":{},"人":{"docs":{},"员":{"docs":{},"以":{"docs":{},"更":{"docs":{},"强":{"docs":{},"大":{"docs":{},"的":{"docs":{},"能":{"docs":{},"力":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"也":{"docs":{},"伴":{"docs":{},"随":{"docs":{},"着":{"docs":{},"更":{"docs":{},"大":{"docs":{},"的":{"docs":{},"责":{"docs":{},"任":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"能":{"docs":{},"力":{"docs":{},"越":{"docs":{},"大":{"docs":{},"，":{"docs":{},"责":{"docs":{},"任":{"docs":{},"越":{"docs":{},"大":{"docs":{},"，":{"docs":{},"小":{"docs":{},"蜘":{"docs":{},"蛛":{"docs":{},"他":{"docs":{},"叔":{"docs":{},"叔":{"docs":{},"说":{"docs":{},"的":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"性":{"docs":{},"能":{"docs":{},"提":{"docs":{},"示":{"docs":{},"，":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"协":{"docs":{},"议":{"docs":{},"约":{"docs":{},"束":{"docs":{},"）":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"高":{"docs":{},"级":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"大":{"docs":{},"部":{"docs":{},"分":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"不":{"docs":{},"会":{"docs":{},"需":{"docs":{},"要":{"docs":{},"它":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{},"这":{"docs":{},"些":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"顶":{"docs":{},"级":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"通":{"docs":{},"用":{"docs":{},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"不":{"docs":{},"只":{"docs":{},"是":{"docs":{},"在":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"此":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"中":{"docs":{},"有":{"docs":{},"用":{"docs":{},"到":{"docs":{},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}},"基":{"docs":{},"于":{"docs":{},"b":{"docs":{},"s":{"docs":{},"d":{"docs":{},"协":{"docs":{},"议":{"docs":{},"开":{"docs":{},"源":{"docs":{},"的":{"docs":{},"高":{"docs":{},"性":{"docs":{},"能":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"包":{"docs":{},"含":{"docs":{},"访":{"docs":{},"问":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"、":{"docs":{},"端":{"docs":{},"口":{"docs":{},"等":{"docs":{},"）":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"与":{"docs":{},"多":{"docs":{},"种":{"docs":{},"日":{"docs":{},"志":{"docs":{},"框":{"docs":{},"架":{"docs":{},"的":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"。":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}},"种":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"技":{"docs":{},"术":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"系":{"docs":{},"列":{"docs":{},"用":{"docs":{},"于":{"docs":{},"基":{"docs":{},"于":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"组":{"docs":{},"工":{"docs":{},"具":{"docs":{},"集":{"docs":{},"，":{"docs":{},"其":{"docs":{},"特":{"docs":{},"点":{"docs":{},"是":{"docs":{},"在":{"docs":{},"不":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"内":{"docs":{},"核":{"docs":{},"线":{"docs":{},"程":{"docs":{},"的":{"docs":{},"同":{"docs":{},"时":{"docs":{},"，":{"docs":{},"允":{"docs":{},"许":{"docs":{},"用":{"docs":{},"户":{"docs":{},"以":{"docs":{},"同":{"docs":{},"步":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"接":{"docs":{},"收":{"docs":{},"事":{"docs":{},"件":{"docs":{},"、":{"docs":{},"执":{"docs":{},"行":{"docs":{},"异":{"docs":{},"步":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"分":{"docs":{},"布":{"docs":{},"式":{"docs":{},"事":{"docs":{},"务":{"docs":{},"必":{"docs":{},"须":{"docs":{},"获":{"docs":{},"得":{"docs":{},"的":{"docs":{},"最":{"docs":{},"小":{"docs":{},"票":{"docs":{},"数":{"docs":{},"才":{"docs":{},"能":{"docs":{},"被":{"docs":{},"允":{"docs":{},"许":{"docs":{},"在":{"docs":{},"分":{"docs":{},"布":{"docs":{},"式":{"docs":{},"系":{"docs":{},"统":{"docs":{},"中":{"docs":{},"执":{"docs":{},"行":{"docs":{},"操":{"docs":{},"作":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"读":{"docs":{},"取":{"docs":{},"或":{"docs":{},"写":{"docs":{},"入":{"docs":{},"的":{"0":{"docs":{},"个":{"docs":{},"或":{"docs":{},"多":{"docs":{},"个":{"docs":{},"字":{"docs":{},"节":{"docs":{},"序":{"docs":{},"列":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"根":{"docs":{},"据":{"docs":{},"需":{"docs":{},"要":{"docs":{},"可":{"docs":{},"以":{"docs":{},"自":{"docs":{},"动":{"docs":{},"扩":{"docs":{},"容":{"docs":{},"、":{"docs":{},"将":{"docs":{},"任":{"docs":{},"意":{"docs":{},"字":{"docs":{},"节":{"docs":{},"写":{"docs":{},"入":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"，":{"docs":{},"这":{"docs":{},"对":{"docs":{},"于":{"docs":{},"以":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"运":{"docs":{},"行":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"选":{"docs":{},"的":{"docs":{},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{},"消":{"docs":{},"息":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"否":{"docs":{},"已":{"docs":{},"满":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"下":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"它":{"docs":{},"的":{"docs":{},"主":{"docs":{},"机":{"docs":{},"信":{"docs":{},"息":{"docs":{},"和":{"docs":{},"端":{"docs":{},"口":{"docs":{},"。":{"docs":{},"您":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"匹":{"docs":{},"配":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"则":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"删":{"docs":{},"除":{"docs":{},"或":{"docs":{},"者":{"docs":{},"分":{"docs":{},"配":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}},"失":{"docs":{},"败":{"docs":{},"状":{"docs":{},"态":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"并":{"docs":{},"发":{"docs":{},"的":{"docs":{},"，":{"docs":{},"您":{"docs":{},"必":{"docs":{},"须":{"docs":{},"小":{"docs":{},"心":{"docs":{},"地":{"docs":{},"使":{"docs":{},"用":{"docs":{},"标":{"docs":{},"准":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"多":{"docs":{},"线":{"docs":{},"程":{"docs":{},"技":{"docs":{},"术":{"docs":{},"来":{"docs":{},"保":{"docs":{},"持":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"成":{"docs":{},"功":{"docs":{},"状":{"docs":{},"态":{"docs":{},"的":{"docs":{},"；":{"docs":{},"当":{"docs":{},"至":{"docs":{},"少":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"流":{"docs":{},"式":{"docs":{},"的":{"docs":{},"吗":{"docs":{},"？":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"用":{"docs":{},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}}},"由":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"用":{"docs":{},"户":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"中":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"，":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"功":{"docs":{},"能":{"docs":{},"也":{"docs":{},"可":{"docs":{},"用":{"docs":{},"于":{"docs":{},"处":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"特":{"docs":{},"定":{"docs":{},"组":{"docs":{},"的":{"docs":{},"最":{"docs":{},"小":{"docs":{},"节":{"docs":{},"点":{"docs":{},"数":{"docs":{},"。":{"docs":{},"通":{"docs":{},"常":{"docs":{},"您":{"docs":{},"选":{"docs":{},"择":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"非":{"docs":{},"常":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"。":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"临":{"docs":{},"时":{"docs":{},"的":{"docs":{},"，":{"docs":{},"当":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"时":{"docs":{},"会":{"docs":{},"被":{"docs":{},"删":{"docs":{},"除":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"避":{"docs":{},"免":{"docs":{},"跨":{"docs":{},"站":{"docs":{},"点":{"docs":{},"的":{"docs":{},"伪":{"docs":{},"造":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"独":{"docs":{},"立":{"docs":{},"于":{"docs":{},"存":{"docs":{},"储":{"docs":{},"的":{"docs":{},"，":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"对":{"docs":{},"于":{"docs":{},"给":{"docs":{},"定":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"在":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"强":{"docs":{},"类":{"docs":{},"型":{"docs":{},"语":{"docs":{},"言":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"我":{"docs":{},"们":{"docs":{},"又":{"docs":{},"要":{"docs":{},"避":{"docs":{},"免":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"。":{"docs":{},"当":{"docs":{},"方":{"docs":{},"法":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"次":{"docs":{},"性":{"docs":{},"的":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}},"所":{"docs":{},"谓":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"超":{"docs":{},"轻":{"docs":{},"量":{"docs":{},"级":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"对":{"docs":{},"应":{"docs":{},"于":{"docs":{},"底":{"docs":{},"层":{"docs":{},"的":{"docs":{},"那":{"docs":{},"种":{"docs":{},"内":{"docs":{},"核":{"docs":{},"线":{"docs":{},"程":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"被":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"时":{"docs":{},"不":{"docs":{},"会":{"docs":{},"导":{"docs":{},"致":{"docs":{},"内":{"docs":{},"核":{"docs":{},"线":{"docs":{},"程":{"docs":{},"也":{"docs":{},"被":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"基":{"docs":{},"于":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}},"显":{"docs":{},"式":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"d":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"示":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"版":{"docs":{},"本":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"著":{"docs":{},"执":{"docs":{},"行":{"docs":{},"时":{"docs":{},"间":{"docs":{},"，":{"docs":{},"那":{"docs":{},"您":{"docs":{},"应":{"docs":{},"该":{"docs":{},"去":{"docs":{},"罚":{"docs":{},"站":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"原":{"docs":{},"文":{"docs":{},"此":{"docs":{},"处":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"？":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"更":{"docs":{},"多":{"docs":{},"关":{"docs":{},"于":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"r":{"docs":{},"u":{"docs":{},"m":{"docs":{},"（":{"docs":{},"多":{"docs":{},"数":{"docs":{},"派":{"docs":{},"机":{"docs":{},"制":{"docs":{},"）":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"优":{"docs":{},"点":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}},"详":{"docs":{},"细":{"docs":{},"内":{"docs":{},"容":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"参":{"docs":{},"考":{"docs":{},"文":{"docs":{},"档":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}},"：":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.0049586776859504135}}},"docs":{}}}}}}},"示":{"docs":{},"例":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}},"传":{"docs":{},"输":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"如":{"docs":{},"何":{"docs":{},"配":{"docs":{},"置":{"docs":{},"它":{"docs":{},"们":{"docs":{},"，":{"docs":{},"请":{"docs":{},"咨":{"docs":{},"询":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},"j":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"s":{"docs":{},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"信":{"docs":{},"息":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"的":{"docs":{},"限":{"docs":{},"制":{"docs":{},"会":{"docs":{},"在":{"docs":{},"下":{"docs":{},"面":{"docs":{},"详":{"docs":{},"解":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}},"容":{"docs":{},"易":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"改":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"新":{"docs":{},"文":{"docs":{},"档":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"语":{"docs":{},"句":{"docs":{},"（":{"docs":{},"原":{"docs":{},"生":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"）":{"docs":{},"传":{"docs":{},"给":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"时":{"docs":{},"，":{"docs":{},"不":{"docs":{},"会":{"docs":{},"经":{"docs":{},"过":{"docs":{},"任":{"docs":{},"何":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}},"已":{"docs":{},"发":{"docs":{},"布":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"的":{"docs":{},"状":{"docs":{},"态":{"docs":{},"（":{"docs":{},"下":{"docs":{},"线":{"docs":{},"、":{"docs":{},"服":{"docs":{},"务":{"docs":{},"暂":{"docs":{},"停":{"docs":{},"等":{"docs":{},"等":{"docs":{},"）":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}},"简":{"docs":{},"洁":{"docs":{},"的":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}},"最":{"docs":{},"后":{"docs":{},"，":{"docs":{},"在":{"docs":{},"第":{"docs":{},"三":{"docs":{},"个":{"docs":{},"终":{"docs":{},"端":{"docs":{},"中":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"不":{"docs":{},"同":{"docs":{},"组":{"docs":{},"启":{"docs":{},"动":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"如":{"docs":{},"您":{"docs":{},"对":{"docs":{},"响":{"docs":{},"应":{"docs":{},"结":{"docs":{},"果":{"docs":{},"不":{"docs":{},"感":{"docs":{},"兴":{"docs":{},"趣":{"docs":{},"，":{"docs":{},"可":{"docs":{},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"插":{"docs":{},"入":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"i":{"docs":{},"d":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},",":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}},"调":{"docs":{},"用":{"docs":{},"端":{"docs":{},"可":{"docs":{},"以":{"docs":{},"检":{"docs":{},"查":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"异":{"docs":{},"常":{"docs":{},"类":{"docs":{},"型":{"docs":{},"了":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}},"简":{"docs":{},"单":{"docs":{},"地":{"docs":{},"使":{"docs":{},"用":{"docs":{},"所":{"docs":{},"有":{"docs":{},"默":{"docs":{},"认":{"docs":{},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"创":{"docs":{},"建":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"的":{"docs":{},"注":{"docs":{},"册":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"模":{"docs":{},"板":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"不":{"docs":{},"是":{"docs":{},"直":{"docs":{},"接":{"docs":{},"调":{"docs":{},"用":{"docs":{},"模":{"docs":{},"板":{"docs":{},"引":{"docs":{},"擎":{"docs":{},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"模":{"docs":{},"板":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"送":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"是":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"指":{"docs":{},"定":{"docs":{},"目":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}},"小":{"docs":{},"心":{"docs":{},"跳":{"docs":{},"频":{"docs":{},"率":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"大":{"docs":{},"连":{"docs":{},"接":{"docs":{},"数":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}},"故":{"docs":{},"障":{"docs":{},"次":{"docs":{},"数":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}},"终":{"docs":{},"创":{"docs":{},"建":{"docs":{},"的":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"服":{"docs":{},"务":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}},"器":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"准":{"docs":{},"备":{"docs":{},"推":{"docs":{},"送":{"docs":{},"响":{"docs":{},"应":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"列":{"docs":{},"表":{"docs":{},"轮":{"docs":{},"询":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"响":{"docs":{},"应":{"docs":{},"对":{"docs":{},"象":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"将":{"docs":{},"从":{"docs":{},"其":{"docs":{},"中":{"docs":{},"（":{"docs":{},"算":{"docs":{},"法":{"docs":{},"）":{"docs":{},"选":{"docs":{},"择":{"docs":{},"一":{"docs":{},"个":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"发":{"docs":{},"回":{"docs":{},"的":{"docs":{},"响":{"docs":{},"应":{"docs":{},"中":{"docs":{},"响":{"docs":{},"应":{"docs":{},"头":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"拒":{"docs":{},"绝":{"docs":{},"查":{"docs":{},"询":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"推":{"docs":{},"送":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}},"收":{"docs":{},"到":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"故":{"docs":{},"障":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"每":{"docs":{},"次":{"docs":{},"收":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"将":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"没":{"docs":{},"实":{"docs":{},"现":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"的":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"默":{"docs":{},"认":{"docs":{},"端":{"docs":{},"口":{"docs":{},"为":{"5":{"3":{"docs":{},"，":{"docs":{},"当":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"使":{"docs":{},"用":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"端":{"docs":{},"口":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"冒":{"docs":{},"号":{"docs":{},"分":{"docs":{},"隔":{"docs":{},"符":{"docs":{},"设":{"docs":{},"置":{"docs":{},"该":{"docs":{},"端":{"docs":{},"口":{"docs":{},"：":{"1":{"9":{"2":{"docs":{},".":{"1":{"6":{"8":{"docs":{},".":{"0":{"docs":{},".":{"2":{"docs":{},":":{"4":{"0":{"0":{"0":{"0":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}},"请":{"docs":{},"求":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"使":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"都":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"版":{"docs":{},"本":{"docs":{},"必":{"docs":{},"须":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}},"相":{"docs":{},"关":{"docs":{},"命":{"docs":{},"令":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}},"地":{"docs":{},"址":{"docs":{},"和":{"docs":{},"包":{"docs":{},"含":{"docs":{},"我":{"docs":{},"们":{"docs":{},"所":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"节":{"docs":{},"点":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"您":{"docs":{},"想":{"docs":{},"提":{"docs":{},"供":{"docs":{},"文":{"docs":{},"件":{"docs":{},"和":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"之":{"docs":{},"外":{"docs":{},"访":{"docs":{},"问":{"docs":{},"的":{"docs":{},"位":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"暂":{"docs":{},"不":{"docs":{},"涉":{"docs":{},"及":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"然":{"docs":{},"后":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"配":{"docs":{},"置":{"docs":{},"一":{"docs":{},"些":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"配":{"docs":{},"置":{"docs":{},"参":{"docs":{},"数":{"docs":{},"包":{"docs":{},"装":{"docs":{},"在":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"会":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"页":{"docs":{},"面":{"docs":{},"（":{"docs":{},"在":{"docs":{},"目":{"docs":{},"标":{"docs":{},"域":{"docs":{},"名":{"docs":{},"上":{"docs":{},"）":{"docs":{},"并":{"docs":{},"放":{"docs":{},"置":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"不":{"docs":{},"可":{"docs":{},"见":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"基":{"docs":{},"本":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"事":{"docs":{},"情":{"docs":{},"，":{"docs":{},"只":{"docs":{},"是":{"docs":{},"这":{"docs":{},"一":{"docs":{},"次":{"docs":{},"换":{"docs":{},"成":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"域":{"docs":{},"名":{"docs":{},"下":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"不":{"docs":{},"用":{"docs":{},"担":{"docs":{},"心":{"docs":{},"跨":{"docs":{},"域":{"docs":{},"的":{"docs":{},"问":{"docs":{},"题":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"接":{"docs":{},"收":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"信":{"docs":{},"息":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}},"后":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}},"失":{"docs":{},"败":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"重":{"docs":{},"连":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"授":{"docs":{},"权":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"您":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}},"与":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}},"中":{"docs":{},"获":{"docs":{},"取":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}},"得":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"端":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0008360427310729215},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"中":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"总":{"docs":{},"是":{"docs":{},"在":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"共":{"docs":{},"享":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"证":{"docs":{},"书":{"docs":{},"颁":{"docs":{},"发":{"docs":{},"机":{"docs":{},"构":{"docs":{},"来":{"docs":{},"验":{"docs":{},"证":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{},"身":{"docs":{},"份":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"水":{"docs":{},"平":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"到":{"docs":{},"多":{"docs":{},"个":{"docs":{},"核":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"每":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"保":{"docs":{},"持":{"docs":{},"单":{"docs":{},"线":{"docs":{},"程":{"docs":{},"环":{"docs":{},"境":{"docs":{},"不":{"docs":{},"变":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"自":{"docs":{},"由":{"docs":{},"地":{"docs":{},"使":{"docs":{},"用":{"docs":{},"自":{"docs":{},"己":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"算":{"docs":{},"法":{"docs":{},"之":{"docs":{},"一":{"docs":{},"进":{"docs":{},"行":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"不":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"将":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"发":{"docs":{},"回":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"这":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"能":{"docs":{},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"和":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"可":{"docs":{},"以":{"docs":{},"配":{"docs":{},"置":{"docs":{},"成":{"docs":{},"和":{"docs":{},"网":{"docs":{},"络":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"完":{"docs":{},"全":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"则":{"docs":{},"在":{"docs":{},"撤":{"docs":{},"销":{"docs":{},"该":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"将":{"docs":{},"自":{"docs":{},"动":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"它":{"docs":{},"们":{"docs":{},"将":{"docs":{},"会":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"端":{"docs":{},"口":{"docs":{},"上":{"docs":{},"监":{"docs":{},"听":{"docs":{},"时":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"向":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"发":{"docs":{},"送":{"docs":{},"其":{"docs":{},"初":{"docs":{},"始":{"docs":{},"设":{"docs":{},"置":{"docs":{},"。":{"docs":{},"设":{"docs":{},"置":{"docs":{},"定":{"docs":{},"义":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"如":{"docs":{},"何":{"docs":{},"使":{"docs":{},"用":{"docs":{},"连":{"docs":{},"接":{"docs":{},"、":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"初":{"docs":{},"始":{"docs":{},"设":{"docs":{},"置":{"docs":{},"是":{"docs":{},"由":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"能":{"docs":{},"被":{"docs":{},"随":{"docs":{},"意":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"的":{"docs":{},"提":{"docs":{},"示":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"方":{"docs":{},"式":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"最":{"docs":{},"简":{"docs":{},"单":{"docs":{},"方":{"docs":{},"法":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"基":{"docs":{},"本":{"docs":{},"概":{"docs":{},"念":{"docs":{},"是":{"docs":{},"很":{"docs":{},"有":{"docs":{},"价":{"docs":{},"值":{"docs":{},"的":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}},"连":{"docs":{},"接":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"通":{"docs":{},"常":{"docs":{},"向":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"提":{"docs":{},"供":{"docs":{},"证":{"docs":{},"书":{"docs":{},"，":{"docs":{},"以":{"docs":{},"便":{"docs":{},"验":{"docs":{},"证":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"的":{"docs":{},"身":{"docs":{},"份":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"一":{"docs":{},"种":{"docs":{},"从":{"docs":{},"磁":{"docs":{},"盘":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{},"并":{"docs":{},"提":{"docs":{},"供":{"docs":{},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"将":{"docs":{},"文":{"docs":{},"件":{"docs":{},"作":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"并":{"docs":{},"设":{"docs":{},"置":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"都":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"建":{"docs":{},"立":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{},"您":{"docs":{},"不":{"docs":{},"必":{"docs":{},"关":{"docs":{},"注":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"或":{"docs":{},"网":{"docs":{},"络":{"docs":{},"是":{"docs":{},"否":{"docs":{},"真":{"docs":{},"的":{"docs":{},"是":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}},"里":{"docs":{},"的":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}},"请":{"docs":{},"求":{"docs":{},"对":{"docs":{},"象":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"检":{"docs":{},"索":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"的":{"docs":{},"静":{"docs":{},"态":{"docs":{},"资":{"docs":{},"源":{"docs":{},"。":{"docs":{},"这":{"docs":{},"对":{"docs":{},"于":{"docs":{},"在":{"docs":{},"生":{"docs":{},"产":{"docs":{},"环":{"docs":{},"境":{"docs":{},"中":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"标":{"docs":{},"签":{"docs":{},"（":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"）":{"docs":{},"都":{"docs":{},"被":{"docs":{},"映":{"docs":{},"射":{"docs":{},"为":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"的":{"docs":{},"元":{"docs":{},"数":{"docs":{},"据":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"s":{"docs":{},"推":{"docs":{},"断":{"docs":{},"出":{"docs":{},"来":{"docs":{},"的":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"和":{"docs":{},"已":{"docs":{},"知":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"就":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"种":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"没":{"docs":{},"有":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"服":{"docs":{},"务":{"docs":{},"导":{"docs":{},"入":{"docs":{},"后":{"docs":{},"将":{"docs":{},"标":{"docs":{},"记":{"docs":{},"为":{"docs":{},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"目":{"docs":{},"前":{"docs":{},"暂":{"docs":{},"时":{"docs":{},"只":{"docs":{},"支":{"docs":{},"持":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"名":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"字":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"随":{"docs":{},"用":{"docs":{},"户":{"docs":{},"定":{"docs":{},"义":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"建":{"docs":{},"议":{"docs":{},"用":{"docs":{},"户":{"docs":{},"使":{"docs":{},"用":{"docs":{},"域":{"docs":{},"名":{"docs":{},"反":{"docs":{},"转":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"（":{"docs":{},"如":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"包":{"docs":{},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"）":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"避":{"docs":{},"免":{"docs":{},"你":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{},"的":{"docs":{},"其":{"docs":{},"他":{"docs":{},"服":{"docs":{},"务":{"docs":{},"同":{"docs":{},"名":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"用":{"docs":{},"于":{"docs":{},"查":{"docs":{},"找":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"描":{"docs":{},"述":{"docs":{},"符":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"描":{"docs":{},"述":{"docs":{},"符":{"docs":{},"文":{"docs":{},"件":{"docs":{},"决":{"docs":{},"定":{"docs":{},"实":{"docs":{},"际":{"docs":{},"被":{"docs":{},"部":{"docs":{},"署":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"包":{"docs":{},"含":{"docs":{},"部":{"docs":{},"署":{"docs":{},"参":{"docs":{},"数":{"docs":{},"例":{"docs":{},"如":{"docs":{},"是":{"docs":{},"否":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"来":{"docs":{},"运":{"docs":{},"行":{"docs":{},"等":{"docs":{},"等":{"docs":{},"。":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"交":{"docs":{},"互":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}},"事":{"docs":{},"件":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"代":{"docs":{},"理":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"代":{"docs":{},"理":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"所":{"docs":{},"代":{"docs":{},"理":{"docs":{},"的":{"docs":{},"接":{"docs":{},"口":{"docs":{},"（":{"docs":{},"其":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"表":{"docs":{},"现":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"e":{"docs":{},"v":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"介":{"docs":{},"绍":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"假":{"docs":{},"定":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}},"类":{"docs":{},"（":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}},"组":{"docs":{},"件":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"其":{"docs":{},"实":{"docs":{},"就":{"docs":{},"是":{"docs":{},"一":{"docs":{},"种":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"帮":{"docs":{},"你":{"docs":{},"处":{"docs":{},"理":{"docs":{},"这":{"docs":{},"些":{"docs":{},"问":{"docs":{},"题":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"你":{"docs":{},"就":{"docs":{},"不":{"docs":{},"必":{"docs":{},"再":{"docs":{},"写":{"docs":{},"这":{"docs":{},"么":{"docs":{},"多":{"docs":{},"的":{"docs":{},"模":{"docs":{},"板":{"docs":{},"代":{"docs":{},"码":{"docs":{},"了":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"专":{"docs":{},"注":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"即":{"docs":{},"可":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"布":{"docs":{},"者":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"都":{"docs":{},"必":{"docs":{},"须":{"docs":{},"通":{"docs":{},"过":{"docs":{},"单":{"docs":{},"独":{"docs":{},"创":{"docs":{},"建":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}},"现":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"组":{"docs":{},"件":{"docs":{},"中":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"通":{"docs":{},"过":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"分":{"docs":{},"布":{"docs":{},"式":{"docs":{},"数":{"docs":{},"据":{"docs":{},"结":{"docs":{},"构":{"docs":{},"来":{"docs":{},"存":{"docs":{},"储":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"，":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"访":{"docs":{},"问":{"docs":{},"到":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"这":{"docs":{},"是":{"docs":{},"服":{"docs":{},"务":{"docs":{},"后":{"docs":{},"端":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"你":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"实":{"docs":{},"现":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"存":{"docs":{},"储":{"docs":{},"后":{"docs":{},"端":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"实":{"docs":{},"现":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"面":{"docs":{},"向":{"docs":{},"服":{"docs":{},"务":{"docs":{},"计":{"docs":{},"算":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"交":{"docs":{},"互":{"docs":{},"。":{"docs":{},"此":{"docs":{},"外":{"docs":{},"，":{"docs":{},"在":{"docs":{},"某":{"docs":{},"种":{"docs":{},"程":{"docs":{},"度":{"docs":{},"上":{"docs":{},"，":{"docs":{},"还":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"动":{"docs":{},"态":{"docs":{},"的":{"docs":{},"面":{"docs":{},"向":{"docs":{},"服":{"docs":{},"务":{"docs":{},"计":{"docs":{},"算":{"docs":{},"交":{"docs":{},"互":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"可":{"docs":{},"以":{"docs":{},"对":{"docs":{},"各":{"docs":{},"种":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"上":{"docs":{},"线":{"docs":{},"、":{"docs":{},"下":{"docs":{},"线":{"docs":{},"作":{"docs":{},"出":{"docs":{},"反":{"docs":{},"应":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"现":{"docs":{},"成":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"但":{"docs":{},"你":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"添":{"docs":{},"加":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"来":{"docs":{},"从":{"docs":{},"其":{"docs":{},"他":{"docs":{},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"技":{"docs":{},"术":{"docs":{},"中":{"docs":{},"导":{"docs":{},"入":{"docs":{},"和":{"docs":{},"导":{"docs":{},"出":{"docs":{},"服":{"docs":{},"务":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"实":{"docs":{},"现":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"概":{"docs":{},"念":{"docs":{},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"这":{"docs":{},"种":{"docs":{},"差":{"docs":{},"异":{"docs":{},"。":{"docs":{},"每":{"docs":{},"种":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"都":{"docs":{},"需":{"docs":{},"要":{"docs":{},"定":{"docs":{},"义":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"除":{"docs":{},"了":{"docs":{},"支":{"docs":{},"持":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"机":{"docs":{},"制":{"docs":{},"以":{"docs":{},"外":{"docs":{},"，":{"docs":{},"还":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"现":{"docs":{},"成":{"docs":{},"的":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"下":{"docs":{},"列":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"加":{"docs":{},"入":{"docs":{},"到":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"配":{"docs":{},"置":{"docs":{},"中":{"docs":{},"文":{"docs":{},"件":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}},"存":{"docs":{},"储":{"docs":{},"后":{"docs":{},"端":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"对":{"docs":{},"象":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"为":{"docs":{},"服":{"docs":{},"务":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"条":{"docs":{},"获":{"docs":{},"取":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"通":{"docs":{},"道":{"docs":{},"，":{"docs":{},"它":{"docs":{},"有":{"docs":{},"各":{"docs":{},"种":{"docs":{},"实":{"docs":{},"现":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"一":{"docs":{},"个":{"docs":{},"代":{"docs":{},"理":{"docs":{},"对":{"docs":{},"象":{"docs":{},"、":{"docs":{},"一":{"docs":{},"个":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"对":{"docs":{},"象":{"docs":{},"、":{"docs":{},"甚":{"docs":{},"至":{"docs":{},"某":{"docs":{},"些":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"可":{"docs":{},"能":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"这":{"docs":{},"样":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"表":{"docs":{},"现":{"docs":{},"有":{"docs":{},"赖":{"docs":{},"于":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"就":{"docs":{},"是":{"docs":{},"资":{"docs":{},"源":{"docs":{},"。":{"docs":{},"有":{"docs":{},"很":{"docs":{},"多":{"docs":{},"各":{"docs":{},"种":{"docs":{},"各":{"docs":{},"样":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"功":{"docs":{},"能":{"docs":{},"性":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"组":{"docs":{},"件":{"docs":{},"、":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"、":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"引":{"docs":{},"用":{"docs":{},"代":{"docs":{},"表":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"和":{"docs":{},"发":{"docs":{},"布":{"docs":{},"者":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"创":{"docs":{},"建":{"docs":{},"他":{"docs":{},"们":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}},"是":{"docs":{},"提":{"docs":{},"供":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"实":{"docs":{},"体":{"docs":{},"，":{"docs":{},"而":{"docs":{},"发":{"docs":{},"布":{"docs":{},"者":{"docs":{},"的":{"docs":{},"职":{"docs":{},"责":{"docs":{},"是":{"docs":{},"发":{"docs":{},"布":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"该":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"服":{"docs":{},"务":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{},"服":{"docs":{},"务":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"和":{"docs":{},"发":{"docs":{},"布":{"docs":{},"者":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"体":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"实":{"docs":{},"体":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"搜":{"docs":{},"索":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"空":{"docs":{},"间":{"docs":{},"（":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"）":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"种":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"，":{"docs":{},"是":{"docs":{},"基":{"docs":{},"于":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"在":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"访":{"docs":{},"问":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"步":{"docs":{},"骤":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}},"通":{"docs":{},"过":{"docs":{},"传":{"docs":{},"递":{"docs":{},"一":{"docs":{},"个":{"docs":{},"过":{"docs":{},"滤":{"docs":{},"器":{"docs":{},"来":{"docs":{},"选":{"docs":{},"择":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"有":{"docs":{},"两":{"docs":{},"种":{"docs":{},"形":{"docs":{},"式":{"docs":{},"的":{"docs":{},"过":{"docs":{},"滤":{"docs":{},"器":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}}}}},"记":{"docs":{},"录":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"按":{"docs":{},"照":{"docs":{},"如":{"docs":{},"下":{"docs":{},"的":{"docs":{},"步":{"docs":{},"骤":{"docs":{},"进":{"docs":{},"行":{"docs":{},"创":{"docs":{},"建":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}},"的":{"docs":{},"元":{"docs":{},"数":{"docs":{},"据":{"docs":{},"、":{"docs":{},"甚":{"docs":{},"至":{"docs":{},"位":{"docs":{},"置":{"docs":{},"的":{"docs":{},"格":{"docs":{},"式":{"docs":{},"，":{"docs":{},"都":{"docs":{},"有":{"docs":{},"赖":{"docs":{},"于":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"详":{"docs":{},"见":{"docs":{},"后":{"docs":{},"续":{"docs":{},"章":{"docs":{},"节":{"docs":{},"）":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"名":{"docs":{},"称":{"docs":{},"就":{"docs":{},"是":{"docs":{},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}},"映":{"docs":{},"射":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"使":{"docs":{},"用":{"docs":{},"者":{"docs":{},"从":{"docs":{},"实":{"docs":{},"际":{"docs":{},"被":{"docs":{},"部":{"docs":{},"署":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"中":{"docs":{},"解":{"docs":{},"耦":{"docs":{},"是":{"docs":{},"很":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"允":{"docs":{},"许":{"docs":{},"服":{"docs":{},"务":{"docs":{},"提":{"docs":{},"供":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"部":{"docs":{},"署":{"docs":{},"参":{"docs":{},"数":{"docs":{},"和":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"描":{"docs":{},"述":{"docs":{},"符":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}},"要":{"docs":{},"实":{"docs":{},"现":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"类":{"docs":{},"（":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}},"接":{"docs":{},"口":{"docs":{},"中":{"docs":{},"不":{"docs":{},"允":{"docs":{},"许":{"docs":{},"有":{"docs":{},"重":{"docs":{},"载":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"方":{"docs":{},"法":{"docs":{},"（":{"docs":{},"即":{"docs":{},"方":{"docs":{},"法":{"docs":{},"名":{"docs":{},"相":{"docs":{},"同":{"docs":{},"，":{"docs":{},"参":{"docs":{},"数":{"docs":{},"列":{"docs":{},"表":{"docs":{},"不":{"docs":{},"同":{"docs":{},"）":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"约":{"docs":{},"束":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}},"方":{"docs":{},"法":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"通":{"docs":{},"过":{"docs":{},"向":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"传":{"docs":{},"递":{"docs":{},"一":{"docs":{},"个":{"docs":{},"失":{"docs":{},"败":{"docs":{},"状":{"docs":{},"态":{"docs":{},"的":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{},"端":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"接":{"docs":{},"口":{"docs":{},"包":{"docs":{},"含":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"异":{"docs":{},"步":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{},"在":{"docs":{},"底":{"docs":{},"层":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"调":{"docs":{},"用":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"调":{"docs":{},"用":{"docs":{},"端":{"docs":{},"向":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"条":{"docs":{},"目":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"您":{"docs":{},"的":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"查":{"docs":{},"看":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"询":{"docs":{},"/":{"docs":{},"审":{"docs":{},"问":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"阶":{"docs":{},"段":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"部":{"docs":{},"分":{"docs":{},"应":{"docs":{},"该":{"docs":{},"是":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"单":{"docs":{},"个":{"docs":{},"文":{"docs":{},"档":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"包":{"docs":{},"装":{"docs":{},"成":{"docs":{},"了":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"（":{"docs":{},"原":{"docs":{},"生":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"）":{"docs":{},"传":{"docs":{},"给":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"时":{"docs":{},"，":{"docs":{},"不":{"docs":{},"会":{"docs":{},"经":{"docs":{},"过":{"docs":{},"任":{"docs":{},"何":{"docs":{},"修":{"docs":{},"改":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}},"超":{"docs":{},"时":{"docs":{},"时":{"docs":{},"间":{"docs":{},"（":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"）":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}},"辅":{"docs":{},"助":{"docs":{},"方":{"docs":{},"法":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"找":{"docs":{},"产":{"docs":{},"品":{"docs":{},"信":{"docs":{},"息":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"文":{"docs":{},"档":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"各":{"docs":{},"种":{"docs":{},"服":{"docs":{},"务":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"服":{"docs":{},"务":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}},"满":{"docs":{},"足":{"docs":{},"它":{"docs":{},"需":{"docs":{},"求":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}},"标":{"docs":{},"准":{"docs":{},"安":{"docs":{},"全":{"docs":{},"最":{"docs":{},"佳":{"docs":{},"实":{"docs":{},"践":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}},"记":{"docs":{},"在":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"时":{"docs":{},"或":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"停":{"docs":{},"止":{"docs":{},"时":{"docs":{},"要":{"docs":{},"删":{"docs":{},"除":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"识":{"docs":{},"的":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"选":{"docs":{},"项":{"docs":{},"至":{"docs":{},"少":{"docs":{},"必":{"docs":{},"须":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"长":{"docs":{},"名":{"docs":{},"或":{"docs":{},"一":{"docs":{},"个":{"docs":{},"短":{"docs":{},"名":{"docs":{},"。":{"docs":{},"长":{"docs":{},"名":{"docs":{},"称":{"docs":{},"通":{"docs":{},"常":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"符":{"docs":{"services/ServiceFactories.html":{"ref":"services/ServiceFactories.html","tf":0.009345794392523364}}}},"示":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"会":{"docs":{},"使":{"docs":{},"用":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"样":{"docs":{},"式":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"例":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"根":{"docs":{},"据":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"您":{"docs":{},"的":{"docs":{},"集":{"docs":{},"群":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"需":{"docs":{},"要":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"配":{"docs":{},"置":{"docs":{},"（":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"）":{"docs":{},"和":{"docs":{},"/":{"docs":{},"或":{"docs":{},"添":{"docs":{},"加":{"docs":{},"集":{"docs":{},"群":{"docs":{},"主":{"docs":{},"机":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"可":{"docs":{},"能":{"docs":{},"需":{"docs":{},"要":{"docs":{},"添":{"docs":{},"加":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"你":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"需":{"docs":{},"要":{"docs":{},"，":{"docs":{},"你":{"docs":{},"同":{"docs":{},"样":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"下":{"docs":{},"边":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"改":{"docs":{},"变":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"集":{"docs":{},"合":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"和":{"docs":{},"列":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"）":{"docs":{},"名":{"docs":{},"称":{"docs":{},"等":{"docs":{},"信":{"docs":{},"息":{"docs":{},"：":{"docs":{"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"路":{"docs":{},"径":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}},"格":{"docs":{},"式":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"格":{"docs":{},"式":{"docs":{},"为":{"docs":{},"：":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}},"来":{"docs":{},"发":{"docs":{},"送":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"创":{"docs":{},"建":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"数":{"docs":{},"据":{"docs":{},"也":{"docs":{},"能":{"docs":{},"够":{"docs":{},"一":{"docs":{},"行":{"docs":{},"行":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"并":{"docs":{},"将":{"docs":{},"其":{"docs":{},"映":{"docs":{},"射":{"docs":{},"为":{"docs":{},"对":{"docs":{},"象":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}},"编":{"docs":{},"码":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"错":{"docs":{},"误":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"检":{"docs":{},"测":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"存":{"docs":{},"在":{"docs":{},"以":{"docs":{},"及":{"docs":{},"删":{"docs":{},"除":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"查":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"户":{"docs":{},"是":{"docs":{},"否":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"特":{"docs":{},"定":{"docs":{},"权":{"docs":{},"限":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"的":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"u":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"索":{"docs":{},"到":{"docs":{},"新":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"最":{"docs":{},"近":{"docs":{},"一":{"docs":{},"次":{"docs":{},"获":{"docs":{},"取":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"内":{"docs":{},"容":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}},"概":{"docs":{},"念":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"使":{"docs":{},"用":{"docs":{},"标":{"docs":{},"准":{"docs":{},"单":{"docs":{},"词":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"欲":{"docs":{},"了":{"docs":{},"解":{"docs":{},"有":{"docs":{},"关":{"docs":{},"在":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"执":{"docs":{},"行":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"正":{"docs":{},"如":{"docs":{},"您":{"docs":{},"在":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"中":{"docs":{},"可":{"docs":{},"看":{"docs":{},"到":{"docs":{},"的":{"docs":{},"，":{"docs":{},"该":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"要":{"docs":{},"么":{"docs":{},"是":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"则":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"同":{"docs":{},"样":{"docs":{},"也":{"docs":{},"可":{"docs":{},"用":{"docs":{},"于":{"docs":{},"在":{"docs":{},"路":{"docs":{},"由":{"docs":{},"时":{"docs":{},"匹":{"docs":{},"配":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"常":{"docs":{},"运":{"docs":{},"行":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}},"调":{"docs":{},"用":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}},"水":{"docs":{},"平":{"docs":{},"扩":{"docs":{},"展":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"没":{"docs":{},"什":{"docs":{},"么":{"docs":{},"特":{"docs":{},"别":{"docs":{},"的":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"任":{"docs":{},"何":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"共":{"docs":{},"享":{"docs":{},"访":{"docs":{},"问":{"docs":{},"可":{"docs":{},"变":{"docs":{},"状":{"docs":{},"态":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"您":{"docs":{},"不":{"docs":{},"必":{"docs":{},"担":{"docs":{},"心":{"docs":{},"需":{"docs":{},"要":{"docs":{},"通":{"docs":{},"过":{"docs":{},"同":{"docs":{},"步":{"docs":{},"访":{"docs":{},"问":{"docs":{},"来":{"docs":{},"保":{"docs":{},"护":{"docs":{},"该":{"docs":{},"状":{"docs":{},"态":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"直":{"docs":{},"接":{"docs":{},"结":{"docs":{},"束":{"docs":{},"响":{"docs":{},"应":{"docs":{},"，":{"docs":{},"发":{"docs":{},"回":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"接":{"docs":{},"收":{"docs":{},"消":{"docs":{},"息":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"对":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"找":{"docs":{},"到":{"docs":{},"给":{"docs":{},"定":{"docs":{},"查":{"docs":{},"询":{"docs":{},"的":{"docs":{},"记":{"docs":{},"录":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"放":{"docs":{},"之":{"docs":{},"四":{"docs":{},"海":{"docs":{},"而":{"docs":{},"皆":{"docs":{},"准":{"docs":{},"的":{"docs":{},"策":{"docs":{},"略":{"docs":{},"，":{"docs":{},"缺":{"docs":{},"省":{"docs":{},"的":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"策":{"docs":{},"略":{"docs":{},"可":{"docs":{},"能":{"docs":{},"不":{"docs":{},"能":{"docs":{},"满":{"docs":{},"足":{"docs":{},"您":{"docs":{},"的":{"docs":{},"需":{"docs":{},"要":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"策":{"docs":{},"略":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"实":{"docs":{},"现":{"docs":{},"更":{"docs":{},"改":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"新":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"需":{"docs":{},"要":{"docs":{},"处":{"docs":{},"理":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}},"完":{"docs":{},"成":{"docs":{},"的":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}},"泵":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"（":{"docs":{},"p":{"docs":{},"u":{"docs":{},"m":{"docs":{},"p":{"docs":{},"）":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"有":{"docs":{},"以":{"docs":{},"下":{"docs":{},"几":{"docs":{},"种":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"流":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"中":{"docs":{},"无":{"docs":{},"效":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"和":{"docs":{},"管":{"docs":{},"道":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"（":{"docs":{},"泵":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"式":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"的":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"所":{"docs":{},"需":{"docs":{},"要":{"docs":{},"发":{"docs":{},"送":{"docs":{},"的":{"docs":{},"最":{"docs":{},"小":{"docs":{},"字":{"docs":{},"节":{"docs":{},"数":{"docs":{},"。":{"docs":{},"超":{"docs":{},"过":{"docs":{},"这":{"docs":{},"个":{"docs":{},"值":{"docs":{},"则":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"需":{"docs":{},"要":{"docs":{},"打":{"docs":{},"开":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{},"将":{"docs":{},"这":{"docs":{},"个":{"docs":{},"值":{"docs":{},"设":{"docs":{},"置":{"docs":{},"得":{"docs":{},"过":{"docs":{},"小":{"docs":{},"会":{"docs":{},"失":{"docs":{},"去":{"docs":{},"流":{"docs":{},"式":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"能":{"docs":{},"力":{"docs":{},"，":{"docs":{},"使":{"docs":{},"这":{"docs":{},"个":{"docs":{},"流":{"docs":{},"式":{"docs":{},"的":{"docs":{},"传":{"docs":{},"输":{"docs":{},"方":{"docs":{},"式":{"docs":{},"表":{"docs":{},"现":{"docs":{},"得":{"docs":{},"像":{"docs":{},"一":{"docs":{},"个":{"docs":{},"轮":{"docs":{},"训":{"docs":{},"的":{"docs":{},"传":{"docs":{},"输":{"docs":{},"方":{"docs":{},"式":{"docs":{},"一":{"docs":{},"样":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"是":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"处":{"docs":{},"理":{"docs":{},"原":{"docs":{},"生":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}},"重":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"量":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"控":{"docs":{},"制":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"程":{"docs":{},"的":{"docs":{},"细":{"docs":{},"节":{"docs":{},"、":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"j":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"与":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"方":{"docs":{},"面":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"请":{"docs":{},"查":{"docs":{},"阅":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"中":{"docs":{},"的":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"帧":{"docs":{},"标":{"docs":{},"记":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"会":{"docs":{},"被":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"写":{"docs":{},"入":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"发":{"docs":{},"送":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"因":{"docs":{},"为":{"docs":{},"其":{"docs":{},"他":{"docs":{},"原":{"docs":{},"因":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"由":{"docs":{},"多":{"docs":{},"个":{"docs":{},"帧":{"docs":{},"组":{"docs":{},"成":{"docs":{},"，":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"第":{"docs":{},"一":{"docs":{},"帧":{"docs":{},"是":{"docs":{},"二":{"docs":{},"进":{"docs":{},"制":{"docs":{},"或":{"docs":{},"文":{"docs":{},"本":{"docs":{},"帧":{"docs":{},"（":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"中":{"docs":{},"被":{"docs":{},"接":{"docs":{},"收":{"docs":{},"。":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{},"地":{"docs":{},"址":{"docs":{},"上":{"docs":{},"注":{"docs":{},"册":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"接":{"docs":{},"收":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"大":{"docs":{},"于":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"象":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"将":{"docs":{},"被":{"docs":{},"发":{"docs":{},"布":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"地":{"docs":{},"址":{"docs":{},"中":{"docs":{},"，":{"docs":{},"发":{"docs":{},"布":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"会":{"docs":{},"将":{"docs":{},"信":{"docs":{},"息":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"送":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"地":{"docs":{},"址":{"docs":{},"中":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"将":{"docs":{},"会":{"docs":{},"把":{"docs":{},"消":{"docs":{},"息":{"docs":{},"分":{"docs":{},"发":{"docs":{},"到":{"docs":{},"某":{"docs":{},"个":{"docs":{},"注":{"docs":{},"册":{"docs":{},"在":{"docs":{},"该":{"docs":{},"地":{"docs":{},"址":{"docs":{},"上":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"若":{"docs":{},"这":{"docs":{},"个":{"docs":{},"地":{"docs":{},"址":{"docs":{},"上":{"docs":{},"有":{"docs":{},"不":{"docs":{},"止":{"docs":{},"一":{"docs":{},"个":{"docs":{},"注":{"docs":{},"册":{"docs":{},"过":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"原":{"docs":{},"始":{"docs":{},"内":{"docs":{},"容":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"如":{"docs":{},"下":{"docs":{},"结":{"docs":{},"构":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"、":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"编":{"docs":{},"解":{"docs":{},"码":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"的":{"docs":{},"编":{"docs":{},"码":{"docs":{},"和":{"docs":{},"解":{"docs":{},"码":{"docs":{},"不":{"docs":{},"一":{"docs":{},"定":{"docs":{},"使":{"docs":{},"用":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"编":{"docs":{},"写":{"docs":{},"一":{"docs":{},"个":{"docs":{},"编":{"docs":{},"解":{"docs":{},"码":{"docs":{},"器":{"docs":{},"来":{"docs":{},"发":{"docs":{},"送":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"顺":{"docs":{},"序":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"我":{"docs":{},"们":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"会":{"docs":{},"在":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"端":{"docs":{},"触":{"docs":{},"发":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"由":{"docs":{},"于":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"端":{"docs":{},"配":{"docs":{},"置":{"docs":{},"了":{"docs":{},"期":{"docs":{},"望":{"docs":{},"每":{"docs":{},"隔":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"体":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"于":{"docs":{},"处":{"docs":{},"理":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"地":{"docs":{},"会":{"docs":{},"合":{"docs":{},"并":{"docs":{},"表":{"docs":{},"单":{"docs":{},"属":{"docs":{},"性":{"docs":{},"到":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"里":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"长":{"docs":{},"度":{"docs":{},"限":{"docs":{},"制":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"（":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}},"头":{"docs":{},"。":{"docs":{},"假":{"docs":{},"设":{"docs":{},"我":{"docs":{},"们":{"docs":{},"要":{"docs":{},"构":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"中":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"了":{"docs":{},"不":{"docs":{},"止":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"匹":{"docs":{},"配":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"多":{"docs":{},"个":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"并":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"识":{"docs":{},"别":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"偏":{"docs":{},"好":{"docs":{},"的":{"docs":{},"语":{"docs":{},"言":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"提":{"docs":{},"供":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"于":{"docs":{},"表":{"docs":{},"示":{"docs":{},"哪":{"docs":{},"些":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"值":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}},"子":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"请":{"docs":{},"求":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"部":{"docs":{},"分":{"docs":{},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"顶":{"docs":{},"级":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"表":{"docs":{},"示":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"只":{"docs":{},"接":{"docs":{},"受":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}},"里":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"(":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"，":{"docs":{},"作":{"docs":{},"为":{"docs":{},"要":{"docs":{},"执":{"docs":{},"行":{"docs":{},"操":{"docs":{},"作":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}},"授":{"docs":{},"权":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"流":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}},"然":{"docs":{},"后":{"docs":{},"拿":{"docs":{},"到":{"docs":{},"回":{"docs":{},"应":{"docs":{},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}},"源":{"docs":{},"服":{"docs":{},"务":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"的":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"是":{"docs":{},"消":{"docs":{},"息":{"docs":{},"所":{"docs":{},"发":{"docs":{},"送":{"docs":{},"的":{"docs":{},"e":{"docs":{},"v":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"（":{"docs":{},"其":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"表":{"docs":{},"现":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"e":{"docs":{},"v":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"费":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}},"者":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"感":{"docs":{},"兴":{"docs":{},"趣":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"组":{"docs":{},"内":{"docs":{},"的":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"可":{"docs":{},"以":{"docs":{},"消":{"docs":{},"费":{"docs":{},"某":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"源":{"docs":{},"服":{"docs":{},"务":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"清":{"docs":{},"理":{"docs":{},"工":{"docs":{},"作":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"它":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"源":{"docs":{},"代":{"docs":{},"码":{"docs":{},"文":{"docs":{},"件":{"docs":{},"执":{"docs":{},"行":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"编":{"docs":{},"译":{"docs":{},"，":{"docs":{},"这":{"docs":{},"对":{"docs":{},"于":{"docs":{},"快":{"docs":{},"速":{"docs":{},"原":{"docs":{},"型":{"docs":{},"制":{"docs":{},"作":{"docs":{},"和":{"docs":{},"演":{"docs":{},"示":{"docs":{},"很":{"docs":{},"有":{"docs":{},"用":{"docs":{},"。":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"设":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"直":{"docs":{},"接":{"docs":{},"运":{"docs":{},"行":{"docs":{},"它":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"会":{"docs":{},"为":{"docs":{},"你":{"docs":{},"编":{"docs":{},"译":{"docs":{},"它":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"激":{"docs":{},"活":{"docs":{},"该":{"docs":{},"行":{"docs":{},"为":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"点":{"docs":{},"对":{"docs":{},"点":{"docs":{},"模":{"docs":{},"式":{"docs":{},"/":{"docs":{},"请":{"docs":{},"求":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"消":{"docs":{},"息":{"docs":{},"传":{"docs":{},"递":{"docs":{},"模":{"docs":{},"式":{"docs":{},"下":{"docs":{},"，":{"docs":{},"可":{"docs":{},"在":{"docs":{},"消":{"docs":{},"息":{"docs":{},"发":{"docs":{},"送":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"应":{"docs":{},"答":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"可":{"docs":{},"选":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"版":{"docs":{},"本":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"可":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"的":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635}},"扩":{"docs":{},"展":{"docs":{},"机":{"docs":{},"制":{"docs":{},"不":{"docs":{},"好":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"，":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"之":{"docs":{},"间":{"docs":{},"发":{"docs":{},"生":{"docs":{},"了":{"docs":{},"变":{"docs":{},"化":{"docs":{},"，":{"docs":{},"请":{"docs":{},"检":{"docs":{},"查":{"docs":{},"变":{"docs":{},"更":{"docs":{},"日":{"docs":{},"志":{"docs":{},"。":{"docs":{},"老":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"兼":{"docs":{},"容":{"docs":{},"，":{"docs":{},"但":{"docs":{},"新":{"docs":{},"版":{"docs":{},"本":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"更":{"docs":{},"接":{"docs":{},"近":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"样":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"为":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"状":{"docs":{},"态":{"docs":{},"代":{"docs":{},"码":{"docs":{},",":{"docs":{},"如":{"docs":{},":":{"2":{"0":{"0":{"docs":{},"、":{"4":{"0":{"4":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}},"时":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"它":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"由":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"码":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"消":{"docs":{},"息":{"docs":{},",":{"docs":{},"如":{"docs":{},":":{"docs":{},"o":{"docs":{},"k":{"docs":{},"、":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"码":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"会":{"docs":{},"是":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"路":{"docs":{},"由":{"docs":{},"的":{"docs":{},"失":{"docs":{},"败":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"通":{"docs":{},"知":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"使":{"docs":{},"用":{"docs":{},"本":{"docs":{},"地":{"docs":{},"的":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"资":{"docs":{},"源":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"）":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"注":{"docs":{},"册":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}},"环":{"docs":{},"境":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"变":{"docs":{},"量":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}},"中":{"docs":{},"，":{"docs":{},"还":{"docs":{},"要":{"docs":{},"确":{"docs":{},"保":{"docs":{},"您":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"和":{"docs":{},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{},"可":{"docs":{},"以":{"docs":{},"直":{"docs":{},"接":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"，":{"docs":{},"请":{"docs":{},"确":{"docs":{},"保":{"docs":{},"路":{"docs":{},"径":{"docs":{},"下":{"docs":{},"包":{"docs":{},"含":{"docs":{},"所":{"docs":{},"有":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"（":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"里":{"docs":{},"您":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"需":{"docs":{},"要":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"中":{"docs":{},"，":{"docs":{},"但":{"docs":{},"我":{"docs":{},"们":{"docs":{},"却":{"docs":{},"不":{"docs":{},"想":{"docs":{},"通":{"docs":{},"过":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}},"参":{"docs":{},"考":{"docs":{},"上":{"docs":{},"述":{"docs":{},"章":{"docs":{},"节":{"docs":{},"，":{"docs":{},"设":{"docs":{},"置":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"网":{"docs":{},"络":{"docs":{},"接":{"docs":{},"口":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"果":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"中":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"把":{"docs":{},"上":{"docs":{},"面":{"docs":{},"列":{"docs":{},"出":{"docs":{},"的":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}},"现":{"docs":{},"在":{"docs":{},"准":{"docs":{},"备":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"一":{"docs":{},"些":{"docs":{},"东":{"docs":{},"西":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"将":{"docs":{},"接":{"docs":{},"收":{"docs":{},"组":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"开":{"docs":{},"启":{"docs":{},"了":{"docs":{},"h":{"docs":{},"a":{"docs":{},"环":{"docs":{},"境":{"docs":{},"，":{"docs":{},"在":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"需":{"docs":{},"要":{"docs":{},"多":{"docs":{},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"我":{"docs":{},"们":{"docs":{},"来":{"docs":{},"看":{"docs":{},"看":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"都":{"docs":{},"读":{"docs":{},"取":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}},"让":{"docs":{},"我":{"docs":{},"们":{"docs":{},"专":{"docs":{},"注":{"docs":{},"于":{"docs":{},"如":{"docs":{},"何":{"docs":{},"发":{"docs":{},"送":{"docs":{},"多":{"docs":{},"播":{"docs":{},"报":{"docs":{},"文":{"docs":{},"，":{"docs":{},"发":{"docs":{},"送":{"docs":{},"多":{"docs":{},"播":{"docs":{},"报":{"docs":{},"文":{"docs":{},"与":{"docs":{},"发":{"docs":{},"送":{"docs":{},"普":{"docs":{},"通":{"docs":{},"数":{"docs":{},"据":{"docs":{},"报":{"docs":{},"报":{"docs":{},"文":{"docs":{},"没":{"docs":{},"什":{"docs":{},"么":{"docs":{},"不":{"docs":{},"同":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"部":{"docs":{},"署":{"docs":{},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{},"一":{"docs":{},"些":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"种":{"docs":{},"路":{"docs":{},"径":{"docs":{},"访":{"docs":{},"问":{"docs":{},"：":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"1":{"2":{"3":{"4":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"甚":{"docs":{},"至":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"允":{"docs":{},"许":{"docs":{},"在":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"中":{"docs":{},"运":{"docs":{},"行":{"docs":{},"的":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"在":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"e":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"生":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"文":{"docs":{},"件":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"工":{"docs":{},"具":{"docs":{},"是":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"，":{"docs":{},"运":{"docs":{},"行":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"指":{"docs":{},"定":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"算":{"docs":{},"法":{"docs":{},"：":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"文":{"docs":{},"件":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}},"其":{"docs":{},"他":{"docs":{},"语":{"docs":{},"言":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}},"产":{"docs":{},"者":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"用":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"y":{"docs":{},"的":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"的":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"测":{"docs":{},"试":{"docs":{},"和":{"docs":{},"开":{"docs":{},"发":{"docs":{},"目":{"docs":{},"的":{"docs":{},"的":{"docs":{},"自":{"docs":{},"签":{"docs":{},"名":{"docs":{},"证":{"docs":{},"书":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"通":{"docs":{},"用":{"docs":{},"错":{"docs":{},"误":{"docs":{},"：":{"1":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}}}}}},"为":{"docs":{},"用":{"docs":{},"户":{"docs":{},"提":{"docs":{},"供":{"docs":{},"认":{"docs":{},"证":{"docs":{},"和":{"docs":{},"授":{"docs":{},"权":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"监":{"docs":{},"听":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"执":{"docs":{},"行":{"docs":{},"结":{"docs":{},"果":{"docs":{},"状":{"docs":{},"态":{"docs":{},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}},"将":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}}},"创":{"docs":{},"建":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}},"以":{"docs":{},"在":{"docs":{},"发":{"docs":{},"生":{"docs":{},"任":{"docs":{},"何":{"docs":{},"异":{"docs":{},"常":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"接":{"docs":{},"收":{"docs":{},"异":{"docs":{},"常":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"发":{"docs":{},"出":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"不":{"docs":{},"同":{"docs":{},"方":{"docs":{},"式":{"docs":{},"都":{"docs":{},"支":{"docs":{},"持":{"docs":{},"这":{"docs":{},"两":{"docs":{},"种":{"docs":{},"指":{"docs":{},"定":{"docs":{},"主":{"docs":{},"机":{"docs":{},"/":{"docs":{},"端":{"docs":{},"口":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"户":{"docs":{},"是":{"docs":{},"无":{"docs":{},"法":{"docs":{},"直":{"docs":{},"接":{"docs":{},"利":{"docs":{},"用":{"docs":{},"路":{"docs":{},"径":{"docs":{},"访":{"docs":{},"问":{"docs":{},"的":{"docs":{},"。":{"docs":{},"更":{"docs":{},"安":{"docs":{},"全":{"docs":{},"的":{"docs":{},"做":{"docs":{},"法":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"角":{"docs":{},"色":{"docs":{},"/":{"docs":{},"权":{"docs":{},"限":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.014778325123152709}},"授":{"docs":{},"权":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"登":{"docs":{},"录":{"docs":{},"，":{"docs":{},"并":{"docs":{},"被":{"docs":{},"授":{"docs":{},"权":{"docs":{},"才":{"docs":{},"能":{"docs":{},"够":{"docs":{},"访":{"docs":{},"问":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"配":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"凭":{"docs":{},"证":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}},"对":{"docs":{},"象":{"docs":{},"可":{"docs":{},"以":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"任":{"docs":{},"何":{"docs":{},"权":{"docs":{},"限":{"docs":{},"，":{"docs":{},"之":{"docs":{},"后":{"docs":{},"的":{"docs":{},"调":{"docs":{},"用":{"docs":{},"会":{"docs":{},"检":{"docs":{},"查":{"docs":{},"是":{"docs":{},"否":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"权":{"docs":{},"限":{"docs":{},"执":{"docs":{},"行":{"docs":{},"其":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"结":{"docs":{},"果":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"调":{"docs":{},"用":{"docs":{},"了":{"docs":{},"底":{"docs":{},"层":{"docs":{},"提":{"docs":{},"供":{"docs":{},"者":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"默":{"docs":{},"认":{"docs":{},"无":{"docs":{},"权":{"docs":{},"限":{"docs":{},"）":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"集":{"docs":{},"群":{"docs":{},"会":{"docs":{},"话":{"docs":{},"存":{"docs":{},"储":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"内":{"docs":{},"的":{"docs":{},"链":{"docs":{},"接":{"docs":{},"作":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"传":{"docs":{},"入":{"docs":{},"l":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"d":{"docs":{},"a":{"docs":{},"，":{"docs":{},"在":{"docs":{},"l":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"d":{"docs":{},"a":{"docs":{},"中":{"docs":{},"将":{"docs":{},"其":{"docs":{},"设":{"docs":{},"置":{"docs":{},"成":{"docs":{},"发":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"并":{"docs":{},"返":{"docs":{},"回":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"在":{"docs":{},"下":{"docs":{},"一":{"docs":{},"步":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"中":{"docs":{},"予":{"docs":{},"以":{"docs":{},"触":{"docs":{},"发":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"发":{"docs":{},"送":{"docs":{},"文":{"docs":{},"件":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"编":{"docs":{},"码":{"docs":{},"方":{"docs":{},"式":{"docs":{},"提":{"docs":{},"交":{"docs":{},"表":{"docs":{},"单":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}},"分":{"docs":{},"块":{"docs":{},"方":{"docs":{},"式":{"docs":{},"编":{"docs":{},"码":{"docs":{},"提":{"docs":{},"交":{"docs":{},"表":{"docs":{},"单":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"s":{"docs":{},"进":{"docs":{},"行":{"docs":{},"其":{"docs":{},"他":{"docs":{},"操":{"docs":{},"作":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}},"到":{"docs":{},"了":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}},"来":{"docs":{},"确":{"docs":{},"定":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"的":{"docs":{},"网":{"docs":{},"络":{"docs":{},"接":{"docs":{},"口":{"docs":{},",":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}},"由":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"于":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"不":{"docs":{},"提":{"docs":{},"供":{"docs":{},"对":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"资":{"docs":{},"源":{"docs":{},"的":{"docs":{},"异":{"docs":{},"步":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"当":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"资":{"docs":{},"源":{"docs":{},"第":{"docs":{},"一":{"docs":{},"次":{"docs":{},"被":{"docs":{},"访":{"docs":{},"问":{"docs":{},"时":{"docs":{},"，":{"docs":{},"该":{"docs":{},"文":{"docs":{},"件":{"docs":{},"将":{"docs":{},"复":{"docs":{},"制":{"docs":{},"到":{"docs":{},"工":{"docs":{},"作":{"docs":{},"线":{"docs":{},"程":{"docs":{},"中":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"。":{"docs":{},"当":{"docs":{},"第":{"docs":{},"二":{"docs":{},"次":{"docs":{},"访":{"docs":{},"问":{"docs":{},"相":{"docs":{},"同":{"docs":{},"资":{"docs":{},"源":{"docs":{},"时":{"docs":{},"，":{"docs":{},"访":{"docs":{},"问":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"直":{"docs":{},"接":{"docs":{},"从":{"docs":{},"（":{"docs":{},"工":{"docs":{},"作":{"docs":{},"线":{"docs":{},"程":{"docs":{},"的":{"docs":{},"）":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"提":{"docs":{},"供":{"docs":{},"。":{"docs":{},"即":{"docs":{},"使":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"资":{"docs":{},"源":{"docs":{},"发":{"docs":{},"生":{"docs":{},"变":{"docs":{},"化":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"开":{"docs":{},"发":{"docs":{},"系":{"docs":{},"统":{"docs":{},"中":{"docs":{},"）":{"docs":{},"，":{"docs":{},"也":{"docs":{},"会":{"docs":{},"提":{"docs":{},"供":{"docs":{},"原":{"docs":{},"始":{"docs":{},"内":{"docs":{},"容":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"命":{"docs":{},"令":{"docs":{},"产":{"docs":{},"生":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"进":{"docs":{},"程":{"docs":{},"，":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"选":{"docs":{},"项":{"docs":{},"不":{"docs":{},"会":{"docs":{},"被":{"docs":{},"传":{"docs":{},"播":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"您":{"docs":{},"必":{"docs":{},"须":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"或":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"中":{"docs":{},"没":{"docs":{},"有":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"，":{"docs":{},"e":{"docs":{},"v":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"多":{"docs":{},"语":{"docs":{},"言":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"当":{"docs":{},"你":{"docs":{},"从":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"、":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"y":{"docs":{},"或":{"docs":{},"其":{"docs":{},"他":{"docs":{},"语":{"docs":{},"言":{"docs":{},"中":{"docs":{},"获":{"docs":{},"取":{"docs":{},"服":{"docs":{},"务":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"有":{"docs":{},"差":{"docs":{},"异":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"没":{"docs":{},"有":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"，":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"远":{"docs":{},"程":{"docs":{},"方":{"docs":{},"应":{"docs":{},"该":{"docs":{},"确":{"docs":{},"认":{"docs":{},"接":{"docs":{},"收":{"docs":{},"者":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"更":{"docs":{},"新":{"docs":{},"，":{"docs":{},"也":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"在":{"docs":{},"回":{"docs":{},"调":{"docs":{},"中":{"docs":{},"接":{"docs":{},"收":{"docs":{},"确":{"docs":{},"认":{"docs":{},"通":{"docs":{},"知":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"话":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"它":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"所":{"docs":{},"有":{"docs":{},"异":{"docs":{},"步":{"docs":{},"执":{"docs":{},"行":{"docs":{},"之":{"docs":{},"前":{"docs":{},"处":{"docs":{},"理":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"要":{"docs":{},"尽":{"docs":{},"可":{"docs":{},"能":{"docs":{},"早":{"docs":{},"地":{"docs":{},"设":{"docs":{},"置":{"docs":{},"到":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"会":{"docs":{},"在":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"里":{"docs":{},"写":{"docs":{},"入":{"docs":{},"响":{"docs":{},"应":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"需":{"docs":{},"要":{"docs":{},"启":{"docs":{},"用":{"docs":{},"分":{"docs":{},"块":{"docs":{},"传":{"docs":{},"输":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"a":{"docs":{},"f":{"docs":{},"k":{"docs":{},"a":{"docs":{},"的":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"会":{"docs":{},"组":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"消":{"docs":{},"费":{"docs":{},"组":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"容":{"docs":{},"器":{"docs":{},"只":{"docs":{},"在":{"docs":{},"启":{"docs":{},"动":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"创":{"docs":{},"建":{"docs":{},"链":{"docs":{},"接":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"这":{"docs":{},"个":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"只":{"docs":{},"会":{"docs":{},"在":{"docs":{},"启":{"docs":{},"动":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"导":{"docs":{},"入":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"此":{"docs":{},"后":{"docs":{},"就":{"docs":{},"都":{"docs":{},"不":{"docs":{},"改":{"docs":{},"变":{"docs":{},"了":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"此":{"docs":{},"引":{"docs":{},"入":{"docs":{},"了":{"docs":{},"下":{"docs":{},"面":{"docs":{},"一":{"docs":{},"些":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"的":{"docs":{},"重":{"docs":{},"要":{"docs":{},"概":{"docs":{},"念":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"围":{"docs":{},"绕":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"和":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"构":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"庞":{"docs":{},"大":{"docs":{},"的":{"docs":{},"分":{"docs":{},"布":{"docs":{},"式":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"组":{"docs":{},"成":{"docs":{},"，":{"docs":{},"里":{"docs":{},"面":{"docs":{},"包":{"docs":{},"含":{"docs":{},"访":{"docs":{},"问":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"的":{"docs":{},"各":{"docs":{},"种":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"j":{"docs":{},"d":{"docs":{},"b":{"docs":{},"c":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"多":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"部":{"docs":{},"分":{"docs":{},"构":{"docs":{},"成":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}},"监":{"docs":{},"听":{"docs":{},"随":{"docs":{},"机":{"docs":{},"端":{"docs":{},"口":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"服":{"docs":{},"务":{"docs":{},"的":{"docs":{},"上":{"docs":{},"线":{"docs":{},"、":{"docs":{},"下":{"docs":{},"线":{"docs":{},"和":{"docs":{},"状":{"docs":{},"态":{"docs":{},"变":{"docs":{},"更":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}},"与":{"docs":{},"下":{"docs":{},"线":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"使":{"docs":{},"用":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"配":{"docs":{},"置":{"docs":{},"变":{"docs":{},"更":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"直":{"docs":{},"接":{"docs":{},"从":{"docs":{},"磁":{"docs":{},"盘":{"docs":{},"或":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"写":{"docs":{},"入":{"docs":{},"数":{"docs":{},"据":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"通":{"docs":{},"过":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{},"连":{"docs":{},"接":{"docs":{},"完":{"docs":{},"成":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"相":{"docs":{},"互":{"docs":{},"通":{"docs":{},"信":{"docs":{},"，":{"docs":{},"无":{"docs":{},"论":{"docs":{},"它":{"docs":{},"们":{"docs":{},"使":{"docs":{},"用":{"docs":{},"哪":{"docs":{},"一":{"docs":{},"种":{"docs":{},"语":{"docs":{},"言":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"无":{"docs":{},"论":{"docs":{},"它":{"docs":{},"们":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"反":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"收":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"在":{"docs":{},"收":{"docs":{},"到":{"docs":{},"新":{"docs":{},"的":{"docs":{},"远":{"docs":{},"程":{"docs":{},"设":{"docs":{},"置":{"docs":{},"时":{"docs":{},"会":{"docs":{},"通":{"docs":{},"知":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"它":{"docs":{},"内":{"docs":{},"部":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"维":{"docs":{},"护":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"当":{"docs":{},"传":{"docs":{},"入":{"docs":{},"新":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"以":{"docs":{},"轮":{"docs":{},"询":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"将":{"docs":{},"其":{"docs":{},"分":{"docs":{},"发":{"docs":{},"给":{"docs":{},"任":{"docs":{},"意":{"docs":{},"一":{"docs":{},"个":{"docs":{},"连":{"docs":{},"接":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"处":{"docs":{},"理":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"应":{"docs":{},"示":{"docs":{},"例":{"docs":{},"来":{"docs":{},"了":{"docs":{},"解":{"docs":{},"如":{"docs":{},"何":{"docs":{},"将":{"docs":{},"应":{"docs":{},"用":{"docs":{},"打":{"docs":{},"包":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"比":{"docs":{},"选":{"docs":{},"项":{"docs":{},"，":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"可":{"docs":{},"以":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"同":{"docs":{},"方":{"docs":{},"式":{"docs":{},"配":{"docs":{},"置":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},"协":{"docs":{},"议":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}},"关":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"命":{"docs":{},"令":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}},"看":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"会":{"docs":{},"更":{"docs":{},"清":{"docs":{},"楚":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.006369426751592357}}}}}}}},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}},"知":{"docs":{},"道":{"docs":{},"它":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"禁":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"磁":{"docs":{},"盘":{"docs":{},"文":{"docs":{},"件":{"docs":{},"缓":{"docs":{},"存":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"止":{"docs":{},"访":{"docs":{},"问":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"种":{"docs":{},"类":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"秒":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"之":{"docs":{},"后":{"docs":{},"发":{"docs":{},"出":{"docs":{},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"内":{"docs":{},"没":{"docs":{},"有":{"docs":{},"从":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"返":{"docs":{},"回":{"docs":{},"时":{"docs":{},"触":{"docs":{},"发":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"个":{"docs":{},"心":{"docs":{},"跳":{"docs":{},"包":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"个":{"docs":{},"设":{"docs":{},"置":{"docs":{},"来":{"docs":{},"控":{"docs":{},"制":{"docs":{},"频":{"docs":{},"率":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"后":{"docs":{},"自":{"docs":{},"动":{"docs":{},"超":{"docs":{},"时":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"调":{"docs":{},"用":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}},"收":{"docs":{},"到":{"docs":{},"一":{"docs":{},"条":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"该":{"docs":{},"会":{"docs":{},"话":{"docs":{},"没":{"docs":{},"有":{"docs":{},"收":{"docs":{},"到":{"docs":{},"新":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"则":{"docs":{},"会":{"docs":{},"认":{"docs":{},"为":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"断":{"docs":{},"开":{"docs":{},"了":{"docs":{},"连":{"docs":{},"接":{"docs":{},"，":{"docs":{},"会":{"docs":{},"话":{"docs":{},"过":{"docs":{},"期":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"钟":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}},"稍":{"docs":{},"后":{"docs":{},"当":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"事":{"docs":{},"件":{"docs":{},"要":{"docs":{},"传":{"docs":{},"给":{"docs":{},"您":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"空":{"docs":{},"的":{"docs":{},"。":{"docs":{},"它":{"docs":{},"不":{"docs":{},"会":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"填":{"docs":{},"满":{"docs":{},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"闲":{"docs":{},"连":{"docs":{},"接":{"docs":{},"保":{"docs":{},"留":{"docs":{},"时":{"docs":{},"间":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"0":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}},"docs":{}}}}}}}}}}}},"突":{"docs":{},"然":{"docs":{},"挂":{"docs":{},"掉":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"章":{"docs":{},"节":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612}}},"了":{"docs":{},"解":{"docs":{},"更":{"docs":{},"多":{"docs":{},"事":{"docs":{},"件":{"docs":{},"总":{"docs":{},"线":{"docs":{},"集":{"docs":{},"群":{"docs":{},"细":{"docs":{},"节":{"docs":{},"）":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"通":{"docs":{},"常":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"您":{"docs":{},"将":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"另":{"docs":{},"一":{"docs":{},"种":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"的":{"docs":{},"限":{"docs":{},"制":{"docs":{},"或":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"它":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}},"来":{"docs":{},"了":{"docs":{},"解":{"docs":{},"详":{"docs":{},"细":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"端":{"docs":{},"口":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"，":{"docs":{},"当":{"docs":{},"这":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"（":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"主":{"docs":{},"机":{"docs":{},"名":{"docs":{},"是":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},",":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}},"点":{"docs":{},"(":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"，":{"docs":{},"就":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"服":{"docs":{},"务":{"docs":{},"带":{"docs":{},"有":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"标":{"docs":{},"签":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"的":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"(":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},")":{"docs":{},"属":{"docs":{},"性":{"docs":{},"将":{"docs":{},"被":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"第":{"docs":{},"一":{"docs":{},"次":{"docs":{},"写":{"docs":{},"入":{"docs":{},"操":{"docs":{},"作":{"docs":{},"会":{"docs":{},"触":{"docs":{},"发":{"docs":{},"响":{"docs":{},"应":{"docs":{},"头":{"docs":{},"的":{"docs":{},"写":{"docs":{},"入":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"若":{"docs":{},"您":{"docs":{},"不":{"docs":{},"使":{"docs":{},"用":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"种":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"指":{"docs":{},"定":{"docs":{},"包":{"docs":{},"含":{"docs":{},"密":{"docs":{},"钥":{"docs":{},"和":{"docs":{},"证":{"docs":{},"书":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"证":{"docs":{},"书":{"docs":{},"和":{"docs":{},"私":{"docs":{},"钥":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"密":{"docs":{},"钥":{"docs":{},"库":{"docs":{},"位":{"docs":{},"置":{"docs":{},"。":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"颁":{"docs":{},"发":{"docs":{},"机":{"docs":{},"构":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"受":{"docs":{},"信":{"docs":{},"库":{"docs":{},"的":{"docs":{},"位":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"实":{"docs":{},"例":{"docs":{},"上":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"式":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"示":{"docs":{},"例":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}},"步":{"docs":{},"，":{"docs":{},"你":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"向":{"docs":{},"用":{"docs":{},"户":{"docs":{},"申":{"docs":{},"请":{"docs":{},"允":{"docs":{},"许":{"docs":{},"访":{"docs":{},"问":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"用":{"docs":{},"户":{"docs":{},"审":{"docs":{},"批":{"docs":{},"后":{"docs":{},"，":{"docs":{},"o":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"2":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"发":{"docs":{},"送":{"docs":{},"给":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"一":{"docs":{},"个":{"docs":{},"授":{"docs":{},"权":{"docs":{},"码":{"docs":{},"；":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"二":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"您":{"docs":{},"提":{"docs":{},"供":{"docs":{},"给":{"docs":{},"您":{"docs":{},"的":{"docs":{},"提":{"docs":{},"供":{"docs":{},"商":{"docs":{},"的":{"docs":{},"回":{"docs":{},"调":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"步":{"docs":{},"，":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"将":{"docs":{},"这":{"docs":{},"个":{"docs":{},"授":{"docs":{},"权":{"docs":{},"码":{"docs":{},"和":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"密":{"docs":{},"钥":{"docs":{},"放":{"docs":{},"到":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"发":{"docs":{},"送":{"docs":{},"给":{"docs":{},"授":{"docs":{},"权":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"（":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"等":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"其":{"docs":{},"他":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"第":{"docs":{},"三":{"docs":{},"方":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}},"待":{"docs":{},"一":{"docs":{},"个":{"docs":{},"互":{"docs":{},"斥":{"docs":{},"信":{"docs":{},"号":{"docs":{},"或":{"docs":{},"监":{"docs":{},"视":{"docs":{},"器":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"同":{"docs":{},"步":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"锁":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"部":{"docs":{},"署":{"docs":{},"完":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"）":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"将":{"docs":{},"被":{"docs":{},"重":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"概":{"docs":{},"念":{"docs":{},"，":{"docs":{},"只":{"docs":{},"是":{"docs":{},"进":{"docs":{},"程":{"docs":{},"内":{"docs":{},"的":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"跳":{"docs":{},"转":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"等":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"接":{"docs":{},"口":{"docs":{},"例":{"docs":{},"子":{"docs":{},"来":{"docs":{},"了":{"docs":{},"解":{"docs":{},"这":{"docs":{},"种":{"docs":{},"设":{"docs":{},"计":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}},"算":{"docs":{},"法":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"压":{"docs":{},"缩":{"docs":{},"过":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"来":{"docs":{},"快":{"docs":{},"速":{"docs":{},"计":{"docs":{},"算":{"docs":{},"元":{"docs":{},"素":{"docs":{},"基":{"docs":{},"数":{"docs":{},"的":{"docs":{},"相":{"docs":{},"关":{"docs":{},"命":{"docs":{},"令":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}},"管":{"docs":{},"道":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"在":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"响":{"docs":{},"应":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"在":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"连":{"docs":{},"接":{"docs":{},"上":{"docs":{},"发":{"docs":{},"送":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"管":{"docs":{},"道":{"docs":{},"不":{"docs":{},"适":{"docs":{},"合":{"docs":{},"所":{"docs":{},"有":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"理":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"，":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"定":{"docs":{},"时":{"docs":{},"器":{"docs":{},"线":{"docs":{},"程":{"docs":{},"并":{"docs":{},"非":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}},"集":{"docs":{},"群":{"docs":{},"端":{"docs":{},"的":{"docs":{},"主":{"docs":{},"题":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"清":{"docs":{},"单":{"docs":{},"（":{"docs":{},"这":{"docs":{},"样":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"轻":{"docs":{},"松":{"docs":{},"得":{"docs":{},"知":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"的":{"docs":{},"那":{"docs":{},"些":{"docs":{},"节":{"docs":{},"点":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"了":{"docs":{},"那":{"docs":{},"些":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"字":{"docs":{},"段":{"docs":{},"都":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"也":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"相":{"docs":{},"似":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}},"似":{"docs":{},"g":{"docs":{},"n":{"docs":{},"u":{"docs":{},"选":{"docs":{},"项":{"docs":{},"（":{"docs":{},"即":{"docs":{},"d":{"docs":{},"u":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"即":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"x":{"docs":{},"选":{"docs":{},"项":{"docs":{},"（":{"docs":{},"即":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"地":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"文":{"docs":{},"件":{"docs":{},"上":{"docs":{},"传":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"于":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}},"，":{"docs":{},"关":{"docs":{},"闭":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"作":{"docs":{},"为":{"docs":{},"主":{"docs":{},"类":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"使":{"docs":{},"用":{"docs":{},"以":{"docs":{},"下":{"docs":{},"退":{"docs":{},"出":{"docs":{},"代":{"docs":{},"码":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"则":{"docs":{},"不":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"）":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"名":{"docs":{},"。":{"docs":{},"我":{"docs":{},"们":{"docs":{},"为":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"4":{"docs":{},"j":{"docs":{},"（":{"docs":{},"版":{"docs":{},"本":{"1":{"docs":{},"）":{"docs":{},"、":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"4":{"docs":{},"j":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}}}}}}},"docs":{}}}}}},"docs":{}}}}}}}}},"型":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"的":{"docs":{},"表":{"docs":{},"单":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"被":{"docs":{},"编":{"docs":{},"码":{"docs":{},"在":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"中":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"在":{"docs":{},"整":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"被":{"docs":{},"完":{"docs":{},"全":{"docs":{},"读":{"docs":{},"取":{"docs":{},"之":{"docs":{},"前":{"docs":{},"它":{"docs":{},"是":{"docs":{},"不":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"。":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"首":{"docs":{},"先":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"非":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"调":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"是":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"可":{"docs":{},"接":{"docs":{},"受":{"docs":{},"的":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"字":{"docs":{},"段":{"docs":{},"。":{"docs":{},"而":{"docs":{},"且":{"docs":{},"在":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"对":{"docs":{},"于":{"docs":{},"其":{"docs":{},"他":{"docs":{},"支":{"docs":{},"持":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}},"原":{"docs":{},"因":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}},"放":{"docs":{},"到":{"docs":{},"最":{"docs":{},"后":{"docs":{},"。":{"docs":{},"其":{"docs":{},"中":{"docs":{},"类":{"docs":{},"型":{"docs":{},"r":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}},"可":{"docs":{},"读":{"docs":{},"流":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},")":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"注":{"docs":{},"册":{"docs":{},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"(":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"，":{"docs":{},"来":{"docs":{},"获":{"docs":{},"得":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"事":{"docs":{},"件":{"docs":{},"通":{"docs":{},"知":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"它":{"docs":{},"们":{"docs":{},"将":{"docs":{},"不":{"docs":{},"会":{"docs":{},"显":{"docs":{},"示":{"docs":{},"在":{"docs":{},"此":{"docs":{},"处":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"中":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"则":{"docs":{},"（":{"docs":{},"系":{"docs":{},"统":{"docs":{},"）":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"计":{"docs":{},"算":{"docs":{},"一":{"docs":{},"组":{"docs":{},"选":{"docs":{},"项":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{},"[":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},",":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}},"这":{"docs":{},"使":{"docs":{},"得":{"docs":{},"返":{"docs":{},"回":{"docs":{},"任":{"docs":{},"意":{"docs":{},"类":{"docs":{},"型":{"docs":{},"变":{"docs":{},"得":{"docs":{},"比":{"docs":{},"较":{"docs":{},"困":{"docs":{},"难":{"docs":{},"。":{"docs":{},"避":{"docs":{},"免":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}},"例":{"docs":{},"如":{"docs":{},"以":{"docs":{},"下":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"可":{"docs":{},"以":{"docs":{},"提":{"docs":{},"供":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"则":{"docs":{},"它":{"docs":{},"会":{"docs":{},"与":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"追":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"）":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}},"字":{"docs":{},"段":{"docs":{},"的":{"docs":{},"文":{"docs":{},"档":{"docs":{},"以":{"docs":{},"及":{"docs":{},"读":{"docs":{},"取":{"docs":{},"这":{"docs":{},"个":{"docs":{},"字":{"docs":{},"段":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"（":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"：":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"这":{"docs":{},"个":{"docs":{},"功":{"docs":{},"能":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"有":{"docs":{},"些":{"docs":{},"例":{"docs":{},"子":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"追":{"docs":{},"加":{"docs":{},"各":{"docs":{},"种":{"docs":{},"不":{"docs":{},"同":{"docs":{},"类":{"docs":{},"型":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"追":{"docs":{},"加":{"docs":{},"写":{"docs":{},"入":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}},"来":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"命":{"docs":{},"令":{"docs":{},"集":{"docs":{},"（":{"docs":{},"仅":{"docs":{},"限":{"docs":{},"于":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"）":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"描":{"docs":{},"述":{"docs":{},"选":{"docs":{},"项":{"docs":{},"和":{"docs":{},"参":{"docs":{},"数":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"用":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"当":{"docs":{},"消":{"docs":{},"息":{"docs":{},"发":{"docs":{},"送":{"docs":{},"给":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"后":{"docs":{},"解":{"docs":{},"码":{"docs":{},"成":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"文":{"docs":{},"档":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"语":{"docs":{},"言":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"y":{"docs":{},":":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"它":{"docs":{},"会":{"docs":{},"做":{"docs":{},"一":{"docs":{},"些":{"docs":{},"包":{"docs":{},"装":{"docs":{},"（":{"docs":{},"你":{"docs":{},"将":{"docs":{},"获":{"docs":{},"得":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"辅":{"docs":{},"助":{"docs":{},"类":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"用":{"docs":{},"于":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}},"并":{"docs":{},"重":{"docs":{},"载":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},"方":{"docs":{},"法":{"docs":{},"和":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{},"方":{"docs":{},"法":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"代":{"docs":{},"表":{"docs":{},"查":{"docs":{},"询":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}},"上":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"可":{"docs":{},"以":{"docs":{},"创":{"docs":{},"建":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"是":{"docs":{},"一":{"docs":{},"对":{"docs":{},"完":{"docs":{},"美":{"docs":{},"的":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"：":{"docs":{},"都":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"流":{"docs":{},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"转":{"docs":{},"化":{"docs":{},"为":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}},"或":{"docs":{},"者":{"docs":{},"各":{"docs":{},"种":{"docs":{},"服":{"docs":{},"务":{"docs":{},"类":{"docs":{},"型":{"docs":{},"类":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"快":{"docs":{},"捷":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"配":{"docs":{},"置":{"docs":{},"该":{"docs":{},"位":{"docs":{},"置":{"docs":{},"。":{"docs":{},"如":{"docs":{},"，":{"docs":{},"若":{"docs":{},"当":{"docs":{},"前":{"docs":{},"工":{"docs":{},"作":{"docs":{},"目":{"docs":{},"录":{"docs":{},"不":{"docs":{},"可":{"docs":{},"写":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"在":{"docs":{},"不":{"docs":{},"可":{"docs":{},"变":{"docs":{},"容":{"docs":{},"器":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"环":{"docs":{},"境":{"docs":{},"中":{"docs":{},"）":{"docs":{},"，":{"docs":{},"请":{"docs":{},"使":{"docs":{},"用":{"docs":{},"以":{"docs":{},"下":{"docs":{},"命":{"docs":{},"令":{"docs":{},"启":{"docs":{},"动":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"变":{"docs":{},"量":{"docs":{},"来":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"达":{"docs":{},"到":{"docs":{},"目":{"docs":{},"的":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}},"索":{"docs":{},"引":{"docs":{},"为":{"0":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"1":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}}}},"级":{"docs":{},"别":{"docs":{},"和":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"线":{"docs":{},"程":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"取":{"docs":{},"而":{"docs":{},"代":{"docs":{},"之":{"docs":{},"是":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"会":{"docs":{},"根":{"docs":{},"据":{"docs":{},"机":{"docs":{},"器":{"docs":{},"上":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"核":{"docs":{},"数":{"docs":{},"量":{"docs":{},"来":{"docs":{},"设":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"上":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"在":{"docs":{},"该":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"稍":{"docs":{},"后":{"docs":{},"的":{"docs":{},"章":{"docs":{},"节":{"docs":{},"我":{"docs":{},"们":{"docs":{},"会":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"更":{"docs":{},"多":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"在":{"docs":{},"多":{"docs":{},"核":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"运":{"docs":{},"行":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"只":{"docs":{},"部":{"docs":{},"署":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"您":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"最":{"docs":{},"多":{"docs":{},"只":{"docs":{},"能":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"核":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"中":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"运":{"docs":{},"行":{"docs":{},"内":{"docs":{},"联":{"docs":{},"的":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"，":{"docs":{},"如":{"docs":{},"单":{"docs":{},"元":{"docs":{},"测":{"docs":{},"试":{"docs":{},"或":{"docs":{},"纯":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"：":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"将":{"docs":{},"被":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"同":{"docs":{},"步":{"docs":{},"执":{"docs":{},"行":{"docs":{},"生":{"docs":{},"成":{"docs":{},"随":{"docs":{},"机":{"docs":{},"数":{"docs":{},"的":{"docs":{},"过":{"docs":{},"程":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"和":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"会":{"docs":{},"根":{"docs":{},"据":{"docs":{},"需":{"docs":{},"要":{"docs":{},"创":{"docs":{},"建":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"生":{"docs":{},"产":{"docs":{},"环":{"docs":{},"境":{"docs":{},"，":{"docs":{},"不":{"docs":{},"推":{"docs":{},"荐":{"docs":{},"这":{"docs":{},"样":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"安":{"docs":{},"全":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"池":{"docs":{},"的":{"docs":{},"线":{"docs":{},"程":{"docs":{},"上":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"（":{"docs":{},"或":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"）":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"，":{"docs":{},"但":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"因":{"docs":{},"此":{"docs":{},"（":{"docs":{},"这":{"docs":{},"些":{"docs":{},"操":{"docs":{},"作":{"docs":{},"）":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"在":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}},"等":{"docs":{},"待":{"docs":{},"作":{"docs":{},"为":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"最":{"docs":{},"长":{"docs":{},"等":{"docs":{},"待":{"docs":{},"时":{"docs":{},"间":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}},"的":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"组":{"docs":{},"件":{"docs":{},"介":{"docs":{},"绍":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"源":{"docs":{},"码":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258},"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.11764705882352941},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"示":{"docs":{},"例":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"也":{"docs":{},"提":{"docs":{},"供":{"docs":{},"r":{"docs":{},"x":{"docs":{},"风":{"docs":{},"格":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"添":{"docs":{},"加":{"docs":{},"以":{"docs":{},"下":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"在":{"docs":{},"构":{"docs":{},"建":{"docs":{},"描":{"docs":{},"述":{"docs":{},"符":{"docs":{},"中":{"docs":{},"添":{"docs":{},"加":{"docs":{},"如":{"docs":{},"下":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"：":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}}}}}}}}},"合":{"docs":{},"路":{"docs":{},"由":{"docs":{},"规":{"docs":{},"则":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"风":{"docs":{},"格":{"docs":{},"在":{"docs":{},"这":{"docs":{},"里":{"docs":{},"是":{"docs":{},"相":{"docs":{},"当":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"：":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}},"播":{"docs":{},"不":{"docs":{},"可":{"docs":{},"用":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"未":{"docs":{},"正":{"docs":{},"常":{"docs":{},"开":{"docs":{},"启":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}},"被":{"docs":{},"禁":{"docs":{},"用":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}},"绑":{"docs":{},"定":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"一":{"docs":{},"次":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"到":{"docs":{},"某":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"（":{"docs":{},"它":{"docs":{},"所":{"docs":{},"获":{"docs":{},"取":{"docs":{},"到":{"docs":{},"的":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}},"结":{"docs":{},"合":{"docs":{},"起":{"docs":{},"来":{"docs":{},"发":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"头":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"尾":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"某":{"docs":{},"些":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"操":{"docs":{},"作":{"docs":{},"）":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"中":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"都":{"docs":{},"不":{"docs":{},"会":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"调":{"docs":{},"用":{"docs":{},"线":{"docs":{},"程":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"路":{"docs":{},"由":{"docs":{},"到":{"docs":{},"模":{"docs":{},"板":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"上":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"束":{"docs":{},"一":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"，":{"docs":{},"若":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"尚":{"docs":{},"未":{"docs":{},"被":{"docs":{},"写":{"docs":{},"入":{"docs":{},"，":{"docs":{},"会":{"docs":{},"导":{"docs":{},"致":{"docs":{},"它":{"docs":{},"们":{"docs":{},"被":{"docs":{},"写":{"docs":{},"入":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"请":{"docs":{},"求":{"docs":{},"被":{"docs":{},"标":{"docs":{},"记":{"docs":{},"成":{"docs":{},"完":{"docs":{},"成":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"请":{"docs":{},"求":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"响":{"docs":{},"应":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}},"构":{"docs":{},"。":{"docs":{},"它":{"docs":{},"具":{"docs":{},"有":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"的":{"docs":{},"键":{"docs":{},"，":{"docs":{},"值":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"任":{"docs":{},"意":{"docs":{},"一":{"docs":{},"种":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"语":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"给":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"绝":{"docs":{},"对":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"继":{"docs":{},"承":{"docs":{},"更":{"docs":{},"简":{"docs":{},"单":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"维":{"docs":{},"护":{"docs":{},"集":{"docs":{},"群":{"docs":{},"范":{"docs":{},"围":{"docs":{},"中":{"docs":{},"的":{"docs":{},"主":{"docs":{},"题":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"者":{"docs":{},"列":{"docs":{},"表":{"docs":{},"（":{"docs":{},"所":{"docs":{},"以":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"知":{"docs":{},"道":{"docs":{},"哪":{"docs":{},"些":{"docs":{},"节":{"docs":{},"点":{"docs":{},"对":{"docs":{},"哪":{"docs":{},"个":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"了":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"对":{"docs":{},"应":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"虚":{"docs":{},"构":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"任":{"docs":{},"务":{"docs":{},"进":{"docs":{},"行":{"docs":{},"循":{"docs":{},"环":{"docs":{},"检":{"docs":{},"查":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"间":{"docs":{},"隔":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"维":{"docs":{},"护":{"docs":{},"任":{"docs":{},"务":{"docs":{},"会":{"docs":{},"定":{"docs":{},"时":{"docs":{},"检":{"docs":{},"查":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"状":{"docs":{},"态":{"docs":{},"，":{"docs":{},"直":{"docs":{},"到":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{},"剩":{"docs":{},"下":{"docs":{},"最":{"docs":{},"小":{"docs":{},"连":{"docs":{},"接":{"docs":{},"数":{"docs":{},"）":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"模":{"docs":{},"式":{"docs":{},"下":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"或":{"docs":{},"已":{"docs":{},"经":{"docs":{},"从":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}},"缓":{"docs":{},"存":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"有":{"docs":{},"过":{"docs":{},"期":{"docs":{},"时":{"docs":{},"间":{"docs":{},"，":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"时":{"docs":{},"间":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"会":{"docs":{},"重":{"docs":{},"新":{"docs":{},"访":{"docs":{},"问":{"docs":{},"磁":{"docs":{},"盘":{"docs":{},"检":{"docs":{},"查":{"docs":{},"文":{"docs":{},"件":{"docs":{},"并":{"docs":{},"更":{"docs":{},"新":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"编":{"docs":{},"写":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00046446818392940084},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"支":{"docs":{},"持":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"码":{"docs":{},"形":{"docs":{},"式":{"docs":{},"上":{"docs":{},"传":{"docs":{},"的":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"成":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"格":{"docs":{},"式":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"过":{"docs":{},"的":{"docs":{},"表":{"docs":{},"单":{"docs":{},"，":{"docs":{},"表":{"docs":{},"单":{"docs":{},"属":{"docs":{},"性":{"docs":{},"会":{"docs":{},"被":{"docs":{},"编":{"docs":{},"码":{"docs":{},"在":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"中":{"docs":{},"，":{"docs":{},"如":{"docs":{},"同":{"docs":{},"普":{"docs":{},"通":{"docs":{},"查":{"docs":{},"询":{"docs":{},"参":{"docs":{},"数":{"docs":{},"一":{"docs":{},"样":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"包":{"docs":{},"含":{"docs":{},"在":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"，":{"docs":{},"将":{"docs":{},"这":{"docs":{},"个":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"作":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}},"格":{"docs":{},"式":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}},"程":{"docs":{},"方":{"docs":{},"式":{"docs":{},"部":{"docs":{},"署":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"比":{"docs":{},"直":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{},"同":{"docs":{},"步":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}},"形":{"docs":{},"式":{"docs":{},"调":{"docs":{},"用":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}},"配":{"docs":{},"置":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}},"译":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"源":{"docs":{},"代":{"docs":{},"码":{"docs":{},"并":{"docs":{},"进":{"docs":{},"行":{"docs":{},"部":{"docs":{},"署":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"网":{"docs":{},"络":{"docs":{},"活":{"docs":{},"动":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"记":{"docs":{},"录":{"docs":{},"下":{"docs":{},"来":{"docs":{},"，":{"docs":{},"用":{"docs":{},"于":{"docs":{},"调":{"docs":{},"试":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"页":{"docs":{},"图":{"docs":{},"标":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"而":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"不":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"j":{"docs":{},"d":{"docs":{},"k":{"docs":{},"实":{"docs":{},"现":{"docs":{},"（":{"docs":{},"来":{"docs":{},"支":{"docs":{},"持":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"管":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"的":{"docs":{},"内":{"docs":{},"容":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}},"是":{"docs":{},"指":{"docs":{},"定":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"非":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"耦":{"docs":{},"合":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"和":{"docs":{},"任":{"docs":{},"意":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"一":{"docs":{},"起":{"docs":{},"工":{"docs":{},"作":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"节":{"docs":{},"点":{"docs":{},"不":{"docs":{},"在":{"docs":{},"授":{"docs":{},"信":{"docs":{},"的":{"docs":{},"网":{"docs":{},"络":{"docs":{},"上":{"docs":{},"，":{"docs":{},"请":{"docs":{},"勿":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"中":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"之":{"docs":{},"间":{"docs":{},"创":{"docs":{},"建":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"下":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"发":{"docs":{},"现":{"docs":{},"和":{"docs":{},"分":{"docs":{},"组":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"列":{"docs":{},"表":{"docs":{},"（":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"）":{"docs":{},"以":{"docs":{},"及":{"docs":{},"如":{"docs":{},"何":{"docs":{},"对":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"进":{"docs":{},"行":{"docs":{},"解":{"docs":{},"析":{"docs":{},"以":{"docs":{},"得":{"docs":{},"到":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"消":{"docs":{},"息":{"docs":{},"确":{"docs":{},"认":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{},"消":{"docs":{},"息":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"标":{"docs":{},"志":{"docs":{},"符":{"docs":{},"（":{"docs":{},"如":{"docs":{},"果":{"docs":{},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{},"单":{"docs":{},"节":{"docs":{},"点":{"docs":{},"模":{"docs":{},"式":{"docs":{},"是":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}},"信":{"docs":{},"息":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}},"若":{"docs":{},"m":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"无":{"docs":{},"法":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"：":{"1":{"1":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}},"docs":{}}}}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"主":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"不":{"docs":{},"能":{"docs":{},"被":{"docs":{},"部":{"docs":{},"署":{"docs":{},"：":{"1":{"5":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"嵌":{"docs":{},"入":{"docs":{},"了":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"编":{"docs":{},"程":{"docs":{},"方":{"docs":{},"式":{"docs":{},"指":{"docs":{},"定":{"docs":{},"度":{"docs":{},"量":{"docs":{},"工":{"docs":{},"厂":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}},"前":{"docs":{},"缀":{"docs":{},"后":{"docs":{},"缀":{"docs":{},"都":{"docs":{},"没":{"docs":{},"指":{"docs":{},"定":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"将":{"docs":{},"假":{"docs":{},"定":{"docs":{},"这":{"docs":{},"个":{"docs":{},"名":{"docs":{},"字":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"不":{"docs":{},"想":{"docs":{},"收":{"docs":{},"到":{"docs":{},"推":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"重":{"docs":{},"置":{"docs":{},"流":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"将":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"没":{"docs":{},"有":{"docs":{},"设":{"docs":{},"置":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"，":{"docs":{},"则":{"docs":{},"必":{"docs":{},"须":{"docs":{},"配":{"docs":{},"置":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"受":{"docs":{},"信":{"docs":{},"存":{"docs":{},"储":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"受":{"docs":{},"信":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"应":{"docs":{},"该":{"docs":{},"包":{"docs":{},"含":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"的":{"docs":{},"证":{"docs":{},"书":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"已":{"docs":{},"经":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"您":{"docs":{},"不":{"docs":{},"想":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"时":{"docs":{},"通":{"docs":{},"过":{"docs":{},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"时":{"docs":{},"传":{"docs":{},"递":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"状":{"docs":{},"态":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"状":{"docs":{},"态":{"docs":{},"码":{"docs":{},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"关":{"docs":{},"心":{"docs":{},"您":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"仅":{"docs":{},"需":{"docs":{},"要":{"docs":{},"写":{"docs":{},"单":{"docs":{},"个":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"或":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"只":{"docs":{},"是":{"docs":{},"想":{"docs":{},"将":{"docs":{},"文":{"docs":{},"件":{"docs":{},"上":{"docs":{},"传":{"docs":{},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"磁":{"docs":{},"盘":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"单":{"docs":{},"个":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"或":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}},"启":{"docs":{},"动":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"时":{"docs":{},"看":{"docs":{},"到":{"docs":{},"以":{"docs":{},"下":{"docs":{},"信":{"docs":{},"息":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"并":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"集":{"docs":{},"群":{"docs":{},"，":{"docs":{},"则":{"docs":{},"应":{"docs":{},"确":{"docs":{},"保":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"安":{"docs":{},"装":{"docs":{},"的":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"目":{"docs":{},"录":{"docs":{},"包":{"docs":{},"含":{"docs":{},"您":{"docs":{},"的":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},")":{"docs":{},"之":{"docs":{},"前":{"docs":{},"已":{"docs":{},"经":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"了":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"调":{"docs":{},"用":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"来":{"docs":{},"查":{"docs":{},"找":{"docs":{},"套":{"docs":{},"接":{"docs":{},"字":{"docs":{},"的":{"docs":{},"本":{"docs":{},"地":{"docs":{},"地":{"docs":{},"址":{"docs":{},"（":{"docs":{},"即":{"docs":{},"u":{"docs":{},"d":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"其":{"docs":{},"中":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"下":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"希":{"docs":{},"望":{"docs":{},"在":{"docs":{},"完":{"docs":{},"成":{"docs":{},"注":{"docs":{},"册":{"docs":{},"后":{"docs":{},"收":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"实":{"docs":{},"际":{"docs":{},"监":{"docs":{},"听":{"docs":{},"时":{"docs":{},"收":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"向":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"总":{"docs":{},"是":{"docs":{},"希":{"docs":{},"望":{"docs":{},"某":{"docs":{},"个":{"docs":{},"类":{"docs":{},"使":{"docs":{},"用":{"docs":{},"将":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"编":{"docs":{},"解":{"docs":{},"码":{"docs":{},"器":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"这":{"docs":{},"个":{"docs":{},"类":{"docs":{},"注":{"docs":{},"册":{"docs":{},"默":{"docs":{},"认":{"docs":{},"编":{"docs":{},"解":{"docs":{},"码":{"docs":{},"器":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"您":{"docs":{},"就":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"每":{"docs":{},"次":{"docs":{},"发":{"docs":{},"送":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"想":{"docs":{},"写":{"docs":{},"入":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"，":{"docs":{},"则":{"docs":{},"您":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"写":{"docs":{},"入":{"docs":{},"任":{"docs":{},"何":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"之":{"docs":{},"前":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"来":{"docs":{},"设":{"docs":{},"置":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"设":{"docs":{},"置":{"docs":{},"默":{"docs":{},"认":{"docs":{},"端":{"docs":{},"口":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"要":{"docs":{},"从":{"docs":{},"偏":{"docs":{},"移":{"docs":{},"量":{"docs":{},"开":{"docs":{},"始":{"docs":{},"发":{"docs":{},"送":{"docs":{},"文":{"docs":{},"件":{"docs":{},"直":{"docs":{},"到":{"docs":{},"尾":{"docs":{},"部":{"docs":{},"，":{"docs":{},"则":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"提":{"docs":{},"供":{"docs":{},"长":{"docs":{},"度":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"执":{"docs":{},"行":{"docs":{},"以":{"docs":{},"下":{"docs":{},"操":{"docs":{},"作":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"决":{"docs":{},"定":{"docs":{},"是":{"docs":{},"否":{"docs":{},"手":{"docs":{},"动":{"docs":{},"发":{"docs":{},"送":{"docs":{},"持":{"docs":{},"续":{"docs":{},"响":{"docs":{},"应":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"此":{"docs":{},"属":{"docs":{},"性":{"docs":{},"可":{"docs":{},"设":{"docs":{},"置":{"docs":{},"成":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"（":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"）":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"检":{"docs":{},"查":{"docs":{},"头":{"docs":{},"信":{"docs":{},"息":{"docs":{},"并":{"docs":{},"且":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"加":{"docs":{},"载":{"docs":{},"的":{"docs":{},"类":{"docs":{},"和":{"docs":{},"资":{"docs":{},"源":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"于":{"docs":{},"主":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"（":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"连":{"docs":{},"接":{"docs":{},"创":{"docs":{},"建":{"docs":{},"完":{"docs":{},"时":{"docs":{},"收":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"，":{"docs":{},"则":{"docs":{},"需":{"docs":{},"要":{"docs":{},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"接":{"docs":{},"收":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"，":{"docs":{},"则":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"读":{"docs":{},"取":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"配":{"docs":{},"置":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"选":{"docs":{},"项":{"docs":{},"，":{"docs":{},"可":{"docs":{},"按":{"docs":{},"以":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"创":{"docs":{},"建":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"拥":{"docs":{},"有":{"docs":{},"的":{"docs":{},"锁":{"docs":{},"没":{"docs":{},"有":{"docs":{},"其":{"docs":{},"他":{"docs":{},"调":{"docs":{},"用":{"docs":{},"者":{"docs":{},"，":{"docs":{},"集":{"docs":{},"群":{"docs":{},"上":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"地":{"docs":{},"方":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"获":{"docs":{},"得":{"docs":{},"该":{"docs":{},"锁":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"正":{"docs":{},"在":{"docs":{},"编":{"docs":{},"写":{"docs":{},"一":{"docs":{},"个":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"用":{"docs":{},"编":{"docs":{},"程":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"创":{"docs":{},"建":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"选":{"docs":{},"项":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"应":{"docs":{},"用":{"docs":{},"关":{"docs":{},"心":{"docs":{},"丢":{"docs":{},"失":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"，":{"docs":{},"您":{"docs":{},"应":{"docs":{},"该":{"docs":{},"编":{"docs":{},"写":{"docs":{},"具":{"docs":{},"有":{"docs":{},"幂":{"docs":{},"等":{"docs":{},"性":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"您":{"docs":{},"的":{"docs":{},"发":{"docs":{},"送":{"docs":{},"者":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"恢":{"docs":{},"复":{"docs":{},"后":{"docs":{},"重":{"docs":{},"试":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"日":{"docs":{},"志":{"docs":{},"显":{"docs":{},"示":{"docs":{},"一":{"docs":{},"堆":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"知":{"docs":{},"道":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"不":{"docs":{},"是":{"docs":{},"很":{"docs":{},"大":{"docs":{},"，":{"docs":{},"并":{"docs":{},"想":{"docs":{},"在":{"docs":{},"处":{"docs":{},"理":{"docs":{},"之":{"docs":{},"前":{"docs":{},"在":{"docs":{},"内":{"docs":{},"存":{"docs":{},"中":{"docs":{},"聚":{"docs":{},"合":{"docs":{},"所":{"docs":{},"有":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"自":{"docs":{},"己":{"docs":{},"聚":{"docs":{},"合":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"收":{"docs":{},"到":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"收":{"docs":{},"到":{"docs":{},"通":{"docs":{},"知":{"docs":{},"，":{"docs":{},"则":{"docs":{},"需":{"docs":{},"要":{"docs":{},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"保":{"docs":{},"证":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"在":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{},"之":{"docs":{},"上":{"docs":{},"建":{"docs":{},"立":{"docs":{},"一":{"docs":{},"些":{"docs":{},"握":{"docs":{},"手":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"符":{"docs":{},"来":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"消":{"docs":{},"息":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}},"想":{"docs":{},"显":{"docs":{},"示":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"执":{"docs":{},"行":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"现":{"docs":{},"在":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"或":{"docs":{},"杀":{"docs":{},"死":{"docs":{},"其":{"docs":{},"中":{"docs":{},"一":{"docs":{},"个":{"docs":{},"节":{"docs":{},"点":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"这":{"docs":{},"些":{"docs":{},"模":{"docs":{},"块":{"docs":{},"将":{"docs":{},"在":{"docs":{},"其":{"docs":{},"他":{"docs":{},"节":{"docs":{},"点":{"docs":{},"上":{"docs":{},"自":{"docs":{},"动":{"docs":{},"撤":{"docs":{},"销":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"不":{"docs":{},"再":{"docs":{},"满":{"docs":{},"足":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"是":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}},"打":{"docs":{},"开":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"已":{"docs":{},"经":{"docs":{},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"没":{"docs":{},"有":{"docs":{},"设":{"docs":{},"置":{"docs":{},"任":{"docs":{},"何":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"时":{"docs":{},"，":{"docs":{},"任":{"docs":{},"何":{"docs":{},"被":{"docs":{},"推":{"docs":{},"送":{"docs":{},"的":{"docs":{},"流":{"docs":{},"将":{"docs":{},"被":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"自":{"docs":{},"动":{"docs":{},"重":{"docs":{},"置":{"docs":{},"流":{"docs":{},"（":{"docs":{},"错":{"docs":{},"误":{"docs":{},"代":{"docs":{},"码":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{},"进":{"docs":{},"程":{"docs":{},"无":{"docs":{},"法":{"docs":{},"启":{"docs":{},"动":{"docs":{},"、":{"docs":{},"发":{"docs":{},"现":{"docs":{},"或":{"docs":{},"停":{"docs":{},"止":{"docs":{},"：":{"1":{"2":{"docs":{},"，":{"docs":{},"该":{"docs":{},"错":{"docs":{},"误":{"docs":{},"代":{"docs":{},"码":{"docs":{},"一":{"docs":{},"般":{"docs":{},"由":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"和":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"命":{"docs":{},"令":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"系":{"docs":{},"统":{"docs":{},"配":{"docs":{},"置":{"docs":{},"不":{"docs":{},"符":{"docs":{},"合":{"docs":{},"系":{"docs":{},"统":{"docs":{},"要":{"docs":{},"求":{"docs":{},"（":{"docs":{},"如":{"docs":{},"找":{"docs":{},"不":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"终":{"docs":{},"端":{"3":{"docs":{},"中":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"被":{"docs":{},"杀":{"docs":{},"掉":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"个":{"docs":{},"组":{"docs":{},"中":{"docs":{},"没":{"docs":{},"有":{"docs":{},"其":{"docs":{},"他":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"则":{"docs":{},"它":{"docs":{},"不":{"docs":{},"会":{"docs":{},"故":{"docs":{},"障":{"docs":{},"转":{"docs":{},"移":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"向":{"docs":{},"响":{"docs":{},"应":{"docs":{},"添":{"docs":{},"加":{"docs":{},"尾":{"docs":{},"部":{"docs":{},"，":{"docs":{},"则":{"docs":{},"直":{"docs":{},"接":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"启":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"h":{"docs":{},"a":{"docs":{},"模":{"docs":{},"式":{"docs":{},"，":{"docs":{},"在":{"docs":{},"启":{"docs":{},"动":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"管":{"docs":{},"道":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"调":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"管":{"docs":{},"道":{"docs":{},"是":{"docs":{},"禁":{"docs":{},"止":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"解":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"功":{"docs":{},"能":{"docs":{},"则":{"docs":{},"您":{"docs":{},"要":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"时":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"高":{"docs":{},"可":{"docs":{},"用":{"docs":{},"方":{"docs":{},"式":{"docs":{},"运":{"docs":{},"行":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"在":{"docs":{},"集":{"docs":{},"群":{"docs":{},"模":{"docs":{},"式":{"docs":{},"下":{"docs":{},"保":{"docs":{},"证":{"docs":{},"安":{"docs":{},"全":{"docs":{},"性":{"docs":{},"，":{"docs":{},"您":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"接":{"docs":{},"收":{"docs":{},"特":{"docs":{},"定":{"docs":{},"多":{"docs":{},"播":{"docs":{},"组":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"通":{"docs":{},"过":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"帧":{"docs":{},"(":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"获":{"docs":{},"取":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"解":{"docs":{},"析":{"docs":{},"器":{"docs":{},"在":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"内":{"docs":{},"没":{"docs":{},"有":{"docs":{},"收":{"docs":{},"到":{"docs":{},"正":{"docs":{},"确":{"docs":{},"答":{"docs":{},"案":{"docs":{},"（":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"5":{"docs":{},"秒":{"docs":{},"）":{"docs":{},"，":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"查":{"docs":{},"询":{"docs":{},"被":{"docs":{},"视":{"docs":{},"为":{"docs":{},"失":{"docs":{},"败":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"监":{"docs":{},"听":{"docs":{},"端":{"docs":{},"口":{"docs":{},"为":{"0":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"将":{"docs":{},"随":{"docs":{},"机":{"docs":{},"寻":{"docs":{},"找":{"docs":{},"一":{"docs":{},"个":{"docs":{},"没":{"docs":{},"有":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"端":{"docs":{},"口":{"docs":{},"来":{"docs":{},"监":{"docs":{},"听":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}},"请":{"docs":{},"求":{"docs":{},"在":{"docs":{},"超":{"docs":{},"时":{"docs":{},"期":{"docs":{},"限":{"docs":{},"内":{"docs":{},"未":{"docs":{},"返":{"docs":{},"回":{"docs":{},"任":{"docs":{},"何":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"则":{"docs":{},"异":{"docs":{},"常":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"传":{"docs":{},"给":{"docs":{},"异":{"docs":{},"常":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"（":{"docs":{},"若":{"docs":{},"提":{"docs":{},"供":{"docs":{},"）":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"请":{"docs":{},"求":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"设":{"docs":{},"定":{"docs":{},"时":{"docs":{},"间":{"docs":{},"内":{"docs":{},"没":{"docs":{},"返":{"docs":{},"回":{"docs":{},"任":{"docs":{},"何":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"则":{"docs":{},"一":{"docs":{},"个":{"docs":{},"超":{"docs":{},"时":{"docs":{},"异":{"docs":{},"常":{"docs":{},"将":{"docs":{},"会":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"响":{"docs":{},"应":{"docs":{},"处":{"docs":{},"理":{"docs":{},"代":{"docs":{},"码":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"进":{"docs":{},"程":{"docs":{},"顺":{"docs":{},"利":{"docs":{},"结":{"docs":{},"束":{"docs":{},"，":{"docs":{},"或":{"docs":{},"抛":{"docs":{},"出":{"docs":{},"未":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"的":{"docs":{},"错":{"docs":{},"误":{"docs":{},"：":{"0":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}}}}}}}}}}}}}}}}}},"选":{"docs":{},"项":{"docs":{},"值":{"docs":{},"包":{"docs":{},"含":{"docs":{},"空":{"docs":{},"白":{"docs":{},"，":{"docs":{},"请":{"docs":{},"不":{"docs":{},"要":{"docs":{},"忘":{"docs":{},"记":{"docs":{},"在":{"docs":{},"“":{"docs":{},"”":{"docs":{},"（":{"docs":{},"双":{"docs":{},"引":{"docs":{},"号":{"docs":{},"）":{"docs":{},"之":{"docs":{},"间":{"docs":{},"包":{"docs":{},"装":{"docs":{},"值":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"调":{"docs":{},"整":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"执":{"docs":{},"行":{"docs":{},"其":{"docs":{},"他":{"docs":{},"数":{"docs":{},"据":{"docs":{},"库":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}},"无":{"docs":{},"法":{"docs":{},"预":{"docs":{},"知":{"docs":{},"响":{"docs":{},"应":{"docs":{},"内":{"docs":{},"容":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"您":{"docs":{},"依":{"docs":{},"旧":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"获":{"docs":{},"取":{"docs":{},"结":{"docs":{},"果":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}}}}},"当":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}}}},"虚":{"docs":{},"拟":{"docs":{},"机":{"docs":{},"本":{"docs":{},"身":{"docs":{},"附":{"docs":{},"带":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"是":{"docs":{},"不":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"它":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"完":{"docs":{},"全":{"docs":{},"异":{"docs":{},"步":{"docs":{},"解":{"docs":{},"析":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"主":{"docs":{},"机":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"机":{"docs":{},"主":{"docs":{},"机":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"会":{"docs":{},"验":{"docs":{},"证":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"主":{"docs":{},"机":{"docs":{},"名":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"则":{"docs":{},"转":{"docs":{},"发":{"docs":{},"这":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"到":{"docs":{},"注":{"docs":{},"册":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"上":{"docs":{},"。":{"docs":{},"否":{"docs":{},"则":{"docs":{},"，":{"docs":{},"继":{"docs":{},"续":{"docs":{},"在":{"docs":{},"原":{"docs":{},"先":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"链":{"docs":{},"中":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"表":{"docs":{},"单":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"您":{"docs":{},"应":{"docs":{},"该":{"docs":{},"告":{"docs":{},"诉":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"文":{"docs":{},"件":{"docs":{},"上":{"docs":{},"传":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"，":{"docs":{},"并":{"docs":{},"对":{"docs":{},"请":{"docs":{},"求":{"docs":{},"设":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"里":{"docs":{},"指":{"docs":{},"定":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"解":{"docs":{},"决":{"docs":{},"这":{"docs":{},"个":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"的":{"docs":{},"值":{"docs":{},"也":{"docs":{},"会":{"docs":{},"通":{"docs":{},"过":{"docs":{},"表":{"docs":{},"单":{"docs":{},"属":{"docs":{},"性":{"docs":{},"来":{"docs":{},"检":{"docs":{},"查":{"docs":{},"。":{"docs":{},"这":{"docs":{},"只":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"在":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"表":{"docs":{},"单":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"同":{"docs":{},"名":{"docs":{},"属":{"docs":{},"性":{"docs":{},"时":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"交":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"示":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"层":{"docs":{},"协":{"docs":{},"议":{"docs":{},"协":{"docs":{},"商":{"docs":{},"(":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"n":{"docs":{},")":{"docs":{},"协":{"docs":{},"议":{"docs":{},"来":{"docs":{},"协":{"docs":{},"商":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"比":{"docs":{},"但":{"docs":{},"比":{"docs":{},"较":{"docs":{},"慢":{"docs":{},"的":{"docs":{},"算":{"docs":{},"法":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"在":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{},"层":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{},"明":{"docs":{},"文":{"docs":{},"形":{"docs":{},"式":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"响":{"docs":{},"应":{"docs":{},"完":{"docs":{},"成":{"docs":{},"后":{"docs":{},"连":{"docs":{},"接":{"docs":{},"将":{"docs":{},"被":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"更":{"docs":{},"低":{"docs":{},"的":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"比":{"docs":{},"但":{"docs":{},"是":{"docs":{},"最":{"docs":{},"快":{"docs":{},"的":{"docs":{},"算":{"docs":{},"法":{"docs":{},"，":{"9":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}}}}}}}}}}}}}}},"要":{"docs":{},"监":{"docs":{},"视":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"集":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"集":{"docs":{},"合":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"会":{"docs":{},"接":{"docs":{},"受":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"无":{"docs":{},"偏":{"docs":{},"好":{"docs":{},"地":{"docs":{},"接":{"docs":{},"受":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"，":{"docs":{},"跳":{"docs":{},"过":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"行":{"docs":{},"数":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"创":{"docs":{},"建":{"docs":{},"时":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"被":{"docs":{},"分":{"docs":{},"派":{"docs":{},"给":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"多":{"docs":{},"次":{"docs":{},"，":{"docs":{},"如":{"docs":{},"运":{"docs":{},"行":{"docs":{},"以":{"docs":{},"下":{"docs":{},"命":{"docs":{},"令":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"我":{"docs":{},"们":{"docs":{},"称":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"撤":{"docs":{},"销":{"docs":{},"时":{"docs":{},"这":{"docs":{},"个":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"会":{"docs":{},"被":{"docs":{},"自":{"docs":{},"动":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"被":{"docs":{},"注":{"docs":{},"销":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"到":{"docs":{},"了":{"docs":{},"仅":{"docs":{},"占":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"节":{"docs":{},"的":{"docs":{},"特":{"docs":{},"定":{"docs":{},"位":{"docs":{},"置":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"该":{"docs":{},"选":{"docs":{},"项":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"计":{"docs":{},"来":{"docs":{},"调":{"docs":{},"用":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"它":{"docs":{},"不":{"docs":{},"会":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"任":{"docs":{},"何":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"消":{"docs":{},"费":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}},"称":{"docs":{},"为":{"docs":{},"子":{"docs":{},"路":{"docs":{},"由":{"docs":{},"（":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"作":{"docs":{},"为":{"docs":{},"当":{"docs":{},"前":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}},"卸":{"docs":{},"载":{"docs":{},"(":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},")":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}},"裁":{"docs":{},"剪":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"得":{"docs":{},"到":{"docs":{},"的":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"是":{"docs":{},"基":{"docs":{},"于":{"docs":{},"原":{"docs":{},"始":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"它":{"docs":{},"不":{"docs":{},"会":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"实":{"docs":{},"际":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"裸":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"要":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"使":{"docs":{},"用":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"进":{"docs":{},"行":{"docs":{},"随":{"docs":{},"机":{"docs":{},"访":{"docs":{},"问":{"docs":{},"写":{"docs":{},"，":{"docs":{},"请":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"读":{"docs":{},"，":{"docs":{},"请":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"d":{"docs":{},"p":{"docs":{},"，":{"docs":{},"您":{"docs":{},"首":{"docs":{},"先":{"docs":{},"要":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"该":{"docs":{},"模":{"docs":{},"型":{"docs":{},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"您":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"组":{"docs":{},"织":{"docs":{},"成":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"发":{"docs":{},"现":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"如":{"docs":{},"下":{"docs":{},"的":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"包":{"docs":{},"加":{"docs":{},"入":{"docs":{},"到":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"中":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}},"事":{"docs":{},"务":{"docs":{},"，":{"docs":{},"首":{"docs":{},"先":{"docs":{},"要":{"docs":{},"用":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}},"此":{"docs":{},"组":{"docs":{},"件":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"添":{"docs":{},"加":{"docs":{},"下":{"docs":{},"列":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"：":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"项":{"docs":{},"目":{"docs":{},"，":{"docs":{},"将":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"构":{"docs":{},"建":{"docs":{},"描":{"docs":{},"述":{"docs":{},"符":{"docs":{},"里":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"部":{"docs":{},"分":{"docs":{},"。":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"做":{"docs":{},"i":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"发":{"docs":{},"送":{"docs":{},"多":{"docs":{},"个":{"docs":{},"帧":{"docs":{},"组":{"docs":{},"成":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"，":{"docs":{},"请":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"帧":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"在":{"docs":{},"响":{"docs":{},"应":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"布":{"docs":{},"一":{"docs":{},"个":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}},"启":{"docs":{},"用":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"实":{"docs":{},"时":{"docs":{},"重":{"docs":{},"新":{"docs":{},"部":{"docs":{},"署":{"docs":{},"，":{"docs":{},"请":{"docs":{},"将":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"告":{"docs":{},"诉":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"当":{"docs":{},"前":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"支":{"docs":{},"持":{"docs":{},"哪":{"docs":{},"种":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"，":{"docs":{},"则":{"docs":{},"它":{"docs":{},"（":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"）":{"docs":{},"将":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"监":{"docs":{},"听":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"其":{"docs":{},"中":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"端":{"docs":{},"监":{"docs":{},"听":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"其":{"docs":{},"中":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"处":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}},"将":{"docs":{},"您":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"全":{"docs":{},"部":{"docs":{},"部":{"docs":{},"署":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"f":{"docs":{},"a":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"屏":{"docs":{},"蔽":{"docs":{},"来":{"docs":{},"自":{"docs":{},"特":{"docs":{},"定":{"docs":{},"地":{"docs":{},"址":{"docs":{},"的":{"docs":{},"多":{"docs":{},"播":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"h":{"docs":{},"a":{"docs":{},"组":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"该":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"接":{"docs":{},"收":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"告":{"docs":{},"诉":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"帧":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"在":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"查":{"docs":{},"找":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"a":{"docs":{},"a":{"docs":{},"a":{"docs":{},"a":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"您":{"docs":{},"通":{"docs":{},"常":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"以":{"docs":{},"下":{"docs":{},"操":{"docs":{},"作":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"您":{"docs":{},"通":{"docs":{},"常":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"以":{"docs":{},"下":{"docs":{},"操":{"docs":{},"作":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"c":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"您":{"docs":{},"通":{"docs":{},"常":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"以":{"docs":{},"下":{"docs":{},"操":{"docs":{},"作":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"v":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"您":{"docs":{},"通":{"docs":{},"常":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"以":{"docs":{},"下":{"docs":{},"操":{"docs":{},"作":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"常":{"docs":{},"用":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"m":{"docs":{},"x":{"docs":{},"记":{"docs":{},"录":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"询":{"docs":{},"单":{"docs":{},"个":{"docs":{},"文":{"docs":{},"档":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"解":{"docs":{},"析":{"docs":{},"i":{"docs":{},"p":{"docs":{},"地":{"docs":{},"址":{"1":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"docs":{},"的":{"docs":{},"p":{"docs":{},"t":{"docs":{},"r":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"您":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"1":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"1":{"0":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"n":{"docs":{},"s":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"下":{"docs":{},"边":{"docs":{},"几":{"docs":{},"行":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"下":{"docs":{},"边":{"docs":{},"几":{"docs":{},"行":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"决":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"这":{"docs":{},"么":{"docs":{},"做":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"这":{"docs":{},"么":{"docs":{},"做":{"docs":{},"：":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}},"调":{"docs":{},"试":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"，":{"docs":{},"请":{"docs":{},"将":{"docs":{},"运":{"docs":{},"行":{"docs":{},"配":{"docs":{},"置":{"docs":{},"创":{"docs":{},"建":{"docs":{},"为":{"docs":{},"远":{"docs":{},"程":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"，":{"docs":{},"并":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"（":{"docs":{},"消":{"docs":{},"费":{"docs":{},"）":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}},"想":{"docs":{},"了":{"docs":{},"解":{"docs":{},"更":{"docs":{},"多":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"实":{"docs":{},"现":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}},"连":{"docs":{},"接":{"docs":{},"到":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"求":{"docs":{},"分":{"docs":{},"配":{"docs":{},"到":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"以":{"docs":{},"及":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}},"验":{"docs":{},"证":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"户":{"docs":{},"是":{"docs":{},"否":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"权":{"docs":{},"限":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"将":{"docs":{},"权":{"docs":{},"限":{"docs":{},"传":{"docs":{},"入":{"docs":{},"到":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"像":{"docs":{},"接":{"docs":{},"下":{"docs":{},"来":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"：":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"角":{"docs":{},"色":{"docs":{},"，":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"参":{"docs":{},"数":{"docs":{},"前":{"docs":{},"面":{"docs":{},"加":{"docs":{},"上":{"docs":{},"角":{"docs":{},"色":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"。":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"更":{"docs":{},"具":{"docs":{},"挑":{"docs":{},"战":{"docs":{},"，":{"docs":{},"特":{"docs":{},"别":{"docs":{},"是":{"docs":{},"当":{"docs":{},"你":{"docs":{},"有":{"docs":{},"好":{"docs":{},"几":{"docs":{},"个":{"docs":{},"操":{"docs":{},"作":{"docs":{},"要":{"docs":{},"按":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"完":{"docs":{},"成":{"docs":{},"时":{"docs":{},"。":{"docs":{},"同":{"docs":{},"时":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"异":{"docs":{},"步":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"取":{"docs":{},"消":{"docs":{},"一":{"docs":{},"个":{"docs":{},"已":{"docs":{},"发":{"docs":{},"布":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"如":{"docs":{},"下":{"docs":{},"方":{"docs":{},"式":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"即":{"docs":{},"生":{"docs":{},"成":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"）":{"docs":{},"，":{"docs":{},"还":{"docs":{},"需":{"docs":{},"要":{"docs":{},"加":{"docs":{},"入":{"docs":{},"以":{"docs":{},"下":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"规":{"docs":{},"范":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"置":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"的":{"docs":{},"生":{"docs":{},"态":{"docs":{},"来":{"docs":{},"看":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"其":{"docs":{},"他":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"解":{"docs":{},"析":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"不":{"docs":{},"会":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"做":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"会":{"docs":{},"一":{"docs":{},"直":{"docs":{},"在":{"docs":{},"代":{"docs":{},"理":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"实":{"docs":{},"现":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"后":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"解":{"docs":{},"析":{"docs":{},"方":{"docs":{},"法":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"对":{"docs":{},"象":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{},"选":{"docs":{},"项":{"docs":{},"和":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"值":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"总":{"docs":{},"是":{"docs":{},"在":{"docs":{},"代":{"docs":{},"理":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"上":{"docs":{},"完":{"docs":{},"成":{"docs":{},"解":{"docs":{},"析":{"docs":{},"，":{"docs":{},"为":{"docs":{},"了":{"docs":{},"实":{"docs":{},"现":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"户":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"阶":{"docs":{},"段":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"释":{"docs":{},"运":{"docs":{},"行":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"决":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{},"查":{"docs":{},"看":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}},"触":{"docs":{},"发":{"docs":{},"一":{"docs":{},"个":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"警":{"docs":{},"告":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"大":{"docs":{},"多":{"docs":{},"数":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"确":{"docs":{},"保":{"docs":{},"您":{"docs":{},"检":{"docs":{},"查":{"docs":{},"了":{"docs":{},"生":{"docs":{},"产":{"docs":{},"系":{"docs":{},"统":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"名":{"docs":{},"，":{"docs":{},"以":{"docs":{},"避":{"docs":{},"免":{"docs":{},"恶":{"docs":{},"意":{"docs":{},"客":{"docs":{},"户":{"docs":{},"将":{"docs":{},"文":{"docs":{},"件":{"docs":{},"上":{"docs":{},"传":{"docs":{},"到":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"中":{"docs":{},"的":{"docs":{},"任":{"docs":{},"意":{"docs":{},"位":{"docs":{},"置":{"docs":{},"。":{"docs":{},"有":{"docs":{},"关":{"docs":{},"详":{"docs":{},"细":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"参":{"docs":{},"阅":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"若":{"docs":{},"您":{"docs":{},"要":{"docs":{},"直":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"谨":{"docs":{},"慎":{"docs":{},"使":{"docs":{},"用":{"docs":{},"此":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"类":{"docs":{},"加":{"docs":{},"载":{"docs":{},"器":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"导":{"docs":{},"致":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"难":{"docs":{},"于":{"docs":{},"调":{"docs":{},"试":{"docs":{},"，":{"docs":{},"变":{"docs":{},"得":{"docs":{},"一":{"docs":{},"团":{"docs":{},"乱":{"docs":{},"麻":{"docs":{},"（":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"随":{"docs":{},"后":{"docs":{},"的":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"会":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"缺":{"docs":{},"省":{"docs":{},"状":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"响":{"docs":{},"应":{"docs":{},"会":{"docs":{},"被":{"docs":{},"完":{"docs":{},"全":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"读":{"docs":{},"入":{"docs":{},"内":{"docs":{},"存":{"docs":{},"，":{"docs":{},"请":{"docs":{},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"仅":{"docs":{},"对":{"docs":{},"响":{"docs":{},"应":{"docs":{},"结":{"docs":{},"果":{"docs":{},"为":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"体":{"docs":{},"有":{"docs":{},"效":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}},"此":{"docs":{},"组":{"docs":{},"件":{"docs":{},"处":{"docs":{},"于":{"docs":{},"技":{"docs":{},"术":{"docs":{},"预":{"docs":{},"览":{"docs":{},"阶":{"docs":{},"段":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"之":{"docs":{},"后":{"docs":{},"版":{"docs":{},"本":{"docs":{},"中":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"可":{"docs":{},"能":{"docs":{},"还":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"一":{"docs":{},"些":{"docs":{},"变":{"docs":{},"更":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"记":{"docs":{},"录":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"网":{"docs":{},"络":{"docs":{},"活":{"docs":{},"动":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"网":{"docs":{},"络":{"docs":{},"活":{"docs":{},"动":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"网":{"docs":{},"络":{"docs":{},"活":{"docs":{},"动":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405}}}}}},"解":{"docs":{},"析":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"将":{"docs":{},"生":{"docs":{},"成":{"docs":{},"下":{"docs":{},"结":{"docs":{},"果":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"那":{"docs":{},"样":{"docs":{},"做":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"许":{"docs":{},"多":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"您":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"发":{"docs":{},"送":{"docs":{},"一":{"docs":{},"个":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"单":{"docs":{},"个":{"docs":{},"最":{"docs":{},"终":{"docs":{},"帧":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}},"设":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"一":{"docs":{},"个":{"docs":{},"推":{"docs":{},"送":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"感":{"docs":{},"知":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"推":{"docs":{},"送":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"资":{"docs":{},"源":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"接":{"docs":{},"收":{"docs":{},"消":{"docs":{},"息":{"docs":{},"的":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}},"只":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"指":{"docs":{},"定":{"docs":{},"i":{"docs":{},"p":{"docs":{},"地":{"docs":{},"址":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"确":{"docs":{},"保":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}},"。":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}},"了":{"docs":{},"下":{"docs":{},"限":{"docs":{},"，":{"docs":{},"则":{"docs":{},"有":{"docs":{},"效":{"docs":{},"值":{"docs":{},"可":{"docs":{},"以":{"docs":{},"更":{"docs":{},"低":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"面":{"docs":{},"两":{"docs":{},"项":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"接":{"docs":{},"收":{"docs":{},"数":{"docs":{},"据":{"docs":{},"的":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"会":{"docs":{},"话":{"docs":{},"的":{"docs":{},"过":{"docs":{},"期":{"docs":{},"时":{"docs":{},"间":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"响":{"docs":{},"应":{"docs":{},"头":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"将":{"docs":{},"用":{"docs":{},"作":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"默":{"docs":{},"认":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"状":{"docs":{},"态":{"docs":{},"码":{"docs":{},"和":{"docs":{},"消":{"docs":{},"息":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"的":{"docs":{},"w":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"值":{"docs":{},"，":{"docs":{},"此":{"docs":{},"时":{"docs":{},"，":{"docs":{},"模":{"docs":{},"块":{"docs":{},"将":{"docs":{},"自":{"docs":{},"动":{"docs":{},"部":{"docs":{},"署":{"docs":{},"在":{"docs":{},"所":{"docs":{},"有":{"docs":{},"实":{"docs":{},"例":{"docs":{},"上":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{},"启":{"docs":{},"用":{"docs":{},"压":{"docs":{},"缩":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"基":{"docs":{},"础":{"docs":{},"认":{"docs":{},"证":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"能":{"docs":{},"力":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"将":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"清":{"docs":{},"除":{"docs":{},"已":{"docs":{},"有":{"docs":{},"的":{"docs":{},"查":{"docs":{},"询":{"docs":{},"参":{"docs":{},"数":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"否":{"docs":{},"复":{"docs":{},"用":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"失":{"docs":{},"败":{"docs":{},"回":{"docs":{},"调":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}},"有":{"docs":{},"内":{"docs":{},"部":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"大":{"docs":{},"小":{"docs":{},"为":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}},"）":{"docs":{},"，":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{},"决":{"docs":{},"定":{"docs":{},"是":{"docs":{},"否":{"docs":{},"恢":{"docs":{},"复":{"docs":{},"状":{"docs":{},"态":{"docs":{},"，":{"docs":{},"此":{"docs":{},"时":{"docs":{},"进":{"docs":{},"入":{"docs":{},"半":{"docs":{},"开":{"docs":{},"启":{"docs":{},"状":{"docs":{},"态":{"docs":{},"（":{"docs":{},"h":{"docs":{},"a":{"docs":{},"l":{"docs":{},"f":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"请":{"docs":{},"不":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{},"h":{"docs":{},"a":{"docs":{},"z":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"在":{"docs":{},"这":{"docs":{},"里":{"docs":{},"省":{"docs":{},"略":{"docs":{},"掉":{"docs":{},"，":{"docs":{},"不":{"docs":{},"再":{"docs":{},"赘":{"docs":{},"述":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}},"应":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}},"证":{"docs":{},"书":{"docs":{},"颁":{"docs":{},"发":{"docs":{},"机":{"docs":{},"构":{"docs":{},"可":{"docs":{},"通":{"docs":{},"过":{"docs":{},"多":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"为":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"以":{"docs":{},"非":{"docs":{},"加":{"docs":{},"密":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"r":{"docs":{},"p":{"docs":{},"c":{"docs":{},"通":{"docs":{},"信":{"docs":{},"通":{"docs":{},"常":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"有":{"docs":{},"三":{"docs":{},"种":{"docs":{},"语":{"docs":{},"义":{"docs":{},"：":{"docs":{},"a":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}},"如":{"docs":{},"要":{"docs":{},"得":{"docs":{},"到":{"docs":{},"更":{"docs":{},"优":{"docs":{},"美":{"docs":{},"、":{"docs":{},"格":{"docs":{},"式":{"docs":{},"化":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"每":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"这":{"docs":{},"里":{"docs":{},"给":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"通":{"docs":{},"常":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"这":{"docs":{},"是":{"docs":{},"正":{"docs":{},"常":{"docs":{},"的":{"docs":{},"，":{"docs":{},"无":{"docs":{},"需":{"docs":{},"担":{"docs":{},"心":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"您":{"docs":{},"打":{"docs":{},"开":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"，":{"docs":{},"按":{"docs":{},"快":{"docs":{},"捷":{"docs":{},"键":{"docs":{},"不":{"docs":{},"停":{"docs":{},"滴":{"docs":{},"刷":{"docs":{},"新":{"docs":{},"页":{"docs":{},"面":{"docs":{},"，":{"docs":{},"就":{"docs":{},"能":{"docs":{},"看":{"docs":{},"到":{"docs":{},"该":{"docs":{},"s":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"日":{"docs":{},"志":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"在":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}},"实":{"docs":{},"际":{"docs":{},"在":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"此":{"docs":{},"处":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"参":{"docs":{},"考":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}},"：":{"docs":{},"虞":{"docs":{},"浪":{"docs":{},"，":{"docs":{},"易":{"docs":{},"世":{"docs":{},"伟":{"docs":{},"校":{"docs":{},"对":{"docs":{},"：":{"docs":{},"钟":{"docs":{},"子":{"docs":{},"期":{"docs":{},"，":{"docs":{},"易":{"docs":{},"世":{"docs":{},"伟":{"docs":{"auth/Auth.html":{"ref":"auth/Auth.html","tf":0.041666666666666664}}}}}}}}}}}}}}}}}}}}},"详":{"docs":{},"情":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"细":{"docs":{},"说":{"docs":{},"明":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"文":{"docs":{},"档":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}},"语":{"docs":{},"言":{"docs":{},"—":{"docs":{},"—":{"docs":{},"若":{"docs":{},"有":{"docs":{},"需":{"docs":{},"要":{"docs":{},"可":{"docs":{},"以":{"docs":{},"切":{"docs":{},"换":{"docs":{},"到":{"docs":{},"语":{"docs":{},"言":{"docs":{},"特":{"docs":{},"定":{"docs":{},"部":{"docs":{},"分":{"docs":{},"（":{"docs":{},"手":{"docs":{},"册":{"docs":{},"中":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"而":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"法":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"句":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}},"。":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}},"（":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}},"义":{"docs":{},"，":{"docs":{},"以":{"docs":{},"确":{"docs":{},"保":{"docs":{},"消":{"docs":{},"息":{"docs":{},"没":{"docs":{},"有":{"docs":{},"被":{"docs":{},"消":{"docs":{},"费":{"docs":{},"前":{"docs":{},"不":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"提":{"docs":{},"交":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}},"读":{"docs":{},"取":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"帧":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}},"文":{"docs":{},"件":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"超":{"docs":{},"时":{"docs":{},"时":{"docs":{},"间":{"docs":{},"，":{"docs":{},"单":{"docs":{},"位":{"docs":{},"是":{"docs":{},"毫":{"docs":{},"秒":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}},"文":{"docs":{},"件":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0002786809103576405},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.004201680672268907}},"一":{"docs":{},"些":{"docs":{},"需":{"docs":{},"要":{"docs":{},"耗":{"docs":{},"费":{"docs":{},"显":{"docs":{},"著":{"docs":{},"执":{"docs":{},"行":{"docs":{},"时":{"docs":{},"间":{"docs":{},"返":{"docs":{},"回":{"docs":{},"结":{"docs":{},"果":{"docs":{},"的":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}}}}}}}}}}}}}}}}}}}}},"了":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"这":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}},"对":{"docs":{},"应":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"失":{"docs":{},"败":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"完":{"docs":{},"毕":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"成":{"docs":{},"功":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"端":{"docs":{},"代":{"docs":{},"理":{"docs":{},"类":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}},"度":{"docs":{},"器":{"docs":{},"支":{"docs":{},"持":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"资":{"docs":{},"源":{"docs":{},"记":{"docs":{},"录":{"docs":{},"不":{"docs":{},"应":{"docs":{},"该":{"docs":{},"存":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"。":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"非":{"docs":{},"常":{"docs":{},"容":{"docs":{},"易":{"docs":{},"地":{"docs":{},"编":{"docs":{},"写":{"docs":{},"静":{"docs":{},"态":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"拥":{"docs":{},"有":{"docs":{},"者":{"docs":{},"密":{"docs":{},"码":{"docs":{},"证":{"docs":{},"书":{"docs":{},"授":{"docs":{},"权":{"docs":{},"类":{"docs":{},"型":{"docs":{},"比":{"docs":{},"较":{"docs":{},"适":{"docs":{},"合":{"docs":{},"于":{"docs":{},"这":{"docs":{},"样":{"docs":{},"一":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"：":{"docs":{},"当":{"docs":{},"资":{"docs":{},"源":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"者":{"docs":{},"和":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"之":{"docs":{},"间":{"docs":{},"有":{"docs":{},"可":{"docs":{},"信":{"docs":{},"任":{"docs":{},"的":{"docs":{},"关":{"docs":{},"系":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"如":{"docs":{},"设":{"docs":{},"备":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"、":{"docs":{},"或":{"docs":{},"高":{"docs":{},"特":{"docs":{},"权":{"docs":{},"应":{"docs":{},"用":{"docs":{},"。":{"docs":{},"授":{"docs":{},"权":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"应":{"docs":{},"该":{"docs":{},"在":{"docs":{},"很":{"docs":{},"特":{"docs":{},"殊":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"时":{"docs":{},"启":{"docs":{},"用":{"docs":{},"这":{"docs":{},"种":{"docs":{},"授":{"docs":{},"权":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"当":{"docs":{},"其":{"docs":{},"他":{"docs":{},"应":{"docs":{},"用":{"docs":{},"都":{"docs":{},"不":{"docs":{},"可":{"docs":{},"见":{"docs":{},"时":{"docs":{},"允":{"docs":{},"许":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.003305785123966942}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"路":{"docs":{},"径":{"docs":{},"部":{"docs":{},"分":{"docs":{},"应":{"docs":{},"该":{"docs":{},"是":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}},"下":{"docs":{},"挂":{"docs":{},"载":{"docs":{},"某":{"docs":{},"些":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}},"。":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}},"开":{"docs":{},"头":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"，":{"docs":{},"都":{"docs":{},"会":{"docs":{},"在":{"docs":{},"执":{"docs":{},"行":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"里":{"docs":{},"面":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}},"（":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"）":{"docs":{},"。":{"docs":{},"此":{"docs":{},"节":{"docs":{},"点":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"格":{"docs":{},"式":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}},"的":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}},"中":{"docs":{},"添":{"docs":{},"加":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}},"作":{"docs":{},"为":{"docs":{},"命":{"docs":{},"名":{"docs":{},"空":{"docs":{},"间":{"docs":{},"，":{"docs":{},"在":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}},"由":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},"。":{"docs":{},"原":{"docs":{},"文":{"docs":{},"的":{"docs":{},"最":{"docs":{},"后":{"docs":{},"几":{"docs":{},"部":{"docs":{},"分":{"docs":{},"关":{"docs":{},"于":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"顺":{"docs":{},"序":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"（":{"docs":{},"基":{"docs":{},"于":{"docs":{},"方":{"docs":{},"法":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},"、":{"docs":{},"路":{"docs":{},"径":{"docs":{},"等":{"docs":{},"）":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"docs":{}}}}}}},"或":{"docs":{},"强":{"docs":{},"制":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}},"转":{"docs":{},"换":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"为":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}},"数":{"docs":{},"据":{"docs":{},"实":{"docs":{},"体":{"docs":{},"类":{"docs":{},"）":{"docs":{},"以":{"docs":{},"及":{"docs":{},"一":{"docs":{},"个":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}},"发":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"。":{"docs":{},"此":{"docs":{},"处":{"docs":{},"有":{"docs":{},"别":{"docs":{},"于":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"变":{"docs":{},"为":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}},"运":{"docs":{},"行":{"2":{"0":{"docs":{},"个":{"docs":{},"r":{"docs":{},"u":{"docs":{},"b":{"docs":{},"y":{"docs":{},"语":{"docs":{},"言":{"docs":{},"的":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"docs":{}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"u":{"docs":{},"b":{"docs":{},"y":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"中":{"docs":{},"指":{"docs":{},"定":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"r":{"docs":{},"u":{"docs":{},"b":{"docs":{},"i":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"应":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"的":{"docs":{},"预":{"docs":{},"编":{"docs":{},"译":{"docs":{},"好":{"docs":{},"的":{"1":{"0":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"代":{"docs":{},"码":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"环":{"docs":{},"境":{"docs":{},"里":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"时":{"docs":{},"抛":{"docs":{},"出":{"docs":{},"异":{"docs":{},"常":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}},"近":{"docs":{},"似":{"docs":{},"于":{"docs":{},"普":{"docs":{},"通":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"的":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"i":{"docs":{},"d":{"docs":{},"，":{"docs":{},"该":{"docs":{},"i":{"docs":{},"d":{"docs":{},"可":{"docs":{},"用":{"docs":{},"于":{"docs":{},"之":{"docs":{},"后":{"docs":{},"取":{"docs":{},"消":{"docs":{},"该":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{},"i":{"docs":{},"d":{"docs":{},"会":{"docs":{},"传":{"docs":{},"入":{"docs":{},"给":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}},"请":{"docs":{},"求":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"未":{"docs":{},"发":{"docs":{},"送":{"docs":{},"的":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"原":{"docs":{},"始":{"docs":{},"请":{"docs":{},"求":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"才":{"docs":{},"会":{"docs":{},"被":{"docs":{},"发":{"docs":{},"送":{"docs":{},"而":{"docs":{},"且":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"之":{"docs":{},"后":{"docs":{},"才":{"docs":{},"能":{"docs":{},"发":{"docs":{},"送":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{},"大":{"docs":{},"多":{"docs":{},"数":{"docs":{},"原":{"docs":{},"始":{"docs":{},"请":{"docs":{},"求":{"docs":{},"设":{"docs":{},"置":{"docs":{},"将":{"docs":{},"会":{"docs":{},"传":{"docs":{},"播":{"docs":{},"（":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"）":{"docs":{},"到":{"docs":{},"新":{"docs":{},"请":{"docs":{},"求":{"docs":{},"中":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"多":{"docs":{},"个":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}},"此":{"docs":{},"服":{"docs":{},"务":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"）":{"docs":{},"并":{"docs":{},"标":{"docs":{},"注":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"以":{"docs":{},"下":{"docs":{},"其":{"docs":{},"中":{"docs":{},"之":{"docs":{},"一":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}},"还":{"docs":{},"将":{"docs":{},"提":{"docs":{},"供":{"docs":{},"堆":{"docs":{},"栈":{"docs":{},"跟":{"docs":{},"踪":{"docs":{},"，":{"docs":{},"以":{"docs":{},"精":{"docs":{},"确":{"docs":{},"定":{"docs":{},"位":{"docs":{},"发":{"docs":{},"生":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"的":{"docs":{},"位":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"应":{"docs":{},"提":{"docs":{},"供":{"docs":{},"受":{"docs":{},"信":{"docs":{},"存":{"docs":{},"储":{"docs":{},"的":{"docs":{},"密":{"docs":{},"码":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"密":{"docs":{},"钥":{"docs":{},"存":{"docs":{},"储":{"docs":{},"的":{"docs":{},"密":{"docs":{},"码":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"其":{"docs":{},"他":{"docs":{},"命":{"docs":{},"令":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"一":{"docs":{},"个":{"docs":{},"根":{"docs":{},"据":{"docs":{},"时":{"docs":{},"间":{"docs":{},"戳":{"docs":{},"(":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},")":{"docs":{},"来":{"docs":{},"定":{"docs":{},"位":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"下":{"docs":{},"面":{"docs":{},"需":{"docs":{},"要":{"docs":{},"提":{"docs":{},"到":{"docs":{},"的":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}},"有":{"docs":{},"一":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"覆":{"docs":{},"盖":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"那":{"docs":{},"就":{"docs":{},"是":{"docs":{},"利":{"docs":{},"用":{"docs":{},"系":{"docs":{},"统":{"docs":{},"配":{"docs":{},"置":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}}}}}}}}},"远":{"docs":{},"程":{"docs":{},"地":{"docs":{},"址":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"连":{"docs":{},"接":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065},"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513},"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00037157454714352065}}},"不":{"docs":{},"会":{"docs":{},"被":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"自":{"docs":{},"动":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"，":{"docs":{},"若":{"docs":{},"要":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"它":{"docs":{},"们":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"直":{"docs":{},"接":{"docs":{},"建":{"docs":{},"立":{"docs":{},"，":{"docs":{},"如":{"docs":{},"连":{"docs":{},"接":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"前":{"docs":{},"文":{"docs":{},"提":{"docs":{},"到":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"创":{"docs":{},"建":{"docs":{},"，":{"docs":{},"当":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"事":{"docs":{},"件":{"docs":{},"、":{"docs":{},"生":{"docs":{},"命":{"docs":{},"周":{"docs":{},"期":{"docs":{},"、":{"docs":{},"设":{"docs":{},"置":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"代":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"关":{"docs":{},"闭":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"/":{"docs":{},"g":{"docs":{},"o":{"docs":{},"a":{"docs":{},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"时":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"，":{"docs":{},"并":{"docs":{},"提":{"docs":{},"供":{"docs":{},"回":{"docs":{},"调":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"前":{"docs":{},"缀":{"docs":{},"，":{"docs":{},"并":{"docs":{},"期":{"docs":{},"望":{"docs":{},"从":{"docs":{},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"接":{"docs":{},"收":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"偏":{"docs":{},"好":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"发":{"docs":{},"送":{"docs":{},"和":{"docs":{},"接":{"docs":{},"收":{"docs":{},"消":{"docs":{},"息":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"在":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"响":{"docs":{},"应":{"docs":{},"之":{"docs":{},"前":{"docs":{},"会":{"docs":{},"发":{"docs":{},"送":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"建":{"docs":{},"立":{"docs":{},"后":{"docs":{},"可":{"docs":{},"随":{"docs":{},"时":{"docs":{},"更":{"docs":{},"改":{"docs":{},"设":{"docs":{},"置":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"它":{"docs":{},"会":{"docs":{},"向":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"发":{"docs":{},"送":{"docs":{},"其":{"docs":{},"初":{"docs":{},"始":{"docs":{},"设":{"docs":{},"置":{"docs":{},"。":{"docs":{},"定":{"docs":{},"义":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"如":{"docs":{},"何":{"docs":{},"使":{"docs":{},"用":{"docs":{},"连":{"docs":{},"接":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"初":{"docs":{},"始":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"于":{"docs":{},"多":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{},"当":{"docs":{},"您":{"docs":{},"向":{"docs":{},"同":{"docs":{},"一":{"docs":{},"台":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"发":{"docs":{},"送":{"docs":{},"多":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"更":{"docs":{},"加":{"docs":{},"有":{"docs":{},"效":{"docs":{},"使":{"docs":{},"用":{"docs":{},"连":{"docs":{},"接":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"复":{"docs":{},"用":{"docs":{},"限":{"docs":{},"制":{"docs":{},"是":{"docs":{},"在":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"上":{"docs":{},"设":{"docs":{},"置":{"docs":{},"限":{"docs":{},"制":{"docs":{},"单":{"docs":{},"个":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"流":{"docs":{},"数":{"docs":{},"量":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"，":{"docs":{},"指":{"docs":{},"的":{"docs":{},"是":{"docs":{},"创":{"docs":{},"建":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},":":{"2":{"7":{"0":{"1":{"7":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"情":{"docs":{},"况":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"池":{"docs":{},"中":{"docs":{},"最":{"docs":{},"大":{"docs":{},"等":{"docs":{},"待":{"docs":{},"连":{"docs":{},"接":{"docs":{},"数":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"启":{"docs":{},"动":{"docs":{},"后":{"docs":{},"，":{"docs":{},"维":{"docs":{},"护":{"docs":{},"任":{"docs":{},"务":{"docs":{},"第":{"docs":{},"一":{"docs":{},"次":{"docs":{},"启":{"docs":{},"动":{"docs":{},"的":{"docs":{},"时":{"docs":{},"间":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}},"最":{"docs":{},"大":{"docs":{},"连":{"docs":{},"接":{"docs":{},"数":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"，":{"docs":{},"默":{"docs":{},"认":{"1":{"5":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}},"docs":{}},"docs":{}}}}}}}},"小":{"docs":{},"连":{"docs":{},"接":{"docs":{},"数":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"最":{"docs":{},"大":{"docs":{},"存":{"docs":{},"活":{"docs":{},"时":{"docs":{},"间":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"空":{"docs":{},"闲":{"docs":{},"时":{"docs":{},"间":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}},"初":{"docs":{},"始":{"docs":{},"连":{"docs":{},"接":{"docs":{},"数":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"3":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}},"docs":{}}}}}}}}}},"地":{"docs":{},"址":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725}}}},"被":{"docs":{},"注":{"docs":{},"册":{"docs":{},"为":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"者":{"docs":{},"时":{"docs":{},"，":{"docs":{},"此":{"docs":{},"连":{"docs":{},"接":{"docs":{},"将":{"docs":{},"不":{"docs":{},"能":{"docs":{},"再":{"docs":{},"执":{"docs":{},"行":{"docs":{},"其":{"docs":{},"他":{"docs":{},"命":{"docs":{},"令":{"docs":{},"，":{"docs":{},"直":{"docs":{},"到":{"docs":{},"这":{"docs":{},"个":{"docs":{},"连":{"docs":{},"接":{"docs":{},"使":{"docs":{},"用":{"docs":{},"取":{"docs":{},"消":{"docs":{},"订":{"docs":{},"阅":{"docs":{},"者":{"docs":{},"的":{"docs":{},"命":{"docs":{},"令":{"docs":{},"。":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"上":{"docs":{},"或":{"docs":{},"失":{"docs":{},"败":{"docs":{},"时":{"docs":{},"，":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}},"续":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"追":{"docs":{},"加":{"docs":{},"上":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"到":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"退":{"docs":{},"出":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"选":{"docs":{},"择":{"docs":{},"其":{"docs":{},"中":{"docs":{},"一":{"docs":{},"个":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"绑":{"docs":{},"定":{"docs":{},"并":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"项":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"可":{"docs":{},"以":{"docs":{},"标":{"docs":{},"记":{"docs":{},"为":{"docs":{},"必":{"docs":{},"填":{"docs":{},"项":{"docs":{},"，":{"docs":{},"在":{"docs":{},"用":{"docs":{},"户":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"中":{"docs":{},"未":{"docs":{},"设":{"docs":{},"置":{"docs":{},"必":{"docs":{},"填":{"docs":{},"选":{"docs":{},"项":{"docs":{},"在":{"docs":{},"解":{"docs":{},"析":{"docs":{},"阶":{"docs":{},"段":{"docs":{},"会":{"docs":{},"引":{"docs":{},"发":{"docs":{},"异":{"docs":{},"常":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"简":{"docs":{},"单":{"docs":{},"部":{"docs":{},"署":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"实":{"docs":{},"例":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"确":{"docs":{},"定":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"的":{"docs":{},"主":{"docs":{},"类":{"docs":{},"启":{"docs":{},"动":{"docs":{},"器":{"docs":{},"。":{"docs":{},"它":{"docs":{},"通":{"docs":{},"常":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"那":{"docs":{},"么":{"docs":{},"参":{"docs":{},"数":{"docs":{},"将":{"docs":{},"包":{"docs":{},"含":{"docs":{},"以":{"docs":{},"下":{"docs":{},"内":{"docs":{},"容":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"如":{"docs":{},"何":{"docs":{},"获":{"docs":{},"取":{"docs":{},"它":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"呢":{"docs":{},"？":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"会":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"样":{"docs":{},"通":{"docs":{},"过":{"docs":{},"它":{"docs":{},"来":{"docs":{},"读":{"docs":{},"写":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{},"它":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"部":{"docs":{},"分":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"是":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"的":{"docs":{},"手":{"docs":{},"册":{"docs":{},"。":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}},"署":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"u":{"docs":{},"b":{"docs":{},"y":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"v":{"docs":{},"y":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"u":{"docs":{},"b":{"docs":{},"y":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"已":{"docs":{},"经":{"docs":{},"打":{"docs":{},"包":{"docs":{},"成":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"编":{"docs":{},"译":{"docs":{},"好":{"docs":{},"的":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"类":{"docs":{},"的":{"docs":{},"根":{"docs":{},"路":{"docs":{},"径":{"docs":{},"是":{"docs":{},"当":{"docs":{},"前":{"docs":{},"目":{"docs":{},"录":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"撤":{"docs":{},"销":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"运":{"docs":{},"行":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"完":{"docs":{},"成":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"会":{"docs":{},"破":{"docs":{},"坏":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"功":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"器":{"docs":{},"即":{"docs":{},"可":{"docs":{},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"失":{"docs":{},"败":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}},"都":{"docs":{},"会":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"自":{"docs":{},"动":{"docs":{},"进":{"docs":{},"行":{"docs":{},"扩":{"docs":{},"容":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"不":{"docs":{},"可":{"docs":{},"能":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"匹":{"docs":{},"配":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"应":{"docs":{},"该":{"docs":{},"成":{"docs":{},"功":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"必":{"docs":{},"须":{"docs":{},"遵":{"docs":{},"守":{"docs":{},"连":{"docs":{},"接":{"docs":{},"另":{"docs":{},"一":{"docs":{},"端":{"docs":{},"的":{"docs":{},"发":{"docs":{},"送":{"docs":{},"设":{"docs":{},"置":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"成":{"docs":{},"功":{"docs":{},"完":{"docs":{},"成":{"docs":{},"，":{"docs":{},"该":{"docs":{},"方":{"docs":{},"法":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"则":{"docs":{},"该":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"是":{"docs":{},"事":{"docs":{},"件":{"docs":{},"驱":{"docs":{},"动":{"docs":{},"的":{"docs":{},"，":{"docs":{},"当":{"docs":{},"有":{"docs":{},"事":{"docs":{},"件":{"docs":{},"时":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"非":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"的":{"docs":{},"并":{"docs":{},"且":{"docs":{},"不":{"docs":{},"会":{"docs":{},"阻":{"docs":{},"塞":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"绑":{"docs":{},"定":{"docs":{},"到":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"端":{"docs":{},"口":{"docs":{},"，":{"docs":{},"您":{"docs":{},"将":{"docs":{},"收":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"）":{"docs":{},"。":{"docs":{},"需":{"docs":{},"要":{"docs":{},"注":{"docs":{},"意":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}},"将":{"docs":{},"被":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"。":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.008639308855291577}}}}}}}}}}},"包":{"docs":{},"含":{"docs":{},"：":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"（":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"模":{"docs":{},"式":{"docs":{},"）":{"docs":{},"，":{"docs":{},"即":{"docs":{},"用":{"docs":{},"于":{"docs":{},"选":{"docs":{},"取":{"docs":{},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"风":{"docs":{},"格":{"docs":{},"的":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{},"此":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"模":{"docs":{},"式":{"docs":{},"使":{"docs":{},"用":{"docs":{},"相":{"docs":{},"对":{"docs":{},"路":{"docs":{},"径":{"docs":{},"确":{"docs":{},"定":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"位":{"docs":{},"置":{"docs":{},"。":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"（":{"docs":{},"格":{"docs":{},"式":{"docs":{},"）":{"docs":{},"作":{"docs":{},"为":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"格":{"docs":{},"式":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}},"要":{"docs":{},"与":{"docs":{},"服":{"docs":{},"务":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.0006502554575011612},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"j":{"docs":{},"u":{"docs":{},"l":{"docs":{},"日":{"docs":{},"志":{"docs":{},"记":{"docs":{},"录":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"v":{"docs":{},"m":{"docs":{},"虚":{"docs":{},"拟":{"docs":{},"机":{"docs":{},"选":{"docs":{},"项":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"协":{"docs":{},"议":{"docs":{},"版":{"docs":{},"本":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"密":{"docs":{},"码":{"docs":{},"套":{"docs":{},"件":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"对":{"docs":{},"应":{"docs":{},"行":{"docs":{},"为":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"日":{"docs":{},"志":{"docs":{},"记":{"docs":{},"录":{"docs":{},"时":{"docs":{},"，":{"docs":{},"您":{"docs":{},"也":{"docs":{},"应":{"docs":{},"该":{"docs":{},"关":{"docs":{},"心":{"docs":{},"配":{"docs":{},"置":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"日":{"docs":{},"志":{"docs":{},"记":{"docs":{},"录":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"端":{"docs":{},"和":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"/":{"docs":{},"t":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"网":{"docs":{},"络":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"连":{"docs":{},"接":{"docs":{},"重":{"docs":{},"试":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"项":{"docs":{},"来":{"docs":{},"启":{"docs":{},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"设":{"docs":{},"为":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"用":{"docs":{},"于":{"docs":{},"颁":{"docs":{},"发":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"（":{"docs":{},"或":{"docs":{},"依":{"docs":{},"靠":{"docs":{},"第":{"docs":{},"三":{"docs":{},"方":{"docs":{},"）":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}},"回":{"docs":{},"调":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"接":{"docs":{},"收":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}},"所":{"docs":{},"需":{"docs":{},"的":{"docs":{},"权":{"docs":{},"限":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"授":{"docs":{},"权":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"来":{"docs":{},"过":{"docs":{},"滤":{"docs":{},"请":{"docs":{},"求":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"索":{"docs":{},"引":{"docs":{},"页":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"缓":{"docs":{},"存":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"跟":{"docs":{},"目":{"docs":{},"录":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"权":{"docs":{},"限":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"选":{"docs":{},"项":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"时":{"docs":{},"可":{"docs":{},"根":{"docs":{},"据":{"docs":{},"实":{"docs":{},"际":{"docs":{},"情":{"docs":{},"况":{"docs":{},"选":{"docs":{},"择":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}},"集":{"docs":{},"群":{"docs":{},"监":{"docs":{},"视":{"docs":{},"器":{"docs":{},"监":{"docs":{},"控":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"参":{"docs":{},"数":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}},"仓":{"docs":{},"库":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.009140767824497258}},"仅":{"docs":{},"支":{"docs":{},"持":{"docs":{},"通":{"docs":{},"过":{"docs":{},"给":{"docs":{},"定":{"docs":{},"的":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}},"组":{"docs":{},"件":{"docs":{},"是":{"docs":{},"对":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.004570383912248629}}}}}},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"添":{"docs":{},"加":{"docs":{},"以":{"docs":{},"下":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.004570383912248629}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}},"内":{"docs":{},"容":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"文":{"docs":{},"件":{"docs":{},"最":{"docs":{},"终":{"docs":{},"会":{"docs":{},"以":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}},"。":{"docs":{},"具":{"docs":{},"体":{"docs":{},"配":{"docs":{},"置":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}},"在":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"官":{"docs":{},"方":{"docs":{},"可":{"docs":{},"以":{"docs":{},"网":{"docs":{},"站":{"docs":{},"可":{"docs":{},"以":{"docs":{},"详":{"docs":{},"细":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"攻":{"docs":{},"略":{"docs":{},"。":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"在":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}},"格":{"docs":{},"式":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.003656307129798903}},"组":{"docs":{},"件":{"docs":{},"是":{"docs":{},"对":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}},"，":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"添":{"docs":{},"加":{"docs":{},"以":{"docs":{},"下":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}}}}}}}}}}}}},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"结":{"docs":{},"构":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"通":{"docs":{},"过":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}},"确":{"docs":{},"保":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}},"套":{"docs":{},"的":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}},"里":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"这":{"docs":{},"对":{"docs":{},"以":{"docs":{},"优":{"docs":{},"化":{"docs":{},"网":{"docs":{},"络":{"docs":{},"协":{"docs":{},"议":{"docs":{},"和":{"docs":{},"最":{"docs":{},"小":{"docs":{},"化":{"docs":{},"带":{"docs":{},"宽":{"docs":{},"消":{"docs":{},"耗":{"docs":{},"为":{"docs":{},"目":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"的":{"docs":{},"编":{"docs":{},"解":{"docs":{},"码":{"docs":{},"器":{"docs":{},"是":{"docs":{},"很":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"单":{"docs":{},"位":{"docs":{},"以":{"docs":{},"及":{"docs":{},"起":{"docs":{},"始":{"docs":{},"、":{"docs":{},"终":{"docs":{},"止":{"docs":{},"位":{"docs":{},"置":{"docs":{},"，":{"docs":{},"则":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"将":{"docs":{},"收":{"docs":{},"到":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"通":{"docs":{},"知":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"它":{"docs":{},"支":{"docs":{},"持":{"docs":{},"范":{"docs":{},"围":{"docs":{},"请":{"docs":{},"求":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"后":{"docs":{},"续":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{},"根":{"docs":{},"目":{"docs":{},"录":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"和":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"那":{"docs":{},"个":{"docs":{},"一":{"docs":{},"般":{"docs":{},"的":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}},"重":{"docs":{},"启":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"配":{"docs":{},"置":{"docs":{},"您":{"docs":{},"的":{"docs":{},"项":{"docs":{},"目":{"docs":{},"来":{"docs":{},"访":{"docs":{},"问":{"docs":{},"它":{"docs":{},"们":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"注":{"docs":{},"册":{"docs":{},"一":{"docs":{},"个":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"策":{"docs":{},"略":{"docs":{},"如":{"docs":{},"下":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"：":{"docs":{},"当":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"认":{"docs":{},"证":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"用":{"docs":{},"于":{"docs":{},"当":{"docs":{},"未":{"docs":{},"登":{"docs":{},"录":{"docs":{},"的":{"docs":{},"用":{"docs":{},"户":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"访":{"docs":{},"问":{"docs":{},"受":{"docs":{},"保":{"docs":{},"护":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"时":{"docs":{},"将":{"docs":{},"他":{"docs":{},"们":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"到":{"docs":{},"登":{"docs":{},"录":{"docs":{},"页":{"docs":{},"上":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"新":{"docs":{},"获":{"docs":{},"取":{"docs":{},"时":{"docs":{},"，":{"docs":{},"他":{"docs":{},"们":{"docs":{},"将":{"docs":{},"重":{"docs":{},"新":{"docs":{},"部":{"docs":{},"署":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"防":{"docs":{},"止":{"docs":{},"网":{"docs":{},"络":{"docs":{},"分":{"docs":{},"区":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"脑":{"docs":{},"裂":{"docs":{},"（":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"部":{"docs":{},"署":{"docs":{},"功":{"docs":{},"能":{"docs":{},"还":{"docs":{},"支":{"docs":{},"持":{"docs":{},"以":{"docs":{},"下":{"docs":{},"设":{"docs":{},"置":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}},"过":{"docs":{},"程":{"docs":{},"如":{"docs":{},"下":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"首":{"docs":{},"先":{"docs":{},"，":{"docs":{},"您":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"作":{"docs":{},"为":{"docs":{},"后":{"docs":{},"台":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"启":{"docs":{},"动":{"docs":{},"（":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"命":{"docs":{},"令":{"docs":{},"）":{"docs":{},"。":{"docs":{},"当":{"docs":{},"发":{"docs":{},"现":{"docs":{},"文":{"docs":{},"件":{"docs":{},"更":{"docs":{},"改":{"docs":{},"时":{"docs":{},"，":{"docs":{},"该":{"docs":{},"进":{"docs":{},"程":{"docs":{},"将":{"docs":{},"停":{"docs":{},"止":{"docs":{},"并":{"docs":{},"重":{"docs":{},"新":{"docs":{},"启":{"docs":{},"动":{"docs":{},"该":{"docs":{},"应":{"docs":{},"用":{"docs":{},"、":{"docs":{},"这":{"docs":{},"样":{"docs":{},"可":{"docs":{},"避":{"docs":{},"免":{"docs":{},"泄":{"docs":{},"露":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"分":{"docs":{},"配":{"docs":{},"给":{"docs":{},"组":{"docs":{},"内":{"docs":{},"其":{"docs":{},"他":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"新":{"docs":{},"加":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{},"消":{"docs":{},"费":{"docs":{},"者":{"docs":{},"去":{"docs":{},"消":{"docs":{},"费":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"请":{"docs":{},"求":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"要":{"docs":{},"提":{"docs":{},"示":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"分":{"docs":{},"布":{"docs":{},"式":{"docs":{},"数":{"docs":{},"据":{"docs":{},"结":{"docs":{},"构":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"您":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"网":{"docs":{},"络":{"docs":{},"分":{"docs":{},"区":{"docs":{},"面":{"docs":{},"临":{"docs":{},"的":{"docs":{},"备":{"docs":{},"份":{"docs":{},"（":{"docs":{},"复":{"docs":{},"制":{"docs":{},"）":{"docs":{},"和":{"docs":{},"行":{"docs":{},"为":{"docs":{},"由":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"和":{"docs":{},"它":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"来":{"docs":{},"定":{"docs":{},"义":{"docs":{},"。":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"文":{"docs":{},"档":{"docs":{},"以":{"docs":{},"及":{"docs":{},"底":{"docs":{},"层":{"docs":{},"框":{"docs":{},"架":{"docs":{},"手":{"docs":{},"册":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"干":{"docs":{},"净":{"docs":{},"地":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"不":{"docs":{},"会":{"docs":{},"导":{"docs":{},"致":{"docs":{},"故":{"docs":{},"障":{"docs":{},"转":{"docs":{},"移":{"docs":{},"发":{"docs":{},"生":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{},"c":{"docs":{},"t":{"docs":{},"r":{"docs":{},"l":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"醒":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}},"组":{"docs":{},"为":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}},"置":{"docs":{},"状":{"docs":{},"态":{"docs":{},"超":{"docs":{},"时":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}},"载":{"docs":{},"规":{"docs":{},"则":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}},"试":{"docs":{},"策":{"docs":{},"略":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}},"锁":{"docs":{},"获":{"docs":{},"取":{"docs":{},"失":{"docs":{},"败":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"错":{"docs":{},"误":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},"代":{"docs":{},"码":{"docs":{},"会":{"docs":{},"发":{"docs":{},"送":{"docs":{},"，":{"docs":{},"您":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"发":{"docs":{},"送":{"docs":{},"另":{"docs":{},"外":{"docs":{},"一":{"docs":{},"个":{"docs":{},"错":{"docs":{},"误":{"docs":{},"代":{"docs":{},"码":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641},"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136},"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}},"时":{"docs":{},"间":{"docs":{},"戳":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"码":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"页":{"docs":{},"面":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"i":{"docs":{},"p":{"docs":{},"v":{"6":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}},"docs":{}}}}}}}}},"键":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}},"阻":{"docs":{},"塞":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"名":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"式":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"和":{"docs":{},"普":{"docs":{},"通":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"区":{"docs":{},"别":{"docs":{},"是":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"附":{"docs":{},"带":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"限":{"docs":{},"定":{"docs":{},"类":{"docs":{},"全":{"docs":{},"名":{"docs":{},"，":{"docs":{},"如":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"制":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"大":{"docs":{},"小":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"除":{"docs":{},"了":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"和":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"以":{"docs":{},"外":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"和":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}},"取":{"docs":{},"消":{"docs":{},"监":{"docs":{},"听":{"docs":{},"一":{"docs":{},"个":{"docs":{},"多":{"docs":{},"播":{"docs":{},"地":{"docs":{},"址":{"docs":{},"以":{"docs":{},"外":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"做":{"docs":{},"到":{"docs":{},"屏":{"docs":{},"蔽":{"docs":{},"指":{"docs":{},"定":{"docs":{},"发":{"docs":{},"送":{"docs":{},"者":{"docs":{},"地":{"docs":{},"址":{"docs":{},"的":{"docs":{},"多":{"docs":{},"播":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"很":{"docs":{},"少":{"docs":{},"的":{"docs":{},"特":{"docs":{},"例":{"docs":{},"（":{"docs":{},"如":{"docs":{},"以":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"上":{"docs":{},"文":{"docs":{},"所":{"docs":{},"提":{"docs":{},"到":{"docs":{},"的":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"现":{"docs":{},"成":{"docs":{},"的":{"docs":{},"格":{"docs":{},"式":{"docs":{},"支":{"docs":{},"持":{"docs":{},"以":{"docs":{},"外":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"支":{"docs":{},"持":{"docs":{},"以":{"docs":{},"外":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"此":{"docs":{},"之":{"docs":{},"外":{"docs":{},"，":{"docs":{},"u":{"docs":{},"d":{"docs":{},"p":{"docs":{},"不":{"docs":{},"像":{"docs":{},"t":{"docs":{},"c":{"docs":{},"p":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"那":{"docs":{},"样":{"docs":{},"安":{"docs":{},"全":{"docs":{},"，":{"docs":{},"这":{"docs":{},"也":{"docs":{},"就":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"不":{"docs":{},"能":{"docs":{},"保":{"docs":{},"证":{"docs":{},"发":{"docs":{},"送":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"包":{"docs":{},"一":{"docs":{},"定":{"docs":{},"会":{"docs":{},"被":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"接":{"docs":{},"收":{"docs":{},"端":{"docs":{},"（":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"接":{"docs":{},"收":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"还":{"docs":{},"可":{"docs":{},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"，":{"docs":{},"它":{"docs":{},"在":{"docs":{},"每":{"docs":{},"次":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}},"要":{"docs":{},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"每":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"置":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}},"非":{"docs":{},"您":{"docs":{},"拿":{"docs":{},"到":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"隔":{"docs":{},"离":{"docs":{},"组":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"“":{"docs":{},"受":{"docs":{},"保":{"docs":{},"护":{"docs":{},"的":{"docs":{},"”":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"这":{"docs":{},"样":{"docs":{},"执":{"docs":{},"行":{"docs":{},"它":{"docs":{},"：":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}},"集":{"docs":{},"群":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.003838771593090211}},"模":{"docs":{},"式":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"下":{"docs":{},"。":{"docs":{},"在":{"docs":{},"单":{"docs":{},"机":{"docs":{},"模":{"docs":{},"式":{"docs":{},"下":{"docs":{},"，":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"存":{"docs":{},"储":{"docs":{},"于":{"docs":{},"本":{"docs":{},"地":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"向":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"每":{"docs":{},"个":{"docs":{},"节":{"docs":{},"点":{"docs":{},"的":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"调":{"docs":{},"用":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}},"不":{"docs":{},"处":{"docs":{},"理":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"必":{"docs":{},"须":{"docs":{},"实":{"docs":{},"现":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"接":{"docs":{},"口":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"加":{"docs":{},"载":{"docs":{},"器":{"docs":{},"（":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353}},"。":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}},"的":{"docs":{},"介":{"docs":{},"绍":{"docs":{},"见":{"docs":{"clustering/Clustering.html":{"ref":"clustering/Clustering.html","tf":0.029411764705882353}}}}}},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"下":{"docs":{},"几":{"docs":{},"个":{"docs":{},"功":{"docs":{},"能":{"docs":{},"：":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}},"以":{"docs":{},"下":{"docs":{},"几":{"docs":{},"个":{"docs":{},"功":{"docs":{},"能":{"docs":{},"：":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}},"的":{"docs":{},"可":{"docs":{},"插":{"docs":{},"拔":{"docs":{},"性":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"轻":{"docs":{},"易":{"docs":{},"切":{"docs":{},"换":{"docs":{},"至":{"docs":{},"其":{"docs":{},"它":{"docs":{},"的":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}}}}}}},"范":{"docs":{},"围":{"docs":{},"异":{"docs":{},"步":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}},"计":{"docs":{},"时":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"锁":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"具":{"docs":{},"有":{"docs":{},"异":{"docs":{},"步":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"，":{"docs":{},"它":{"docs":{},"和":{"docs":{},"大":{"docs":{},"多":{"docs":{},"数":{"docs":{},"等":{"docs":{},"待":{"docs":{},"锁":{"docs":{},"释":{"docs":{},"放":{"docs":{},"的":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"调":{"docs":{},"用":{"docs":{},"线":{"docs":{},"程":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"锁":{"docs":{},"不":{"docs":{},"相":{"docs":{},"同":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"）":{"docs":{},"允":{"docs":{},"许":{"docs":{},"您":{"docs":{},"在":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"获":{"docs":{},"取":{"docs":{},"独":{"docs":{},"占":{"docs":{},"锁":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"共":{"docs":{},"享":{"docs":{},"访":{"docs":{},"问":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"某":{"docs":{},"个":{"docs":{},"运":{"docs":{},"行":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"监":{"docs":{},"听":{"docs":{},"的":{"docs":{},"端":{"docs":{},"口":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"会":{"docs":{},"话":{"docs":{},"存":{"docs":{},"储":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"自":{"docs":{},"动":{"docs":{},"把":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"的":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"相":{"docs":{},"关":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{},"，":{"docs":{},"只":{"docs":{},"有":{"docs":{},"跟":{"docs":{},"路":{"docs":{},"径":{"docs":{},"可":{"docs":{},"以":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}}}}}}}}}}}}},"监":{"docs":{},"视":{"docs":{},"器":{"docs":{},"访":{"docs":{},"问":{"docs":{},"每":{"docs":{},"个":{"docs":{},"集":{"docs":{},"群":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"的":{"docs":{},"频":{"docs":{},"率":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"分":{"docs":{},"片":{"docs":{},"／":{"docs":{},"复":{"docs":{},"制":{"docs":{},"）":{"docs":{},"的":{"docs":{},"一":{"docs":{},"组":{"docs":{},"地":{"docs":{},"址":{"docs":{},"和":{"docs":{},"端":{"docs":{},"口":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}},"上":{"docs":{},"消":{"docs":{},"费":{"docs":{},"或":{"docs":{},"者":{"docs":{},"发":{"docs":{},"送":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"错":{"docs":{},"误":{"docs":{},"（":{"docs":{},"如":{"docs":{},"超":{"docs":{},"时":{"docs":{},"）":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}}},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}},"使":{"docs":{},"用":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}},"关":{"docs":{},"闭":{"docs":{},"。":{"docs":{},"同":{"docs":{},"时":{"docs":{},"需":{"docs":{},"要":{"docs":{},"禁":{"docs":{},"用":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}},"启":{"docs":{},"动":{"docs":{},"，":{"docs":{},"后":{"docs":{},"于":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}},"器":{"docs":{},"并":{"docs":{},"不":{"docs":{},"处":{"docs":{},"理":{"docs":{},"节":{"docs":{},"点":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"通":{"docs":{},"信":{"docs":{},"，":{"docs":{},"在":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}},"通":{"docs":{},"讯":{"docs":{},"交":{"docs":{},"互":{"docs":{},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"采":{"docs":{},"用":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}},"能":{"docs":{},"够":{"docs":{},"正":{"docs":{},"常":{"docs":{},"运":{"docs":{},"行":{"docs":{},"在":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"参":{"docs":{},"考":{"docs":{},"文":{"docs":{},"档":{"docs":{"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.007352941176470588}}}}}}}}}}}},"合":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}},"中":{"docs":{},"某":{"docs":{},"一":{"docs":{},"个":{"docs":{},"作":{"docs":{},"者":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"文":{"docs":{},"档":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"文":{"docs":{},"档":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0013577732518669382}}}}}}}}},"，":{"docs":{},"实":{"docs":{},"际":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}},"成":{"docs":{},"起":{"docs":{},"来":{"docs":{},"很":{"docs":{},"自":{"docs":{},"然":{"docs":{},"：":{"docs":{},"它":{"docs":{},"使":{"docs":{},"得":{"docs":{},"无":{"docs":{},"论":{"docs":{},"什":{"docs":{},"么":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"我":{"docs":{},"们":{"docs":{},"能":{"docs":{},"使":{"docs":{},"用":{"docs":{},"流":{"docs":{},"和":{"docs":{},"异":{"docs":{},"步":{"docs":{},"结":{"docs":{},"果":{"docs":{},"，":{"docs":{},"就":{"docs":{},"能":{"docs":{},"使":{"docs":{},"用":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"从":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{},"读":{"docs":{},"取":{"docs":{},"文":{"docs":{},"件":{"docs":{},"（":{"docs":{},"嵌":{"docs":{},"入":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}},"的":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"握":{"docs":{},"手":{"docs":{},"，":{"docs":{},"但":{"docs":{},"可":{"docs":{},"以":{"docs":{},"提":{"docs":{},"供":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"(":{"1":{"1":{"docs":{},")":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"h":{"docs":{},"i":{"docs":{},"k":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"你":{"docs":{},"只":{"docs":{},"能":{"docs":{},"在":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}},"需":{"docs":{},"要":{"docs":{},"通":{"docs":{},"过":{"docs":{},"如":{"docs":{},"下":{"docs":{},"配":{"docs":{},"置":{"docs":{},"来":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"醒":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"节":{"docs":{},"点":{"docs":{},"注":{"docs":{},"册":{"docs":{},"了":{"docs":{},"服":{"docs":{},"务":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"，":{"docs":{},"集":{"docs":{},"群":{"docs":{},"中":{"docs":{},"所":{"docs":{},"有":{"docs":{},"成":{"docs":{},"员":{"docs":{},"就":{"docs":{},"都":{"docs":{},"能":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"读":{"docs":{},"取":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"列":{"docs":{},"表":{"docs":{},"（":{"docs":{},"模":{"docs":{},"式":{"docs":{},"）":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}},"（":{"docs":{},"等":{"docs":{},"同":{"docs":{},"于":{"docs":{},"目":{"docs":{},"录":{"docs":{},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"方":{"docs":{},"式":{"docs":{},"）":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}},"非":{"docs":{},"常":{"docs":{},"灵":{"docs":{},"活":{"docs":{},"，":{"docs":{},"它":{"docs":{},"支":{"docs":{},"持":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"适":{"docs":{},"合":{"docs":{},"编":{"docs":{},"写":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"必":{"docs":{},"填":{"docs":{},"选":{"docs":{},"项":{"docs":{},"可":{"docs":{},"以":{"docs":{},"具":{"docs":{},"有":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"用":{"docs":{},"户":{"docs":{},"没":{"docs":{},"有":{"docs":{},"在":{"docs":{},"命":{"docs":{},"令":{"docs":{},"行":{"docs":{},"中":{"docs":{},"设":{"docs":{},"置":{"docs":{},"该":{"docs":{},"选":{"docs":{},"项":{"docs":{},"，":{"docs":{},"即":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"该":{"docs":{},"值":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},")":{"docs":{},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}},"标":{"docs":{},"准":{"docs":{},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"法":{"docs":{},"密":{"docs":{},"钥":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"签":{"docs":{},"名":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"阻":{"docs":{},"塞":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},"性":{"docs":{},"的":{"docs":{},"特":{"docs":{},"性":{"docs":{},"产":{"docs":{},"生":{"docs":{},"了":{"docs":{},"异":{"docs":{},"步":{"docs":{},"的":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}},"页":{"docs":{},"面":{"docs":{},"上":{"docs":{},"找":{"docs":{},"到":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"项":{"docs":{},"目":{"docs":{},"中":{"docs":{},"以":{"docs":{},"正":{"docs":{},"常":{"docs":{},"方":{"docs":{},"式":{"docs":{},"添":{"docs":{},"加":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"若":{"docs":{},"干":{"docs":{},"开":{"docs":{},"箱":{"docs":{},"即":{"docs":{},"用":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"，":{"docs":{},"则":{"docs":{},"只":{"docs":{},"需":{"docs":{},"将":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"作":{"docs":{},"为":{"docs":{},"项":{"docs":{},"目":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"添":{"docs":{},"加":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"空":{"docs":{},"间":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}},"顺":{"docs":{},"序":{"docs":{},"合":{"docs":{},"并":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"执":{"docs":{},"行":{"docs":{},"（":{"docs":{},"一":{"docs":{},"个":{"docs":{},"接":{"docs":{},"一":{"docs":{},"个":{"docs":{},"）":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"高":{"docs":{},"可":{"docs":{},"用":{"docs":{},"/":{"docs":{},"故":{"docs":{},"障":{"docs":{},"转":{"docs":{},"移":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"h":{"docs":{},"a":{"docs":{},"实":{"docs":{},"现":{"docs":{},"同":{"docs":{},"样":{"docs":{},"支":{"docs":{},"持":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"和":{"docs":{},"故":{"docs":{},"障":{"docs":{},"转":{"docs":{},"移":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}},"性":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033}}}}}},"黄":{"docs":{},"金":{"docs":{},"法":{"docs":{},"则":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"：":{"docs":{},"不":{"docs":{},"要":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"主":{"docs":{},"机":{"docs":{},"名":{"docs":{},"是":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{},"，":{"docs":{},"它":{"docs":{},"表":{"docs":{},"示":{"docs":{},"：":{"docs":{},"监":{"docs":{},"听":{"docs":{},"所":{"docs":{},"有":{"docs":{},"可":{"docs":{},"用":{"docs":{},"地":{"docs":{},"址":{"docs":{},"；":{"docs":{},"默":{"docs":{},"认":{"docs":{},"端":{"docs":{},"口":{"docs":{},"号":{"docs":{},"是":{"8":{"0":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}},"允":{"docs":{},"许":{"docs":{},"任":{"docs":{},"何":{"docs":{},"基":{"docs":{},"本":{"docs":{},"/":{"docs":{},"简":{"docs":{},"单":{"docs":{},"类":{"docs":{},"型":{"docs":{},"、":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}},"，":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"选":{"docs":{},"择":{"docs":{},"使":{"docs":{},"用":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"，":{"docs":{},"其":{"docs":{},"余":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"用":{"docs":{},"于":{"docs":{},"故":{"docs":{},"障":{"docs":{},"转":{"docs":{},"移":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"a":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"配":{"docs":{},"置":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"以":{"docs":{},"下":{"docs":{},"协":{"docs":{},"议":{"docs":{},"版":{"docs":{},"本":{"docs":{},"：":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"v":{"2":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"、":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"v":{"1":{"docs":{},"、":{"docs":{},"t":{"docs":{},"l":{"docs":{},"s":{"docs":{},"v":{"1":{"docs":{},".":{"1":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}},"docs":{}}},"docs":{}}}}}}},"docs":{}}}}}}}}}}}},"docs":{}}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"不":{"docs":{},"会":{"docs":{},"记":{"docs":{},"录":{"docs":{},"任":{"docs":{},"何":{"docs":{},"指":{"docs":{},"标":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"，":{"docs":{},"它":{"docs":{},"为":{"docs":{},"其":{"docs":{},"他":{"docs":{},"人":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"p":{"docs":{},"i":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"其":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"中":{"docs":{},"。":{"docs":{},"s":{"docs":{},"p":{"docs":{},"i":{"docs":{},"是":{"docs":{},"一":{"docs":{},"项":{"docs":{},"高":{"docs":{},"级":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"允":{"docs":{},"许":{"docs":{},"实":{"docs":{},"施":{"docs":{},"者":{"docs":{},"从":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"事":{"docs":{},"件":{"docs":{},"以":{"docs":{},"收":{"docs":{},"集":{"docs":{},"指":{"docs":{},"标":{"docs":{},"。":{"docs":{},"有":{"docs":{},"关":{"docs":{},"详":{"docs":{},"细":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"多":{"docs":{},"个":{"docs":{},"连":{"docs":{},"接":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"是":{"docs":{},"被":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}},"如":{"docs":{},"果":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"它":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"环":{"docs":{},"境":{"docs":{},"中":{"docs":{},"系":{"docs":{},"统":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"地":{"docs":{},"址":{"docs":{},"的":{"docs":{},"列":{"docs":{},"表":{"docs":{},"，":{"docs":{},"若":{"docs":{},"该":{"docs":{},"列":{"docs":{},"表":{"docs":{},"无":{"docs":{},"法":{"docs":{},"检":{"docs":{},"索":{"docs":{},"，":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"公":{"docs":{},"共":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"主":{"docs":{},"机":{"docs":{},"验":{"docs":{},"证":{"docs":{},"。":{"docs":{},"要":{"docs":{},"启":{"docs":{},"用":{"docs":{},"主":{"docs":{},"机":{"docs":{},"验":{"docs":{},"证":{"docs":{},"，":{"docs":{},"请":{"docs":{},"在":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"上":{"docs":{},"设":{"docs":{},"置":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"算":{"docs":{},"法":{"docs":{},"（":{"docs":{},"目":{"docs":{},"前":{"docs":{},"仅":{"docs":{},"支":{"docs":{},"持":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},"和":{"docs":{},"l":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{},"）":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"解":{"docs":{},"析":{"docs":{},"器":{"docs":{},"将":{"docs":{},"使":{"docs":{},"用":{"docs":{},"环":{"docs":{},"境":{"docs":{},"中":{"docs":{},"的":{"docs":{},"系":{"docs":{},"统":{"docs":{},"d":{"docs":{},"n":{"docs":{},"s":{"docs":{},"搜":{"docs":{},"索":{"docs":{},"域":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"，":{"docs":{},"可":{"docs":{},"提":{"docs":{},"供":{"docs":{},"明":{"docs":{},"确":{"docs":{},"的":{"docs":{},"显":{"docs":{},"示":{"docs":{},"搜":{"docs":{},"索":{"docs":{},"域":{"docs":{},"列":{"docs":{},"表":{"docs":{},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"v":{"docs":{},"m":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"压":{"docs":{},"缩":{"docs":{},"被":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}},"最":{"docs":{},"大":{"docs":{},"的":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"数":{"docs":{},"为":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}},"，":{"docs":{},"发":{"docs":{},"送":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}},"当":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"部":{"docs":{},"署":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"时":{"docs":{},"它":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"当":{"docs":{},"前":{"docs":{},"类":{"docs":{},"加":{"docs":{},"载":{"docs":{},"器":{"docs":{},"来":{"docs":{},"加":{"docs":{},"载":{"docs":{},"类":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"会":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"。":{"docs":{},"大":{"docs":{},"多":{"docs":{},"数":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"这":{"docs":{},"是":{"docs":{},"最":{"docs":{},"简":{"docs":{},"单":{"docs":{},"、":{"docs":{},"最":{"docs":{},"清":{"docs":{},"晰":{"docs":{},"和":{"docs":{},"最":{"docs":{},"干":{"docs":{},"净":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.01079913606911447}},"不":{"docs":{},"分":{"docs":{},"块":{"docs":{},"的":{"docs":{},"，":{"docs":{},"当":{"docs":{},"处":{"docs":{},"于":{"docs":{},"分":{"docs":{},"块":{"docs":{},"模":{"docs":{},"式":{"docs":{},"，":{"docs":{},"每":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{},"任":{"docs":{},"意":{"docs":{},"一":{"docs":{},"个":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00018578727357176033},"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"代":{"docs":{},"码":{"docs":{},"会":{"docs":{},"在":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}},"会":{"docs":{},"拒":{"docs":{},"绝":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{},"您":{"docs":{},"需":{"docs":{},"要":{"docs":{},"告":{"docs":{},"诉":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"哪":{"docs":{},"些":{"docs":{},"消":{"docs":{},"息":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"的":{"docs":{},"。":{"docs":{},"（":{"docs":{},"例":{"docs":{},"外":{"docs":{},"情":{"docs":{},"况":{"docs":{},"是":{"docs":{},"，":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"回":{"docs":{},"复":{"docs":{},"消":{"docs":{},"息":{"docs":{},"都":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"的":{"docs":{},"）":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"没":{"docs":{},"有":{"docs":{},"消":{"docs":{},"息":{"docs":{},"体":{"docs":{},"大":{"docs":{},"小":{"docs":{},"限":{"docs":{},"制":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"路":{"docs":{},"由":{"docs":{},"的":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"与":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"，":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"为":{"docs":{},"了":{"docs":{},"让":{"docs":{},"浏":{"docs":{},"览":{"docs":{},"器":{"docs":{},"有":{"docs":{},"效":{"docs":{},"地":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"文":{"docs":{},"件":{"docs":{},"，":{"docs":{},"静":{"docs":{},"态":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"设":{"docs":{},"置":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"为":{"docs":{},"隐":{"docs":{},"藏":{"docs":{},"文":{"docs":{},"件":{"docs":{},"提":{"docs":{},"供":{"docs":{},"服":{"docs":{},"务":{"docs":{},"（":{"docs":{},"文":{"docs":{},"件":{"docs":{},"名":{"docs":{},"以":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"果":{"docs":{},"不":{"docs":{},"配":{"docs":{},"置":{"docs":{},"权":{"docs":{},"限":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"只":{"docs":{},"要":{"docs":{},"登":{"docs":{},"录":{"docs":{},"了":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"访":{"docs":{},"问":{"docs":{},"资":{"docs":{},"源":{"docs":{},"。":{"docs":{},"否":{"docs":{},"则":{"docs":{},"，":{"docs":{},"用":{"docs":{},"户":{"docs":{},"不":{"docs":{},"仅":{"docs":{},"需":{"docs":{},"要":{"docs":{},"登":{"docs":{},"录":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"需":{"docs":{},"要":{"docs":{},"具":{"docs":{},"有":{"docs":{},"所":{"docs":{},"需":{"docs":{},"的":{"docs":{},"权":{"docs":{},"限":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"您":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"永":{"docs":{},"远":{"docs":{},"不":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"变":{"docs":{},"化":{"docs":{},"，":{"docs":{},"则":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"内":{"docs":{},"容":{"docs":{},"会":{"docs":{},"永":{"docs":{},"远":{"docs":{},"有":{"docs":{},"效":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"资":{"docs":{},"源":{"docs":{},"都":{"docs":{},"以":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"模":{"docs":{},"板":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"请":{"docs":{},"求":{"docs":{},"会":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"实":{"docs":{},"践":{"docs":{},"将":{"docs":{},"会":{"docs":{},"查":{"docs":{},"找":{"docs":{},"这":{"docs":{},"些":{"docs":{},"别":{"docs":{},"名":{"docs":{},"，":{"docs":{},"然":{"docs":{},"而":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"算":{"docs":{},"法":{"docs":{},"都":{"docs":{},"需":{"docs":{},"要":{"docs":{},"存":{"docs":{},"在":{"docs":{},"。":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"好":{"docs":{},"的":{"docs":{},"实":{"docs":{},"践":{"docs":{},"h":{"docs":{},"s":{"2":{"5":{"6":{"docs":{},"应":{"docs":{},"该":{"docs":{},"存":{"docs":{},"在":{"docs":{},"：":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"实":{"docs":{},"现":{"docs":{},"将":{"docs":{},"会":{"docs":{},"在":{"docs":{},"类":{"docs":{},"路":{"docs":{},"径":{"docs":{},"里":{"docs":{},"查":{"docs":{},"找":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}},"角":{"docs":{},"色":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"是":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"置":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"改":{"docs":{},"变":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"。":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"在":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"使":{"docs":{},"用":{"docs":{},"混":{"docs":{},"合":{"docs":{},"模":{"docs":{},"式":{"docs":{},"，":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"地":{"docs":{},"刷":{"docs":{},"新":{"docs":{},"种":{"docs":{},"子":{"docs":{},"，":{"docs":{},"非":{"docs":{},"阻":{"docs":{},"塞":{"docs":{},"式":{"docs":{},"地":{"docs":{},"生":{"docs":{},"成":{"docs":{},"随":{"docs":{},"机":{"docs":{},"数":{"docs":{},"(":{"7":{"docs":{},")":{"docs":{},"。":{"docs":{},"p":{"docs":{},"r":{"docs":{},"n":{"docs":{},"g":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"共":{"docs":{},"享":{"docs":{},"的":{"docs":{},"连":{"docs":{},"接":{"docs":{},"池":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}},"写":{"docs":{},"操":{"docs":{},"作":{"docs":{},"级":{"docs":{},"别":{"docs":{},"是":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"为":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.009950248756218905}}},"配":{"docs":{},"置":{"docs":{},"下":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}},"禁":{"docs":{},"用":{"docs":{},"组":{"docs":{},"播":{"docs":{},"。":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"一":{"docs":{},"下":{"docs":{},"启":{"docs":{},"用":{"docs":{},"组":{"docs":{},"播":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}}}}}}}}},"监":{"docs":{},"听":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}},"采":{"docs":{},"用":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}},"（":{"1":{"docs":{},"s":{"docs":{},"）":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"5":{"docs":{},"s":{"docs":{},"）":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}},"扩":{"docs":{},"展":{"docs":{},"包":{"docs":{},"）":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"包":{"docs":{},"是":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{},"的":{"docs":{},"子":{"docs":{},"项":{"docs":{},"目":{"docs":{},"集":{"docs":{},"合":{"docs":{},"，":{"docs":{},"类":{"docs":{},"似":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"、":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"您":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}},"可":{"docs":{},"选":{"docs":{},"）":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"继":{"docs":{},"承":{"docs":{},"了":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"，":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"，":{"docs":{},"h":{"docs":{},"a":{"docs":{},"l":{"docs":{},"f":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"）":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}},"）":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"标":{"docs":{},"记":{"docs":{},"启":{"docs":{},"动":{"docs":{},"完":{"docs":{},"成":{"docs":{},"或":{"docs":{},"失":{"docs":{},"败":{"docs":{},"了":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}},"：":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016},"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"一":{"docs":{},"些":{"docs":{},"配":{"docs":{},"置":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"是":{"docs":{},"包":{"docs":{},"含":{"docs":{},"描":{"docs":{},"述":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"文":{"docs":{},"本":{"docs":{},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"该":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"搜":{"docs":{},"索":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"和":{"docs":{},"它":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"其":{"docs":{},"他":{"docs":{},"任":{"docs":{},"何":{"docs":{},"资":{"docs":{},"源":{"docs":{},"的":{"docs":{},"路":{"docs":{},"径":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{},".":{"docs":{},"（":{"docs":{},"当":{"docs":{},"前":{"docs":{},"目":{"docs":{},"录":{"docs":{},"）":{"docs":{},"。":{"docs":{},"若":{"docs":{},"您":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"引":{"docs":{},"用":{"docs":{},"了":{"docs":{},"其":{"docs":{},"他":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"、":{"docs":{},"类":{"docs":{},"或":{"docs":{},"其":{"docs":{},"他":{"docs":{},"资":{"docs":{},"源":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"文":{"docs":{},"件":{"docs":{},"）":{"docs":{},"，":{"docs":{},"请":{"docs":{},"确":{"docs":{},"保":{"docs":{},"这":{"docs":{},"些":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"、":{"docs":{},"其":{"docs":{},"他":{"docs":{},"资":{"docs":{},"源":{"docs":{},"存":{"docs":{},"在":{"docs":{},"此":{"docs":{},"路":{"docs":{},"径":{"docs":{},"上":{"docs":{},"。":{"docs":{},"该":{"docs":{},"路":{"docs":{},"径":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"由":{"docs":{},"以":{"docs":{},"下":{"docs":{},"内":{"docs":{},"容":{"docs":{},"分":{"docs":{},"隔":{"docs":{},"的":{"docs":{},"多":{"docs":{},"个":{"docs":{},"路":{"docs":{},"径":{"docs":{},"条":{"docs":{},"目":{"docs":{},"：":{"docs":{},":":{"docs":{},"（":{"docs":{},"冒":{"docs":{},"号":{"docs":{},"）":{"docs":{},"或":{"docs":{},";":{"docs":{},"（":{"docs":{},"分":{"docs":{},"号":{"docs":{},"）":{"docs":{},"—":{"docs":{},"—":{"docs":{},"这":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"操":{"docs":{},"作":{"docs":{},"系":{"docs":{},"统":{"docs":{},"。":{"docs":{},"每":{"docs":{},"个":{"docs":{},"路":{"docs":{},"径":{"docs":{},"条":{"docs":{},"目":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"包":{"docs":{},"含":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"的":{"docs":{},"目":{"docs":{},"录":{"docs":{},"的":{"docs":{},"绝":{"docs":{},"对":{"docs":{},"路":{"docs":{},"径":{"docs":{},"或":{"docs":{},"相":{"docs":{},"对":{"docs":{},"路":{"docs":{},"径":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"或":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{},"绝":{"docs":{},"对":{"docs":{},"或":{"docs":{},"相":{"docs":{},"对":{"docs":{},"文":{"docs":{},"件":{"docs":{},"名":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"示":{"docs":{},"例":{"docs":{},"路":{"docs":{},"径":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"要":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"数":{"docs":{},"目":{"docs":{},"，":{"docs":{},"每":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"都":{"docs":{},"是":{"docs":{},"严":{"docs":{},"格":{"docs":{},"单":{"docs":{},"线":{"docs":{},"程":{"docs":{},"（":{"docs":{},"运":{"docs":{},"行":{"docs":{},"）":{"docs":{},"的":{"docs":{},"，":{"docs":{},"以":{"docs":{},"便":{"docs":{},"在":{"docs":{},"可":{"docs":{},"用":{"docs":{},"的":{"docs":{},"核":{"docs":{},"上":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"能":{"docs":{},"需":{"docs":{},"要":{"docs":{},"部":{"docs":{},"署":{"docs":{},"多":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"若":{"docs":{},"省":{"docs":{},"略":{"docs":{},"，":{"docs":{},"则":{"docs":{},"部":{"docs":{},"署":{"docs":{},"单":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{"core/Core.html":{"ref":"core/Core.html","tf":0.00009289363678588016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"认":{"docs":{},"证":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}},",":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.017412935323383085}},"是":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}},"来":{"docs":{},"指":{"docs":{},"定":{"docs":{},"集":{"docs":{},"群":{"docs":{},"管":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}},"`":{"docs":{},"*":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"o":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},".":{"docs":{},"h":{"docs":{},"b":{"docs":{},"s":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"/":{"docs":{},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"/":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"/":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0009737098344693282}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"/":{"docs":{},"b":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"/":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0012171372930866603}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"/":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"h":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"/":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"d":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"l":{"docs":{},"b":{"docs":{},"u":{"docs":{},"m":{"docs":{},"s":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"/":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0014605647517039922}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"g":{"docs":{},"r":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"`":{"docs":{},"、":{"docs":{},"`":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"o":{"docs":{},"o":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},":":{"8":{"0":{"8":{"0":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"s":{"2":{"5":{"6":{"docs":{},"`":{"docs":{},":":{"docs":{},":":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}},"docs":{}},"docs":{}},"3":{"8":{"4":{"docs":{},"`":{"docs":{},":":{"docs":{},":":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}},"docs":{}},"docs":{}},"5":{"1":{"2":{"docs":{},"`":{"docs":{},":":{"docs":{},":":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}},"docs":{}},"docs":{}},"docs":{}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"s":{"docs":{},".":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"/":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0007302823758519961}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}}},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"b":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"`":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"e":{"docs":{},"s":{"2":{"5":{"6":{"docs":{},"`":{"docs":{},":":{"docs":{},":":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}},"docs":{}},"docs":{}},"3":{"8":{"4":{"docs":{},"`":{"docs":{},":":{"docs":{},":":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}},"docs":{}},"docs":{}},"5":{"1":{"2":{"docs":{},"`":{"docs":{},":":{"docs":{},":":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}},"docs":{}},"docs":{}},"docs":{}}},"r":{"docs":{},"s":{"2":{"5":{"6":{"docs":{},"`":{"docs":{},":":{"docs":{},":":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}},"docs":{}},"docs":{}},"3":{"8":{"4":{"docs":{},"`":{"docs":{},":":{"docs":{},":":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}},"docs":{}},"docs":{}},"5":{"1":{"2":{"docs":{},"`":{"docs":{},":":{"docs":{},":":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}},"docs":{}},"docs":{}},"docs":{}}}},"”":{"docs":{},"漂":{"docs":{},"亮":{"docs":{},"“":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"个":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}},"步":{"docs":{},"骤":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"令":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}},"牌":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}},"来":{"docs":{},"作":{"docs":{},"为":{"docs":{},"访":{"docs":{},"问":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"。":{"docs":{},"这":{"docs":{},"对":{"docs":{},"于":{"docs":{},"需":{"docs":{},"要":{"docs":{},"混":{"docs":{},"合":{"docs":{},"基":{"docs":{},"于":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"的":{"docs":{},"授":{"docs":{},"权":{"docs":{},"和":{"docs":{},"基":{"docs":{},"于":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"种":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"发":{"docs":{},"送":{"docs":{},"明":{"docs":{},"文":{"docs":{},"信":{"docs":{},"息":{"docs":{},"（":{"docs":{},"通":{"docs":{},"常":{"docs":{},"是":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"）":{"docs":{},"，":{"docs":{},"其":{"docs":{},"内":{"docs":{},"容":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"验":{"docs":{},"证":{"docs":{},"为":{"docs":{},"是":{"docs":{},"可":{"docs":{},"信":{"docs":{},"的":{"docs":{},"。":{"docs":{},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"这":{"docs":{},"些":{"docs":{},"场":{"docs":{},"景":{"docs":{},"j":{"docs":{},"w":{"docs":{},"t":{"docs":{},"是":{"docs":{},"非":{"docs":{},"常":{"docs":{},"适":{"docs":{},"用":{"docs":{},"的":{"docs":{},"：":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"位":{"docs":{},"的":{"docs":{},"熵":{"docs":{},"作":{"docs":{},"为":{"docs":{},"种":{"docs":{},"子":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"策":{"docs":{},"略":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"系":{"docs":{},"统":{"docs":{},"属":{"docs":{},"性":{"docs":{},"来":{"docs":{},"设":{"docs":{},"置":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}},"置":{"docs":{},"开":{"docs":{},"始":{"docs":{},"消":{"docs":{},"费":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"到":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0013253810470510272}}}}}}},"保":{"docs":{},"护":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}},"存":{"docs":{},"文":{"docs":{},"档":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"这":{"docs":{},"个":{"docs":{},"发":{"docs":{},"布":{"docs":{},"记":{"docs":{},"录":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"后":{"docs":{},"面":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"取":{"docs":{},"消":{"docs":{},"发":{"docs":{},"布":{"docs":{},"或":{"docs":{},"者":{"docs":{},"修":{"docs":{},"改":{"docs":{},"发":{"docs":{},"布":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"持":{"docs":{},"一":{"docs":{},"致":{"docs":{},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"决":{"docs":{},"定":{"docs":{},"路":{"docs":{},"由":{"docs":{},"一":{"docs":{},"个":{"docs":{},"请":{"docs":{},"求":{"docs":{},"到":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"的":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}},"则":{"docs":{},"您":{"docs":{},"可":{"docs":{},"以":{"docs":{},"配":{"docs":{},"置":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"暂":{"docs":{},"停":{"docs":{},"读":{"docs":{},"取":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"删":{"docs":{},"除":{"docs":{},"产":{"docs":{},"品":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"单":{"docs":{},"个":{"docs":{},"文":{"docs":{},"档":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"文":{"docs":{},"档":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"匹":{"docs":{},"配":{"docs":{},"对":{"docs":{},"应":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"所":{"docs":{},"有":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"名":{"docs":{},"称":{"docs":{},"为":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},"的":{"docs":{},"记":{"docs":{},"录":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"了":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"占":{"docs":{},"位":{"docs":{},"符":{"docs":{},"由":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"合":{"docs":{},"并":{"docs":{},"表":{"docs":{},"单":{"docs":{},"属":{"docs":{},"性":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"回":{"docs":{},"收":{"docs":{},"的":{"docs":{},"周":{"docs":{},"期":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"调":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582},"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"您":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"处":{"docs":{},"理":{"docs":{},"授":{"docs":{},"权":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"的":{"docs":{},"响":{"docs":{},"应":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"很":{"docs":{},"重":{"docs":{},"要":{"docs":{},"的":{"docs":{},"事":{"docs":{},"情":{"docs":{},"是":{"docs":{},"，":{"docs":{},"来":{"docs":{},"自":{"docs":{},"授":{"docs":{},"权":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"的":{"docs":{},"响":{"docs":{},"应":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"次":{"docs":{},"有":{"docs":{},"效":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"如":{"docs":{},"果":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"对":{"docs":{},"回":{"docs":{},"调":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"顾":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"到":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}},"图":{"docs":{},"标":{"docs":{},"可":{"docs":{},"以":{"docs":{},"指":{"docs":{},"定":{"docs":{},"为":{"docs":{},"文":{"docs":{},"件":{"docs":{},"系":{"docs":{},"统":{"docs":{},"上":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"路":{"docs":{},"径":{"docs":{},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}},"套":{"docs":{},"接":{"docs":{},"字":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"创":{"docs":{},"建":{"docs":{},"时":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"该":{"docs":{},"事":{"docs":{},"件":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"。":{"docs":{},"该":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"用":{"docs":{},"于":{"docs":{},"将":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"端":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"会":{"docs":{},"被":{"docs":{},"安":{"docs":{},"装":{"docs":{},"到":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}},"，":{"docs":{},"在":{"docs":{},"亚":{"docs":{},"马":{"docs":{},"逊":{"docs":{},"云":{"docs":{},"上":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}}}}}}}},"字":{"docs":{},"段":{"docs":{},"来":{"docs":{},"提":{"docs":{},"供":{"docs":{},"资":{"docs":{},"源":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"版":{"docs":{},"本":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"消":{"docs":{},"息":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"的":{"docs":{},"目":{"docs":{},"标":{"docs":{},"地":{"docs":{},"址":{"docs":{},"与":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"匹":{"docs":{},"配":{"docs":{},"了":{"docs":{},"这":{"docs":{},"个":{"docs":{},"正":{"docs":{},"则":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"，":{"docs":{},"则":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"成":{"docs":{},"功":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}},"回":{"docs":{},"调":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"可":{"docs":{},"以":{"docs":{},"获":{"docs":{},"得":{"docs":{},"保":{"docs":{},"存":{"docs":{},"后":{"docs":{},"生":{"docs":{},"成":{"docs":{},"的":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}},"文":{"docs":{},"档":{"docs":{},"会":{"docs":{},"被":{"docs":{},"保":{"docs":{},"存":{"docs":{},"。":{"docs":{},"若":{"docs":{},"有":{"docs":{},"，":{"docs":{},"将":{"docs":{},"执":{"docs":{},"行":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}},"插":{"docs":{},"入":{"docs":{},"。":{"docs":{},"并":{"docs":{},"且":{"docs":{},"读":{"docs":{},"取":{"docs":{},"这":{"docs":{},"个":{"docs":{},"字":{"docs":{},"段":{"docs":{},"：":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"生":{"docs":{},"成":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}},"导":{"docs":{},"致":{"docs":{},"协":{"docs":{},"议":{"docs":{},"运":{"docs":{},"行":{"docs":{},"的":{"docs":{},"不":{"docs":{},"完":{"docs":{},"整":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"已":{"docs":{},"更":{"docs":{},"名":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"经":{"docs":{},"弃":{"docs":{},"用":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}},"帮":{"docs":{},"助":{"docs":{},"您":{"docs":{},"快":{"docs":{},"速":{"docs":{},"地":{"docs":{},"配":{"docs":{},"置":{"docs":{},"基":{"docs":{},"于":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"库":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"。":{"docs":{},"它":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"类":{"docs":{},"似":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"来":{"docs":{},"和":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"实":{"docs":{},"现":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"配":{"docs":{},"置":{"docs":{},"就":{"docs":{},"是":{"docs":{},"用":{"docs":{},"于":{"docs":{},"指":{"docs":{},"定":{"docs":{},"这":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}},"库":{"docs":{},"借":{"docs":{},"助":{"docs":{},"字":{"docs":{},"节":{"docs":{},"码":{"docs":{},"增":{"docs":{},"强":{"docs":{},"(":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}},"你":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"需":{"docs":{},"要":{"docs":{},"继":{"docs":{},"承":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}},"非":{"docs":{},"常":{"docs":{},"相":{"docs":{},"似":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}}}},"建":{"docs":{},"立":{"docs":{},"连":{"docs":{},"接":{"docs":{},"，":{"docs":{},"并":{"docs":{},"发":{"docs":{},"送":{"docs":{},"/":{"docs":{},"接":{"docs":{},"收":{"docs":{},"消":{"docs":{},"息":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}},"循":{"docs":{},"环":{"docs":{},"有":{"docs":{},"点":{"docs":{},"奇":{"docs":{},"怪":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"必":{"docs":{},"须":{"docs":{},"按":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"选":{"docs":{},"择":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"本":{"docs":{},"地":{"docs":{},"化":{"docs":{},"方":{"docs":{},"式":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}},"微":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"但":{"docs":{},"我":{"docs":{},"们":{"docs":{},"不":{"docs":{},"强":{"docs":{},"制":{"docs":{},"您":{"docs":{},"必":{"docs":{},"须":{"docs":{},"把":{"docs":{},"应":{"docs":{},"用":{"docs":{},"实":{"docs":{},"现":{"docs":{},"成":{"docs":{},"这":{"docs":{},"样":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}},"挂":{"docs":{},"载":{"docs":{},"到":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}}}}}}}},"捕":{"docs":{},"捉":{"docs":{},"路":{"docs":{},"径":{"docs":{},"参":{"docs":{},"数":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"换":{"docs":{},"句":{"docs":{},"话":{"docs":{},"说":{"docs":{},"，":{"docs":{},"桥":{"docs":{},"接":{"docs":{},"器":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"像":{"docs":{},"是":{"docs":{},"配":{"docs":{},"置":{"docs":{},"了":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"授":{"docs":{},"权":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"通":{"docs":{},"过":{"docs":{},"权":{"docs":{},"限":{"docs":{},"来":{"docs":{},"保":{"docs":{},"护":{"docs":{},"资":{"docs":{},"源":{"docs":{},"不":{"docs":{},"被":{"docs":{},"未":{"docs":{},"为":{"docs":{},"授":{"docs":{},"权":{"docs":{},"的":{"docs":{},"用":{"docs":{},"户":{"docs":{},"访":{"docs":{},"问":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"密":{"docs":{},"码":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"用":{"docs":{},"户":{"docs":{},"名":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"：":{"docs":{},"用":{"docs":{},"于":{"docs":{},"验":{"docs":{},"证":{"docs":{},"用":{"docs":{},"户":{"docs":{},"是":{"docs":{},"否":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"访":{"docs":{},"问":{"docs":{},"系":{"docs":{},"统":{"docs":{},"的":{"docs":{},"许":{"docs":{},"可":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"：":{"docs":{},"b":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{"auth/JWTAuth.html":{"ref":"auth/JWTAuth.html","tf":0.0026954177897574125}}}}}}}}},"码":{"docs":{},"—":{"docs":{},"—":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}},"授":{"docs":{},"权":{"docs":{},"类":{"docs":{},"型":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"访":{"docs":{},"问":{"docs":{},"令":{"docs":{},"牌":{"docs":{},"（":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}}}}}}},"流":{"docs":{},"程":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}},"主":{"docs":{},"要":{"docs":{},"包":{"docs":{},"含":{"docs":{},"两":{"docs":{},"部":{"docs":{},"分":{"docs":{},"内":{"docs":{},"容":{"docs":{},"：":{"docs":{"auth/Oauth2.html":{"ref":"auth/Oauth2.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}},"排":{"docs":{},"序":{"docs":{},"的":{"docs":{},"语":{"docs":{},"言":{"docs":{},"偏":{"docs":{},"好":{"docs":{},"列":{"docs":{},"表":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}},"暴":{"docs":{},"露":{"docs":{},"的":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}},"你":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}},"权":{"docs":{},"限":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204},"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}},"来":{"docs":{},"列":{"docs":{},"举":{"docs":{},"产":{"docs":{},"品":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"：":{"docs":{},"它":{"docs":{},"取":{"docs":{},"决":{"docs":{},"于":{"docs":{},"一":{"docs":{},"些":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"系":{"docs":{},"统":{"docs":{},"实":{"docs":{},"现":{"docs":{},"但":{"docs":{},"对":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"模":{"docs":{},"型":{"docs":{},"不":{"docs":{},"做":{"docs":{},"任":{"docs":{},"何":{"docs":{},"要":{"docs":{},"求":{"docs":{},"；":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{},"许":{"docs":{},"可":{"docs":{},"/":{"docs":{},"角":{"docs":{},"色":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"/":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"模":{"docs":{},"型":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"事":{"docs":{},"情":{"docs":{},"变":{"docs":{},"得":{"docs":{},"灵":{"docs":{},"活":{"docs":{},"。":{"docs":{},"在":{"docs":{},"一":{"docs":{},"些":{"docs":{},"实":{"docs":{},"现":{"docs":{},"中":{"docs":{},"一":{"docs":{},"个":{"docs":{},"权":{"docs":{},"限":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"述":{"docs":{},"一":{"docs":{},"个":{"docs":{},"许":{"docs":{},"可":{"docs":{},"，":{"docs":{},"如":{"docs":{},"：":{"docs":{},"有":{"docs":{},"权":{"docs":{},"限":{"docs":{},"访":{"docs":{},"问":{"docs":{},"所":{"docs":{},"有":{"docs":{},"打":{"docs":{},"印":{"docs":{},"机":{"docs":{},"、":{"docs":{},"或":{"docs":{},"特":{"docs":{},"定":{"docs":{},"打":{"docs":{},"印":{"docs":{},"机":{"docs":{},"。":{"docs":{},"在":{"docs":{},"另":{"docs":{},"外":{"docs":{},"一":{"docs":{},"些":{"docs":{},"实":{"docs":{},"现":{"docs":{},"中":{"docs":{},"则":{"docs":{},"必":{"docs":{},"须":{"docs":{},"支":{"docs":{},"持":{"docs":{},"角":{"docs":{},"色":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"通":{"docs":{},"常":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"些":{"docs":{},"角":{"docs":{},"色":{"docs":{},"信":{"docs":{},"息":{"docs":{},"对":{"docs":{},"权":{"docs":{},"限":{"docs":{},"进":{"docs":{},"行":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{},"命":{"docs":{},"名":{"docs":{},"/":{"docs":{},"标":{"docs":{},"识":{"docs":{},"，":{"docs":{},"如":{"docs":{},"：":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{},"a":{"docs":{},"d":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"。":{"docs":{},"还":{"docs":{},"有":{"docs":{},"一":{"docs":{},"些":{"docs":{},"实":{"docs":{},"现":{"docs":{},"也":{"docs":{},"许":{"docs":{},"会":{"docs":{},"包":{"docs":{},"含":{"docs":{},"更":{"docs":{},"加":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"以":{"docs":{},"及":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"模":{"docs":{},"型":{"docs":{},"来":{"docs":{},"表":{"docs":{},"述":{"docs":{},"权":{"docs":{},"限":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"缓":{"docs":{},"存":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}},"某":{"docs":{},"些":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"失":{"docs":{},"败":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"会":{"docs":{},"由":{"docs":{},"于":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"集":{"docs":{},"作":{"docs":{},"为":{"docs":{},"状":{"docs":{},"态":{"docs":{},"消":{"docs":{},"息":{"docs":{},"而":{"docs":{},"导":{"docs":{},"致":{"docs":{},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"您":{"docs":{},"的":{"docs":{},"查":{"docs":{},"询":{"docs":{},"语":{"docs":{},"句":{"docs":{},"可":{"docs":{},"能":{"docs":{},"返":{"docs":{},"回":{"docs":{},"多":{"docs":{},"个":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"异":{"docs":{},"步":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}},"时":{"docs":{},"候":{"docs":{},"也":{"docs":{},"被":{"docs":{},"称":{"docs":{},"为":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"您":{"docs":{},"可":{"docs":{},"能":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"里":{"docs":{},"执":{"docs":{},"行":{"docs":{},"一":{"docs":{},"些":{"docs":{},"需":{"docs":{},"要":{"docs":{},"阻":{"docs":{},"塞":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"不":{"docs":{},"带":{"docs":{},"有":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"）":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"种":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"，":{"docs":{},"是":{"docs":{},"无":{"docs":{},"法":{"docs":{},"获":{"docs":{},"取":{"docs":{},"到":{"docs":{},"服":{"docs":{},"务":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"）":{"docs":{},"的":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"和":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"连":{"docs":{},"接":{"docs":{},"的":{"docs":{},"细":{"docs":{},"节":{"docs":{},"。":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"个":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"桥":{"docs":{},"接":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.0004868549172346641}},"器":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}},"事":{"docs":{},"件":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"从":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"k":{"docs":{},"u":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"（":{"docs":{},"或":{"docs":{},"者":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}},"将":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"将":{"docs":{},"会":{"docs":{},"在":{"docs":{},"启":{"docs":{},"动":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},")":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"导":{"docs":{},"入":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"在":{"docs":{},"停":{"docs":{},"止":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},")":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"移":{"docs":{},"除":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"。":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"期":{"docs":{},"间":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"监":{"docs":{},"听":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.0015329586101175269}}}},"配":{"docs":{},"置":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}},"项":{"docs":{},"有":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}},"混":{"docs":{},"合":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}},"新":{"docs":{},"的":{"docs":{},"产":{"docs":{},"品":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"消":{"docs":{},"息":{"docs":{},"头":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"1":{"docs":{},"（":{"docs":{},"参":{"docs":{},"数":{"1":{"docs":{},"）":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"docs":{}}}}},"3":{"docs":{},"（":{"docs":{},"参":{"docs":{},"数":{"3":{"docs":{},"）":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"docs":{}}}}},"docs":{}}}}}}}},"登":{"docs":{},"录":{"docs":{},"表":{"docs":{},"单":{"docs":{},"数":{"docs":{},"据":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}},"策":{"docs":{},"略":{"docs":{},"的":{"docs":{},"防":{"docs":{},"火":{"docs":{},"墙":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}},"）":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"精":{"docs":{},"确":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"，":{"docs":{},"则":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"成":{"docs":{},"功":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}},"经":{"docs":{},"验":{"docs":{},"法":{"docs":{},"则":{"docs":{},"是":{"docs":{},"：":{"docs":{},"当":{"docs":{},"有":{"docs":{},"效":{"docs":{},"的":{"docs":{},"回":{"docs":{},"调":{"docs":{},"执":{"docs":{},"行":{"docs":{},"时":{"docs":{},"，":{"docs":{},"通":{"docs":{},"知":{"docs":{},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"跳":{"docs":{},"转":{"docs":{},"到":{"docs":{},"受":{"docs":{},"保":{"docs":{},"护":{"docs":{},"的":{"docs":{},"资":{"docs":{},"源":{"docs":{},"上":{"docs":{},"。":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"认":{"docs":{},"证":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333},"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}},"/":{"docs":{},"授":{"docs":{},"权":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"登":{"docs":{},"录":{"docs":{},"和":{"docs":{},"授":{"docs":{},"权":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"：":{"docs":{},"用":{"docs":{},"于":{"docs":{},"验":{"docs":{},"证":{"docs":{},"用":{"docs":{},"户":{"docs":{},"的":{"docs":{},"标":{"docs":{},"识":{"docs":{},"和":{"docs":{},"身":{"docs":{},"份":{"docs":{},"。":{"docs":{"auth/AuthCommon.html":{"ref":"auth/AuthCommon.html","tf":0.008333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"超":{"docs":{},"时":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}},"时":{"docs":{},"间":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}},"跨":{"docs":{},"域":{"docs":{},"请":{"docs":{},"求":{"docs":{},"伪":{"docs":{},"造":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"资":{"docs":{},"源":{"docs":{},"共":{"docs":{},"享":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"，":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}},"站":{"docs":{},"点":{"docs":{},"请":{"docs":{},"求":{"docs":{},"伪":{"docs":{},"造":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}},"隐":{"docs":{},"藏":{"docs":{},"文":{"docs":{},"件":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"静":{"docs":{},"态":{"docs":{},"文":{"docs":{},"件":{"docs":{},"服":{"docs":{},"务":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"以":{"docs":{},"及":{"docs":{},"目":{"docs":{},"录":{"docs":{},"监":{"docs":{},"听":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}},"资":{"docs":{},"源":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"于":{"docs":{},"列":{"docs":{},"举":{"docs":{},"目":{"docs":{},"录":{"docs":{},"的":{"docs":{},"文":{"docs":{},"件":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"该":{"docs":{},"功":{"docs":{},"能":{"docs":{},"是":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"的":{"docs":{},"。":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"服":{"docs":{},"务":{"docs":{"web/Web.html":{"ref":"web/Web.html","tf":0.00024342745861733204}}}}}},"方":{"docs":{},"法":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0018467220683287165}},"里":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"用":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"但":{"docs":{},"这":{"docs":{},"不":{"docs":{},"是":{"docs":{},"必":{"docs":{},"须":{"docs":{},"的":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}},"予":{"docs":{},"以":{"docs":{},"配":{"docs":{},"置":{"docs":{},"：":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}},"再":{"docs":{},"次":{"docs":{},"发":{"docs":{},"送":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}},"请":{"docs":{},"求":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}},"制":{"docs":{},"作":{"docs":{},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}},"填":{"docs":{},"充":{"docs":{},"请":{"docs":{},"求":{"docs":{},"体":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}},"头":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}},"废":{"docs":{},"弃":{"docs":{},"响":{"docs":{},"应":{"docs":{},"体":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}},"映":{"docs":{},"射":{"docs":{},"为":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}},"成":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}},"普":{"docs":{},"通":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}},"欧":{"docs":{},"洲":{"docs":{},"中":{"docs":{},"部":{"docs":{},"时":{"docs":{},"间":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}},"统":{"docs":{},"一":{"docs":{},"的":{"docs":{},"错":{"docs":{},"误":{"docs":{},"处":{"docs":{},"理":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}},"缺":{"docs":{},"省":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"提":{"docs":{},"交":{"docs":{},"表":{"docs":{},"单":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"头":{"docs":{},"中":{"docs":{},"的":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}},"状":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"响":{"docs":{},"应":{"docs":{},"以":{"docs":{},"缓":{"docs":{},"冲":{"docs":{},"形":{"docs":{},"式":{"docs":{},"提":{"docs":{},"供":{"docs":{},"，":{"docs":{},"并":{"docs":{},"不":{"docs":{},"提":{"docs":{},"供":{"docs":{},"任":{"docs":{},"何":{"docs":{},"形":{"docs":{},"式":{"docs":{},"的":{"docs":{},"解":{"docs":{},"码":{"docs":{},"。":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}}}}}}}}},"客":{"docs":{},"户":{"docs":{},"端":{"docs":{},"将":{"docs":{},"会":{"docs":{},"依":{"docs":{},"照":{"3":{"0":{"docs":{},"x":{"docs":{},"状":{"docs":{},"态":{"docs":{},"码":{"docs":{},"自":{"docs":{},"动":{"docs":{},"重":{"docs":{},"定":{"docs":{},"向":{"docs":{},"，":{"docs":{},"您":{"docs":{},"可":{"docs":{},"使":{"docs":{},"用":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}},"覆":{"docs":{},"盖":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"1":{"docs":{},"（":{"docs":{},"参":{"docs":{},"数":{"1":{"docs":{},"）":{"docs":{},"同":{"docs":{},"时":{"docs":{},"新":{"docs":{},"增":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"2":{"docs":{},"（":{"docs":{},"参":{"docs":{},"数":{"2":{"docs":{},"）":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"docs":{}}}}},"docs":{}}}}}}}}}}}},"docs":{}}}}},"2":{"docs":{},"（":{"docs":{},"参":{"docs":{},"数":{"2":{"docs":{},"）":{"docs":{"webclient/WebClient.html":{"ref":"webclient/WebClient.html","tf":0.000931098696461825}}}},"docs":{}}}}},"docs":{}}}}}}}},"]":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.03225806451612903}},",":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"_":{"docs":{},"i":{"docs":{},"d":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.004073319755600814}}}}},"却":{"docs":{},"是":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}},"天":{"docs":{},"生":{"docs":{},"就":{"docs":{},"是":{"docs":{},"处":{"docs":{},"理":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"快":{"docs":{},"速":{"docs":{},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{},"和":{"docs":{},"反":{"docs":{},"序":{"docs":{},"列":{"docs":{},"化":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}},"意":{"docs":{},"思":{"docs":{},"是":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"此":{"docs":{},"文":{"docs":{},"档":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"就":{"docs":{},"保":{"docs":{},"存":{"docs":{},"此":{"docs":{},"文":{"docs":{},"档":{"docs":{},"，":{"docs":{},"此":{"docs":{},"文":{"docs":{},"档":{"docs":{},"存":{"docs":{},"在":{"docs":{},"就":{"docs":{},"更":{"docs":{},"新":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}},"；":{"docs":{},"此":{"docs":{},"文":{"docs":{},"档":{"docs":{},"存":{"docs":{},"在":{"docs":{},"就":{"docs":{},"更":{"docs":{},"新":{"docs":{},"）":{"docs":{},"或":{"docs":{},"者":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"只":{"docs":{},"更":{"docs":{},"新":{"docs":{},"，":{"docs":{},"请":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"拥":{"docs":{},"有":{"docs":{},"多":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"我":{"docs":{},"们":{"docs":{},"希":{"docs":{},"望":{"docs":{},"每":{"docs":{},"个":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691},"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}},"您":{"docs":{},"希":{"docs":{},"望":{"docs":{},"每":{"docs":{},"个":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}}}}}}},"插":{"docs":{},"入":{"docs":{},"文":{"docs":{},"档":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}},"件":{"docs":{},"机":{"docs":{},"制":{"docs":{},"向":{"docs":{},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"包":{"docs":{},"中":{"docs":{},"添":{"docs":{},"加":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"注":{"docs":{},"解":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"。":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}},"期":{"docs":{},"望":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"枚":{"docs":{},"举":{"docs":{},"类":{"docs":{},"型":{"docs":{},"来":{"docs":{},"代":{"docs":{},"表":{"docs":{},"的":{"docs":{},"）":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}},"特":{"docs":{},"点":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"达":{"docs":{},"到":{"docs":{},"了":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}},"成":{"docs":{},"离":{"docs":{},"线":{"docs":{},"增":{"docs":{},"强":{"docs":{},"(":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}},"驱":{"docs":{},"动":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.004901960784313725}},"参":{"docs":{},"数":{"docs":{},"说":{"docs":{},"明":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}},"大":{"docs":{},"部":{"docs":{},"分":{"docs":{},"配":{"docs":{},"置":{"docs":{},"项":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"。":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"驱":{"docs":{},"动":{"docs":{},"文":{"docs":{},"档":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"最":{"docs":{},"新":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}}}}}}},"选":{"docs":{},"择":{"docs":{},"服":{"docs":{},"务":{"docs":{},"器":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"时":{"docs":{},"间":{"docs":{},"，":{"docs":{},"单":{"docs":{},"位":{"docs":{},"毫":{"docs":{},"秒":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}}}}}}}}}},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"具":{"docs":{},"体":{"docs":{},"选":{"docs":{},"项":{"docs":{"data/MongoDBClient.html":{"ref":"data/MongoDBClient.html","tf":0.0006788866259334691}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},"包":{"docs":{},"放":{"docs":{},"在":{"docs":{},"编":{"docs":{},"译":{"docs":{},"路":{"docs":{},"径":{"docs":{},"下":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}},"包":{"docs":{},"加":{"docs":{},"到":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}},"含":{"docs":{},"在":{"docs":{},"里":{"docs":{},"面":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"我":{"docs":{},"们":{"docs":{},"的":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}},"在":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}},"类":{"docs":{},"名":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"就":{"docs":{},"不":{"docs":{},"能":{"docs":{},"作":{"docs":{},"为":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}},"卸":{"docs":{},"载":{"docs":{},"（":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"）":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"自":{"docs":{},"动":{"docs":{},"关":{"docs":{},"闭":{"docs":{},"。":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}}}}}}},"常":{"docs":{},"用":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"参":{"docs":{},"数":{"docs":{},"有":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"些":{"docs":{},"：":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}},"考":{"docs":{},"虑":{"docs":{},"这":{"docs":{},"样":{"docs":{},"一":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"：":{"docs":{},"我":{"docs":{},"们":{"docs":{},"在":{"docs":{},"部":{"docs":{},"署":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}},"您":{"docs":{},"在":{"docs":{},"部":{"docs":{},"署":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}}}}}}}}}}}}},"预":{"docs":{},"处":{"docs":{},"理":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"语":{"docs":{},"句":{"docs":{},"最":{"docs":{},"小":{"docs":{},"缓":{"docs":{},"存":{"docs":{},"数":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{"data/JDBCClient.html":{"ref":"data/JDBCClient.html","tf":0.0024509803921568627}}}}}}}}}}}}}}}}},"编":{"docs":{},"译":{"docs":{},"或":{"docs":{},"者":{"docs":{},"调":{"docs":{},"用":{"docs":{},"语":{"docs":{},"句":{"docs":{},"将":{"docs":{},"会":{"docs":{},"根":{"docs":{},"据":{"docs":{},"参":{"docs":{},"数":{"docs":{},"列":{"docs":{},"表":{"docs":{},"，":{"docs":{},"来":{"docs":{},"重":{"docs":{},"复":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}},"更":{"docs":{},"新":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}},"查":{"docs":{},"询":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}},"何":{"docs":{},"时":{"docs":{},"停":{"docs":{},"止":{"docs":{},"，":{"docs":{},"何":{"docs":{},"时":{"docs":{},"恢":{"docs":{},"复":{"docs":{},"，":{"docs":{},"何":{"docs":{},"时":{"docs":{},"结":{"docs":{},"束":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"查":{"docs":{},"询":{"docs":{},"返":{"docs":{},"回":{"docs":{},"多":{"docs":{},"个":{"docs":{},"结":{"docs":{},"果":{"docs":{},"集":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"您":{"docs":{},"应":{"docs":{},"该":{"docs":{},"使":{"docs":{},"用":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"公":{"docs":{},"共":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}},"接":{"docs":{},"口":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"3":{"docs":{},"种":{"docs":{},"批":{"docs":{},"量":{"docs":{},"操":{"docs":{},"作":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}},"docs":{}}}}}}}},"批":{"docs":{},"量":{"docs":{},"操":{"docs":{},"作":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0027359781121751026}},"能":{"docs":{},"执":{"docs":{},"行":{"docs":{},"一":{"docs":{},"组":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}},"调":{"docs":{},"用":{"docs":{},"语":{"docs":{},"句":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}},"预":{"docs":{},"编":{"docs":{},"译":{"docs":{},"操":{"docs":{},"作":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}},"输":{"docs":{},"入":{"docs":{},"参":{"docs":{},"数":{"docs":{},"集":{"docs":{},"（":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"）":{"docs":{},"，":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"data/SQLCommon.html":{"ref":"data/SQLCommon.html","tf":0.0013679890560875513}}}}}}}}}}}}}}}}}}}}}}}}},"切":{"docs":{},"换":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}},"脚":{"docs":{},"本":{"docs":{},"的":{"docs":{},"相":{"docs":{},"关":{"docs":{},"命":{"docs":{},"令":{"docs":{"data/RedisClient.html":{"ref":"data/RedisClient.html","tf":0.0021598272138228943}}}}}}}}},"存":{"docs":{},"储":{"docs":{},"过":{"docs":{},"程":{"docs":{"data/MySQL&PostgreSQLClient.html":{"ref":"data/MySQL&PostgreSQLClient.html","tf":0.0024875621890547263}}}},"后":{"docs":{},"端":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.001021972406745018}},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"如":{"docs":{},"下":{"docs":{},"的":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"包":{"docs":{},"加":{"docs":{},"入":{"docs":{},"到":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"配":{"docs":{},"置":{"docs":{},"文":{"docs":{},"件":{"docs":{},"中":{"docs":{},"：":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}},"分":{"docs":{},"布":{"docs":{},"式":{"docs":{},"计":{"docs":{},"数":{"docs":{},"器":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}},"锁":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}},"通":{"docs":{},"过":{"docs":{},"接":{"docs":{},"口":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635}}}}}}},"在":{"docs":{},"，":{"docs":{},"那":{"docs":{},"首":{"docs":{},"先":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"更":{"docs":{},"新":{"docs":{},"（":{"docs":{},"如":{"docs":{},"果":{"docs":{},"需":{"docs":{},"要":{"docs":{},"切":{"docs":{},"换":{"docs":{},"分":{"docs":{},"支":{"docs":{},"就":{"docs":{},"切":{"docs":{},"换":{"docs":{},"分":{"docs":{},"支":{"docs":{},"）":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"更":{"docs":{},"新":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"那":{"docs":{},"配":{"docs":{},"置":{"docs":{},"读":{"docs":{},"取":{"docs":{},"也":{"docs":{},"会":{"docs":{},"失":{"docs":{},"败":{"docs":{},"。":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"低":{"docs":{},"位":{"docs":{},"就":{"docs":{},"是":{"docs":{},"时":{"docs":{},"间":{"docs":{},"戳":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}}}}},"侦":{"docs":{},"听":{"docs":{},"分":{"docs":{},"配":{"docs":{},"结":{"docs":{},"果":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}},"偏":{"docs":{},"移":{"docs":{},"量":{"docs":{},"查":{"docs":{},"询":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}},"手":{"docs":{},"动":{"docs":{},"提":{"docs":{},"交":{"docs":{},"偏":{"docs":{},"移":{"docs":{},"量":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"机":{"docs":{},"制":{"docs":{},"去":{"docs":{},"消":{"docs":{},"费":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"器":{"docs":{},"禁":{"docs":{},"用":{"docs":{},"组":{"docs":{},"播":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}},"多":{"docs":{},"播":{"docs":{"clustering/JGroups.html":{"ref":"clustering/JGroups.html","tf":0.0049261083743842365}}}}}}}},"比":{"docs":{},"如":{"docs":{},"创":{"docs":{},"建":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}},"起":{"docs":{},"很":{"docs":{},"多":{"docs":{},"历":{"docs":{},"史":{"docs":{},"遗":{"docs":{},"留":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"系":{"docs":{},"统":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},".":{"docs":{},"x":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}},"订":{"docs":{},"阅":{"docs":{},"单":{"docs":{},"个":{"docs":{},"主":{"docs":{},"题":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}},"多":{"docs":{},"个":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{"integration/KafkaClient.html":{"ref":"integration/KafkaClient.html","tf":0.0006626905235255136}}}}}}}}},"绑":{"docs":{},"定":{"docs":{},"端":{"docs":{},"口":{"docs":{},"的":{"docs":{},"事":{"docs":{},"件":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"者":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"来":{"docs":{},"自":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}},"！":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{"auth/JDBCAuth.html":{"ref":"auth/JDBCAuth.html","tf":0.008771929824561403},"auth/MongoDBAuth.html":{"ref":"auth/MongoDBAuth.html","tf":0.006802721088435374}}}}}}},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"的":{"docs":{},"：":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}}}}}},"角":{"docs":{},"色":{"docs":{},"模":{"docs":{},"型":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}}}},"验":{"docs":{},"证":{"docs":{"auth/ShiroAuth.html":{"ref":"auth/ShiroAuth.html","tf":0.0049261083743842365}}}},"·":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},".":{"docs":{},"r":{"docs":{},"x":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"x":{"docs":{},"·":{"docs":{},"类":{"docs":{},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"吧":{"docs":{},"。":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"增":{"docs":{},"强":{"docs":{},"的":{"docs":{},"r":{"docs":{},"x":{"docs":{},"化":{"docs":{},"的":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}}}},"未":{"docs":{},"提":{"docs":{},"供":{"docs":{},"针":{"docs":{},"对":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}}}}},"辅":{"docs":{},"以":{"docs":{"reactive/Rx.html":{"ref":"reactive/Rx.html","tf":0.0009233610341643582}}}},"、":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182},"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0058309037900874635}}},"把":{"docs":{},"从":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}},"数":{"docs":{},"据":{"docs":{},"从":{"docs":{},"这":{"docs":{},"个":{"docs":{},"流":{"docs":{},"泵":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{"reactive/Reactivestreams.html":{"ref":"reactive/Reactivestreams.html","tf":0.005681818181818182}}}}}}}}}}}}},"借":{"docs":{},"助":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}},"技":{"docs":{},"术":{"docs":{},"完":{"docs":{},"成":{"docs":{},"的":{"docs":{},"。":{"docs":{"reactive/Sync.html":{"ref":"reactive/Sync.html","tf":0.0031847133757961785}}}}}}}},"动":{"docs":{},"态":{"docs":{},"性":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}},"号":{"docs":{},"来":{"docs":{},"代":{"docs":{},"表":{"docs":{},"必":{"docs":{},"须":{"docs":{},"存":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"值":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"管":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"值":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}},"新":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"被":{"docs":{},"导":{"docs":{},"入":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}},"过":{"docs":{},"滤":{"docs":{},"器":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{},"对":{"docs":{},"象":{"docs":{},"中":{"docs":{},"的":{"docs":{},"每":{"docs":{},"个":{"docs":{},"条":{"docs":{},"目":{"docs":{},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"用":{"docs":{},"来":{"docs":{},"过":{"docs":{},"滤":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"。":{"docs":{},"服":{"docs":{},"务":{"docs":{},"记":{"docs":{},"录":{"docs":{},"必":{"docs":{},"须":{"docs":{},"满":{"docs":{},"足":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"条":{"docs":{},"目":{"docs":{},"要":{"docs":{},"求":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"条":{"docs":{},"目":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{"microservices/ServiceDiscovery.html":{"ref":"microservices/ServiceDiscovery.html","tf":0.000510986203372509}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"仪":{"docs":{},"表":{"docs":{},"板":{"docs":{},"中":{"docs":{},"，":{"docs":{},"配":{"docs":{},"置":{"docs":{},"流":{"docs":{},"网":{"docs":{},"址":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"个":{"docs":{},"发":{"docs":{},"送":{"docs":{},"指":{"docs":{},"标":{"docs":{},"的":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"流":{"docs":{},"，":{"docs":{},"此":{"docs":{},"流":{"docs":{},"由":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}},"半":{"docs":{},"开":{"docs":{},"启":{"docs":{},"状":{"docs":{},"态":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}},"熔":{"docs":{},"断":{"docs":{},"器":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}},"可":{"docs":{},"以":{"docs":{},"发":{"docs":{},"布":{"docs":{},"其":{"docs":{},"指":{"docs":{},"标":{"docs":{},"（":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"）":{"docs":{},"，":{"docs":{},"以":{"docs":{},"供":{"docs":{},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{},"以":{"docs":{},"下":{"docs":{},"的":{"docs":{},"故":{"docs":{},"障":{"docs":{},"：":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}},"模":{"docs":{},"式":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}},"用":{"docs":{},"来":{"docs":{},"追":{"docs":{},"踪":{"docs":{},"故":{"docs":{},"障":{"docs":{},"次":{"docs":{},"数":{"docs":{},"，":{"docs":{},"当":{"docs":{},"失":{"docs":{},"败":{"docs":{},"次":{"docs":{},"数":{"docs":{},"达":{"docs":{},"到":{"docs":{},"阈":{"docs":{},"值":{"docs":{},"时":{"docs":{},"触":{"docs":{},"发":{"docs":{},"熔":{"docs":{},"断":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"可":{"docs":{},"选":{"docs":{},"择":{"docs":{},"性":{"docs":{},"提":{"docs":{},"供":{"docs":{},"失":{"docs":{},"败":{"docs":{},"回":{"docs":{},"调":{"docs":{},"。":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}},"新":{"docs":{},"状":{"docs":{},"态":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}},"要":{"docs":{},"旨":{"docs":{},"是":{"docs":{},"保":{"docs":{},"护":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"依":{"docs":{},"赖":{"docs":{},"中":{"docs":{},"增":{"docs":{},"加":{"docs":{},"以":{"docs":{},"下":{"docs":{},"代":{"docs":{},"码":{"docs":{},"片":{"docs":{},"段":{"docs":{},"：":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}},"状":{"docs":{},"态":{"docs":{},"中":{"docs":{},"都":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"失":{"docs":{},"败":{"docs":{},"回":{"docs":{},"调":{"docs":{},"（":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"）":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"设":{"docs":{},"置":{"docs":{"microservices/CircuitBreaker.html":{"ref":"microservices/CircuitBreaker.html","tf":0.0021008403361344537}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"含":{"docs":{},"有":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0018281535648994515}}}},"底":{"docs":{},"层":{"docs":{},"所":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}},"明":{"docs":{},"确":{"docs":{},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"对":{"docs":{},"于":{"docs":{},"重":{"docs":{},"载":{"docs":{},"极":{"docs":{},"为":{"docs":{},"重":{"docs":{},"要":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"冲":{"docs":{},"突":{"docs":{},"的":{"docs":{},"键":{"docs":{},"名":{"docs":{},"，":{"docs":{},"后":{"docs":{},"面":{"docs":{},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"值":{"docs":{},"将":{"docs":{},"替":{"docs":{},"换":{"docs":{},"掉":{"docs":{},"之":{"docs":{},"前":{"docs":{},"的":{"docs":{},"。":{"docs":{},"举":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"我":{"docs":{},"们":{"docs":{},"有":{"docs":{},"两":{"docs":{},"个":{"docs":{},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"额":{"docs":{},"外":{"docs":{},"可":{"docs":{},"以":{"docs":{},"配":{"docs":{},"置":{"docs":{},"的":{"docs":{},"有":{"docs":{},"：":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"的":{"docs":{},"配":{"docs":{},"置":{"docs":{},"仓":{"docs":{},"库":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}},"格":{"docs":{},"式":{"docs":{"microservices/Config.html":{"ref":"microservices/Config.html","tf":0.0009140767824497258}}}}}}}}},"先":{"docs":{},"于":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}},"均":{"docs":{},"有":{"docs":{},"异":{"docs":{},"步":{"docs":{},"调":{"docs":{},"用":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"其":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"为":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}}},"宋":{"docs":{},"子":{"docs":{},"豪":{"docs":{},"、":{"docs":{},"赵":{"docs":{},"亮":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}},"群":{"docs":{},"集":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"者":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"不":{"docs":{},"要":{"docs":{},"关":{"docs":{},"闭":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055}}}}}}}}}}}}}}},"软":{"docs":{},"件":{"docs":{},"通":{"docs":{},"常":{"docs":{},"通":{"docs":{},"过":{"docs":{},"创":{"docs":{},"建":{"docs":{},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{},"组":{"docs":{},"播":{"docs":{},"的":{"docs":{},"虚":{"docs":{},"拟":{"docs":{},"网":{"docs":{},"络":{"docs":{},"接":{"docs":{},"口":{"docs":{},"来":{"docs":{},"进":{"docs":{},"行":{"docs":{},"工":{"docs":{},"作":{"docs":{},"。":{"docs":{},"在":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"链":{"docs":{},"接":{"docs":{},"处":{"docs":{},"理":{"docs":{},"的":{"docs":{},"。":{"docs":{"clustering/Hazelcast.html":{"ref":"clustering/Hazelcast.html","tf":0.0019193857965451055},"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}},"才":{"docs":{},"能":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"挑":{"docs":{},"选":{"docs":{},"出":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}},"能":{"docs":{},"够":{"docs":{},"从":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076},"clustering/ApacheIgnite.html":{"ref":"clustering/ApacheIgnite.html","tf":0.003676470588235294},"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}},"在":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}},"自":{"docs":{},"动":{"docs":{},"检":{"docs":{},"测":{"docs":{},"使":{"docs":{},"用":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}}}}}}}}}},"适":{"docs":{},"配":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.004106776180698152}}}},"采":{"docs":{},"用":{"docs":{"clustering/Infinispan.html":{"ref":"clustering/Infinispan.html","tf":0.002053388090349076}},"字":{"docs":{},"典":{"docs":{},"树":{"docs":{},"来":{"docs":{},"存":{"docs":{},"储":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"便":{"docs":{},"可":{"docs":{},"以":{"docs":{},"以":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}}},"框":{"docs":{},"架":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"原":{"docs":{},"生":{"docs":{},"z":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"clustering/ApacheZookeeper.html":{"ref":"clustering/ApacheZookeeper.html","tf":0.0029154518950437317}}}}}}}}}}}}}}}},"举":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"假":{"docs":{},"如":{"docs":{},"我":{"docs":{},"们":{"docs":{},"要":{"docs":{},"去":{"docs":{},"执":{"docs":{},"行":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"此":{"docs":{},"操":{"docs":{},"作":{"docs":{},"接":{"docs":{},"受":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"参":{"docs":{},"数":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"参":{"docs":{},"数":{"docs":{},"：":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"产":{"docs":{},"生":{"docs":{},"的":{"docs":{},"服":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"和":{"docs":{},"处":{"docs":{},"理":{"docs":{},"器":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"是":{"docs":{},"在":{"docs":{},"类":{"docs":{},"名":{"docs":{},"的":{"docs":{},"后":{"docs":{},"面":{"docs":{},"加":{"docs":{},"相":{"docs":{},"关":{"docs":{},"的":{"docs":{},"字":{"docs":{},"段":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"一":{"docs":{},"个":{"docs":{},"服":{"docs":{},"务":{"docs":{},"接":{"docs":{},"口":{"docs":{},"名":{"docs":{},"为":{"docs":{"services/ServiceProxies.html":{"ref":"services/ServiceProxies.html","tf":0.001176470588235294}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"截":{"docs":{},"至":{"docs":{},"：":{"2":{"0":{"1":{"7":{"docs":{"PLAN.html":{"ref":"PLAN.html","tf":0.008064516129032258}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"length":15166},"corpusTokens":["!!!","!\");","!=","\"","\"\")","\"\"));","\"\";","\");","\"*\"","\"***\")","\"*****\"));","\"*****\"),","\"*.json\"))));","\",","\",offset=\"","\",partition=\"","\",value=\"","\"...\")","\"...\");","\"/\",","\"/a\"));","\"/api\"","\"/api\");","\"/api\",","\"/bar\",","\"/blah\");","\"/catalogue/products/:producttype/:productid/\");","\"/conf\"));","\"/dialog/oauth\")","\"/main.js\",","\"/o/oauth2/auth\");","\"/oauth/access_token\")","\"/oauth/access_token\");","\"/oauth/authorize\")","\"/oauth/authorize\");","\"/other","\"/path/to/my/conf\")","\"/protocol/openid","\"/realms/\"","\"/some","\"/some/path/\");","\"/the_uri\").toobservable().subscribe(","\"/the_uri\");","\"/uas/oauth2/accesstoken\");","\"/uas/oauth2/authorization\")","\"/users\",","\"0\",","\"0.0.0.0\",","\"1\");","\"10.0.0.1\");","\"10.0.0.1\",","\"10.0.0.2\",","\"100","\"1000\").putheader(\"cont","\"1000\");","\"1024\";","\"123244\");","\"127.0.0.1\")","\"127.0.0.1\");//","\"127.0.0.1\",","\"1937","\"2.5.13\",","\"230.0.0.1\",","\"2812b945\",","\"3(#0/!~\"));","\"32\",","\"4.4.1\",","\"8107\",","\"[\\\"foo\\\",\\\"bar\\\"]\";","\"a\"","\"a\",","\"a\"}","\"a2fpbhvhiglzihrozsajmsbizwfjacbpbib0agugd29ybgq=\";","\"action\":","\"address","\"address\",","\"address\":","\"alan","\"albums\"));","\"another_param2_value\");","\"app.js\"","\"application/json\").","\"application/json\").end(tojson(ar.result()));","\"application/json\").putheader(\"oth","\"application/json\").set(\"oth","\"application/json\");","\"authmechanism\"","\"authsource\"","\"bar\"","\"bar\").put(\"num\",","\"bar\");","\"bar\",","\"bar.txt\");","\"bar.txt\",","\"blah\",","\"body\":","\"castuuid\":","\"charset\"","\"classes:lib/myjar.jar\"","\"classpath:test","\"clement\").put(\"password\",","\"client_id\")","\"client_id\",","\"client_secret\")","\"client_secret\");","\"close\")","\"cluster1\",","\"cluster2\",","\"cn=,ou=,o=,l=,st=,c=\"","\"collection\":","\"collection_name\")","\"color\"","\"com.hazelcast:hazelcast:enter_your_version_here\"","\"com.mycompany.cleverdb.mainverticle\"","\"com.mycompany.cleverdb.mainverticle\",","\"com.mycompany.somepkg.someclass\",","\"config\"","\"config\")","\"configmap","\"connecttimeoutms\"","\"cooper\"),","\"cooper\");","\"creat","\"current","\"dale\")","\"dale\");","\"databas","\"database\"","\"db","\"dir/*.properties\")","\"dir/*json\"))","\"document\":","\"earliest\");","\"en\":","\"epoll\",","\"es\":","\"examples.mydata\"","\"examples.myservice\",","\"f\",","\"false\"));","\"false\");","\"find\")","\"flooble\");","\"fname","\"foo","\"foo\"));","\"foo\");","\"foo\",","\"foo\":","\"fr\":","\"gssapi\",","\"gssapiservicename\"","\"header","\"heartbeat.socket\"","\"heartbeatfrequencyms\"","\"hello","\"hello\");","\"hello\";","\"host\"","\"hosts\"","\"http://localhost:3000/callback\");","\"http://localhost:8080\");","\"http://localhost:8080/callback\")","\"http://localhost:8080/callback\"),","\"http://localhost:8888/foo/development\"));","\"http://the","\"https://accounts.google.com\")","\"https://api.oauth.com\");","\"https://api.twitter.com\")","\"https://github.com/cescoffier/vertx","\"https://github.com/login\")","\"https://graph.facebook.com/oauth/access_token\");","\"https://myserver.com/callback\");","\"https://myserver.com:8447/callback\");","\"https://www.facebook.com\")","\"https://www.googleapis.com/oauth2/v3/token\")","\"https://www.linkedin.com\")","\"https://www.your","\"in","\"included\":","\"index.html\";","\"io.example.main\"//指定main函数所在的类","\"io.example.mainverticle\"//新增main","\"io.vertx\");//","\"io.vertx.core.launcher\",//改为launch","\"io.vertx.kafka.client.serialization.bufferdeserializer\");","\"io.vertx.kafka.client.serialization.bufferserializer\");","\"io.vertx.kafka.client.serialization.jsonarraydeserializer\");","\"io.vertx.kafka.client.serialization.jsonarrayserializer\");","\"io.vertx.kafka.client.serialization.jsonobjectdeserializer\");","\"io.vertx.kafka.client.serialization.jsonobjectserializer\");","\"io.vertx:vertx","\"isolationgroup\":","\"j.","\"jceks\")","\"jdbc:hsqldb:mem:test?shutdown=true\")","\"john\",","\"keepalive\"","\"keystore.jceks\")","\"linux","\"local\")","\"localhost\")","\"localhost\"),","\"localhost\").put(\"port\",","\"localhost\");","\"localhost\",","\"localhost:2181\")","\"localhost:9092\");","\"main","\"main\":","\"maintenancefrequencyms\"","\"maintenanceinitialdelayms\"","\"manager\",","\"maven:com.mycompany:clev","\"maxidletimems\"","\"maxlifetimems\"","\"maxpoolsize\"","\"member\",","\"message\",","\"message_\"","\"mi","\"minheartbeatfrequencyms\"","\"minpoolsize\"","\"multipart/form","\"my_group\");","\"myapi/orders\")","\"myapp3.sessionmap\");","\"myapp3.sessionmap\",","\"myclusteredapp3.sessionmap\");","\"mycollection\")","\"mycollection\",","\"mydatasource\");","\"mygroup\"","\"myhost.com\");","\"myhost.com\",","\"mymysqldb.mycompany\");","\"mypassword\"","\"mypassword\");","\"mypoolname\");","\"mypostgresqldb.mycompany\");","\"myserver.mycompany.com\",","\"myservicename\",","\"mysqlpool1\");","\"name\"","\"name\")","\"name\",","\"name\":","\"not","\"notifications\")","\"num_widgets\":","\"ok\"","\"on","\"options\":","\"org.apache.kafka.common.serialization.stringdeserializer\");","\"org.apache.kafka.common.serialization.stringserializer\");","\"org.hsqldb.jdbcdriver\")","\"org.slf4j.impl.staticloggerbinder\".","\"org.somelibrary.*\"));","\"other","\"param","\"param1_value\");","\"param3_value\");","\"param_value\")","\"passw0rd\",","\"password\"","\"password\");","\"password\":","\"path","\"paulo\"),","\"paulo\").put(\"somekey\",","\"ping\",","\"port\"","\"postgresqlpool1\");","\"properties\"))","\"pt\":","\"querytimeout\"","\"receivebuffersize\"","\"records\")","\"red\"","\"red\",","\"red\"的记录","\"replicaset\"","\"sausages\");","\"save\"","\"save\");","\"secret\"));","\"secret\".equals(ctx.request().getparam(\"password\")))","\"select","\"send\"|\"publish\"|\"receive\"|\"register\"|\"unregister\",","\"sendbuffersize\"","\"serverselectiontimeoutms\"","\"sockettimeoutms\"","\"some","\"some.db\"","\"somemessage\",","\"somevalue\"));","\"stephen","\"super_secret\".equals(password))","\"sync\"","\"target/classes/readme2.txt\",","\"text/html\").end(\"helloprotect","\"text/html\").putheader(\"oth","\"text/html\");","\"text/plain\")","\"text/plain\").end(body);","\"text/plain\").write(\"som","\"text/plain\").write(body).end();","\"text/plain\");","\"the","\"tim\"","\"tim\")","\"tim\"));","\"tim\"),","\"tim\").put(\"directory\",","\"tim\").put(\"password\",","\"tim\",","\"title\",","\"type\":","\"updat","\"username\"","\"username\")","\"utf","\"val\").put(\"header2\",","\"val2\");","\"value\"));","\"value\",","\"waitqueuemultiple\"","\"waitqueuetimeoutms\"","\"wibble\");","\"with","\"woobble\").puttrailer(\"x","\"woobble\").set(\"x","\"worker\":","\"xxxxxxxxxxxxxxxxxxxxxxxx\";","\"yay!","\"your_client_id\")","\"your_client_secret\")","\"{","\"{\\\"foo\\\":\\\"bar\\\"}\";","#","$(oc","$cwd/.vertx","$vertx_hom","$vertx_home/lib","${main.class}","${main.verticle}","${project.build.directory}/${project.artifactid}","${project.version}","${version}","${version}.jar","${vertx.version}","${vertx_home}/lib","&","&&","'","'1.0","'4.12'","'abc'","'bar'","'com.hazelcast',","'foo'","'hazelcast'","'io.example'","'io.example'//对应刚刚向导中输入的","'io.vertx:vertx","'java'","'john',","'junit',","'message');","'smith',","'tim',","'varchar']","'xyz'","(!","(!line.isvalid()","(!request.path().contains(\"..\"))","(!shoesize.equals(\"9\"))","(!sock.writequeuefull())","(\"io.vertx:vertx","(\"paulo\".equal(username)","(\"paulo\".equals(ctx.request().getparam(\"username\"))","('jane')\");","('joe')\");","((record.partition()","()","(1)","(2)","(2.6.0)","(2.6.2)","(3)","(3.1.0)","(3.4.0+)","(4)","(4.0.31.final)","(5)","(6)","(=","(?)\",","(a,","(ar.failed())","(ar.result()","(ar.succeeded()","(ar.succeeded())","(assign","(asyncresult.succeeded())","(asyncresult2.succeeded())","(b,","(be.getrawmessage().getstring(\"body\").equals(\"armadillos\"))","(be.type()","(build.gradl","(byte","(caus","(context.iseventloopcontext())","(context.ismultithreadedworkercontext())","(context.isworkercontext())","(continue)","(ctx.statuscode()","(destin","(dnsexception)","(done.succeeded())","(done1.succeeded())","(err","(everi","(exc.failurecode()","(except","(execute.succeeded())","(fileres.succeeded())","(hasauthority)","(id","(int","(jsonarray","(jsonobject","(l)","(language.tag())","(languagehead","(mxrecord","(name)","(nop)","(not","(null,","(numberformatexcept","(partitioninfo","(password","(pom.xml文件中)：","(pushedrequest.path().equals(\"/main.js\"))","(r","(rc.getacceptablecontenttype().equals(\"text/xml\"))","(record.offset()","(rejectandclose)","(request.getheader(\"expect\").equalsignorecase(\"100","(request.method()","(request.path().equals(\"/\"))","(request.path().equals(\"/myapi\"))","(res.failed())","(res.result()","(res.succeeded())","(res2.succeeded())","(resget.succeeded())","(response.statuscode()","(resput.succeeded())","(result.cause()","(result.succeeded()","(result.succeeded())","(serviceexception)","(shoesizeexception)","(short)","(sock.writequeuefull())","(srvrecord","(start","(stream.succeeded())","(streamresetexception)","(string","(system.currenttimemillis()","(the","(time,","(token.expired())","(topicpartit","(websocket.path().equals(\"/myapi\"))","(代表一直保留)","(在","(此客户端)",")","));",").compose((msg)",").fallback(v",").listen(observable.tohandler());",").openhandler(v",").sethandler((res)",").subscribe(v",");",")应该在",")，并且在回调中，执行","*","**，*","*.vertx.io","*/","*observ","+",",",",是vert.x",",来指定集群管理器。",".","...","...\"","....","./","./vertx",".000。",".add(new",".addargument(new",".addchoice(\"blue\").addchoice(\"red\").addchoice(\"green\")",".addoption(",".addoption(new",".addqueryparam(\"param\",",".addqueryparam(\"som",".addstore(httpstore).addstore(filestore).addstore(syspropsstore);",".addstore(store1)",".addstore(store2);",".as(bodycodec.json(user.class))",".as(bodycodec.jsonobject())",".as(bodycodec.none())",".as(bodycodec.pipe(writestream))",".bodyhandler(buff",".buffer(256)",".connecthandler(socket",".consumes(\"application/json\")",".createhttpserver()",".end(\"hello",".end(\"not",".end();",".endhandler(v",".exceptionhandler(future::fail)",".exceptionhandler(t",".flatmap(u",".ftl",".get(443,",".get(8080,",".getabs(\"https://myserver.mycompany.com:4043/som",".handler(conf",".handler(row",".hb",".head(8080,",".html",".html、.css、.j",".jade",".launcher",".listen(1234,",".listen(8080);",".map(",".map(httpresponse::bodyasstring);",".map(record",".peb",".pem",".post(8080,",".produces(\"application/json\");",".put(\"address\",",".put(\"aggregate\",",".put(\"authorizationpath\",",".put(\"binarystuff\",",".put(\"clientid\",",".put(\"clientsecret\",",".put(\"code\",",".put(\"collection\",",".put(\"connection\",",".put(\"defaulthost\",",".put(\"defaultport\",",".put(\"document\",",".put(\"driver_class\",",".put(\"filesets\",",".put(\"firstname\",",".put(\"format\",",".put(\"host\",",".put(\"individualid\",",".put(\"initialsleeptime\",",".put(\"jdbcurl\",",".put(\"key\",",".put(\"lastname\",",".put(\"max_pool_size\",",".put(\"maximumpoolsize\",",".put(\"maxtimes\",",".put(\"name\",",".put(\"namespace\",",".put(\"password\",",".put(\"path\",",".put(\"pipeline\",",".put(\"port\",",".put(\"provider_class\",",".put(\"publicationdate\",",".put(\"redirect_uri\",",".put(\"scan",".put(\"scope\",",".put(\"secret\",",".put(\"site\",",".put(\"som",".put(\"ssl\",",".put(\"state\",",".put(\"tokenpath\",",".put(\"type\",",".put(\"url\",",".put(\"username\",",".putheader(\"an",".putheader(\"connection\",",".putheader(\"cont",".putheader(\"som",".registerserviceimporter(new",".requesthandler(req",".requesthandler(router::accept)",".resultsetclosedhandler(v",".rxlisten(1234,",".rxsend()",".rxsend();",".rxsendstream(body);",".send(ar",".send(respons",".sendbuffer(buffer,",".sendform(form,",".sendjson(new",".sendjsonobject(new",".sendstream(filestream,",".sendstream(stream,",".setannounceaddress(\"servic",".setargname(\"arg1\"))",".setargname(\"arg2\"));",".setargname(\"source\"))",".setargname(\"target\"));",".setauthorizationpath(\"/o/oauth2/auth\"));",".setbackendconfiguration(",".setclientauth(clientauth.required)",".setclientid(\"client_id\")",".setclientsecret(\"client_secret\")",".setclusterpublichost(\"whatever\")",".setclusterpublicport(1234)",".setconfig(new",".setconverter(new",".setdefaultvalue(\"green\")",".setdefaultvalue(\"hello\")",".setdescription(\"a",".setdescription(\"an",".setdescription(\"en",".setdescription(\"th",".seteventbusoptions(new",".setfallbackonfailure(true)",".setflag(true))",".setformat(\"hocon\")",".setformat(\"properties\")",".setformat(\"yaml\")",".setgroupconfig(new",".sethandler(ar",".sethost(\"127.0.0.1\");",".sethost(\"localhost\")",".sethost(\"localhost\").setport(1080)",".sethost(\"localhost\").setport(3128)",".setindex(0)",".setindex(1)",".setkeycertoptions(certificate.keycertoptions())",".setkeystoreoptions(new",".setlocation(new",".setlongname(\"color\")",".setlongname(\"directory\")",".setlongname(\"flag\").setshortname(\"f\").setflag(true).setdescription(\"a",".setlongname(\"mandatory\")",".setlongname(\"multiple\").setshortname(\"m\").setmultivalued(true)",".setlongname(\"optional\")",".setlongname(\"person\"));",".setlongname(\"single\").setshortname(\"s\").setdescription(\"a",".setmatch(new",".setmaxfailures(5)",".setmaxredirects(32));",".setmetadata(new",".setname(\"mi",".setnetworkconfig(new",".setpartition(0));",".setpartition(0);",".setport(8080)",".setproxyoptions(new",".setrequired(true)",".setresettimeout(10000)",".setscanperiod(2000)",".setshortname(\"r\")",".setsite(\"https://accounts.google.com\")",".setssl(true)",".setssl(true),",".setstatuscode(302)",".setstatuscode(404)",".setstatuscode(405)",".setsummary(\"a",".settimeout(2000)",".settokenpath(\"https://www.googleapis.com/oauth2/v3/token\")",".settopic(\"test\")",".settrustall(true);",".settrustoptions(certificate.trustoptions()))",".settrustoptions(certificate.trustoptions());",".settruststoreoptions(new",".settype(\"configmap\")",".settype(\"directory\")",".settype(\"env\");",".settype(\"ev",".settype(\"eventbu",".settype(\"file\")",".settype(\"git\")",".settype(\"http\")",".settype(\"json\")",".settype(\"redis\")",".settype(\"spr",".settype(\"sys\")",".settype(\"zookeeper\")",".settype(boolean.class)",".settype(file.class)",".settype(person.class)",".seturi(\"/\")",".setusealpn(true)",".setuseragent(\"mi",".setusername(\"username\").setpassword(\"secret\"));",".ssl(true)",".subscribe(respons",".templ",".timeout(5000)",".vertx","/","/**","//","//...","//blablabla","//deal","//iso","//thi","//use","//仅回传数据","//以上和以下两种写法是等效的","//以下程序先向address1发送一个message，然后等address1回复之后，将address1的回复消息发送给address2，最后将address2的回复打印到控制台上","//以下部分新增","//使用future之后，用completer方法填充参数","//创建hazelcastcli","//创建hazelcast配置","//创建客户端","//发送head请求","//将回调函数存入future中，从而实现代码的扁平化","//将客户端对象与verticle对象绑定，这里选取了三种不同的客户端作为示范","//异常处理","//或","//未使用future时，回调函数嵌在send方法内部，以匿名函数的形式作为send的参数","//注册一个handler处理进来的消息","//获取到一个平均值","//虽然通过一个","//译者注：mongodb","//这里lambda表达式用于接收消息处理结果","/a/b/c/page.html","/bar/foo","/bar/wibbl","/catalogue/products/tools/drill123/，那么会匹配这个","/dynamic/graph.hb","/foo","/foo/bar/wibble/foo","/io.vertx/asyncmap/$name/","/io.vertx/asyncmultimap/$name/","/io.vertx/cluster/nodes/","/io.vertx/counters/","/io.vertx/locks/","/loginpage。","/page.html?param1=abc¶m2=xyz","/preoductapi：","/privat","/products/product1234","/some/path","/some/path/","/some/path//","/some/path/b，该处理器最后结束了响应。","/some/path/foo","/some/path/foo.html","/some/path/oth","/some/path/otherdir/blah.css","/some/path，首先第一个处理器向上下文添加了值，然后路由到了下一个处理器。第二个处理器转发到了路径","/somepath/","/static","/static/css/mystyles.css","/templates/graph.hb","/tools/drill123/，那么会匹配这个","/，则意味着是一个子类型（sub","/，所以路径","0","0)","0);","0.0.0.0，它表示：监听所有可用地址。默认端口号是","0.10.1.1","0.9.0","03","05","06","07","09","0;","0;//属性变量","0;i","0。","0，第二个是","0，表示一直存在","0，表示永远存活。","0，这也是一个特殊值，它告诉服务器随机选择并监听一个本地没有被占用的端口。","0，这将使用操作系统默认大小。","0：","1","1\"));","1)","1);","1.0","1.0。","1.0。缺省值为","1.0）。","1.8","1.8.0u74","1.8//新增","1.8版本的基础知识，因为vert.x","10","10,","10.0.0.1的反向查找类似的事：","10.0.0.2","100","100,","1000","10000","10000);","10000,","100000,","10;","10。","10秒)。","10秒后注销","120000;","120000（2分钟）","123).put(\"mybool\",","123);","1234,","127.0.0.1","127.0.0.1。","128","128k。","128。","1456m","14|activ","15","15:54:14","15;","15|activ","16","16\");","16|activ","16进制的字符串中导出创建时间。若您选择其他类型作为","16进制的字符串作为","16，您可使用","18|activ","192.168.1.20","192.168.1.3","19|activ","1st","1|jackson","1|netty/buff","1|netty/codec","1|netty/codec/http","1|netty/codec/sock","1|netty/common","1|netty/handl","1|netty/transport","1|netty/transport/sctp","1|vert.x","1。","1代理不支持参数化消息。log4j","1，以此类推。","1，意味着返回所有数据。","2","2.1.1","2.11","2.11.4","2.11，来自","2.4.2","2.6.32.16","2.x","20","200","200)","200);","2000","2000));","2000,","200。","200，表示","2017","20458","2048","20|activ","21/04/2017.","21t00:00:00+00:00\"));","21|activ","224.0.0.0/5","224.0.0.1","22|activ","230.0.0.1","231.255.255.254","232.0.0.0/5","232.0.0.1","239.255.255.254","23|activ","24","24|activ","25","25,","256","25|activ","26/04/2017.","26|activ","27000","27017,","27017。如果设置了","28","28000","2nd","2xx","2分钟","2和slf4j提供了预设的实现，类名为：io.vertx.core.logging.log4jlogdelegatefactory，io.vertx.core.logging.log4j2logdelegatefactory和io.vertx.core.logging.slf4jlogdelegatefactory。如您要使用这些实现，还应确保相关的log4j或slf4j的jar在您的类路径上。","2的代理使用了像slf4j代理这样的{}语法，jul代理使用如{x}语法。","2）个","2，其中n是组中节点数。若集群中的q节点少于ha节点，ha部署将被撤销。如果/当","2：http://vertx.io/docs/vertx","3","3));","3);","3,","3.0.0","3.1.0","3.2.1","3.3","3.4.0","3.4.0开始，vert.x提供了另一种更高层次封装、更方便使用的http客户端","3.4.1","3.4.1.jar","3.4.1.jar，应该在vert.x中安装包中。同时也要将jgroup","3.4.1。","3.4.2","3.4.8","3.5.x","3.6.3","30","30)","30);","3000","3000)","30000,","300000,","300000});","301","301、302","301、302、303","303","304","307","30x","3306","360","3600000,","384","3以上版本要求java","3以上版本需要java","3，需要在配置以及依赖上做一些改动。","4.0.0","4.1","4.12","4.3","4.4","401","403","404","404)","40;","413","42;","43;","46","5","5))","5.1.2","5.2.0上的工作部署：","50,","500","500)","500,","5000","500，否则是","503","512","512算法加密后进行存储，之后会连接对应的salt值，这个salt值和密码存储在同一个表里。","512算法加密后进行存储，之后会连接对应的salt值，这个salt值和密码存储在同一个表里。你可以调用setsaltfield方法来改变存储salt值的字段名称，它的默认值是\"salt\"，你同样可以使用setsaltstyle来改变一些行为。通过调用gethashstrategy方法还可以读取hash策略设置。","521","5432，mysql","587});","5};","5秒后再恢复,继续读取","5秒后我们释放该锁其他人可以得到它","6","60000);","6379","6379)","64","8","8\")));","8\"));","8.1.7.v20160121。这个完整列表可以在","8.8.4.4。","8.8.8.8","8080","8080)","8080).put(\"path\",","8080,","8192,","8433,","8500","8500)","8601","8601（yyyi","8859","8888","8。","8不支持alpn，所以alpn应该通过其他方式启用：","8以上版本方可运行，且大量应用了1.8加入的新语法糖，比如匿名函数lambda。","8以上版本方能运行；","8发行版用以支持alpn。","8的jdk。","8的jdk环境。","8的编码方式写入一个字符串","8编码方式编码字符串和以指定方式编码编码字符串、或写buffer的方法：","8编码的字符串","8）。","9","9!\",","9)\",","9杀死进程来测试），运行mi",":","=","==","=>",">",">=3.0.0",">build",">ctx.reroute(\"/static/index.html\"));",">gradle项目",">jar，双击执行，便可在build/libs文件夹下生成可执行的jar文件，我生成的是vertxexampl",">next",">task",">{",">{//blablabla}就是一个处理器（handler），在随后的例子中，我们用1sthandler以及2ndhandler来指代具体的匿名函数，让代码更加清晰明了，放在verticle中类似：",">勾选use",">填入groupid（也就是你所在组织的名字，例如io.example）和artifactid（也就是项目的名字，例如vertxexample）","?","?\";","?)","?），您也可以使用逗号（,）分隔它们来指定多个集合。模式相当于当前工作目录。","@after","@argument(index","@befor","@dataobject","@description(\"som","@fluent","@name(\"mi","@name(\"som","@option(longnam","@option(shortnam","@overrid","@proxyclos","@proxygen","@runwith(vertxunitrunner.class)","@summary(\"a","@summary(\"som","@suspend","@test","@vertxgen","@{context.get('bar')}","@{context.request().path()}","@{context.session().get('foo')}","[","[2.6.0,3)","[2.6.2,3)","[4.0.31,5)","[arg_name,","[hazlcast]|(/clustering/hazelcast.md)，也可以通过编程的方式来实现：","[infinispan]|(/clustering/infinispan.md)","[key,","[snip]","[x]","]","],","_id","`*.vertx.io`","`.hbs`","`/dynamic`","`/foo/bar`","`/myapi/orders`","`/private/settings`","`/private`","`/protected`","`/some/bath`","`/some/path//`","`/some/path/`","`/some/path/subdir/blah.html`","`/some/path/subdir`","`/some/path`","`/somepath/`","`accept`","`action`","`admin`","`albums`","`application/json`","`content","`demo.ordermgr`","`demo.orderservice`","`es256`::","`es384`::","`es512`::","`find`、`collecton`","`foo`","`hs256`::","`hs384`::","`hs512`::","`http://localhost:8080`","`json`","`list_products`","`news.`","`place_orders`","`rs256`::","`rs384`::","`rs512`::","`text/html`","`text/json`","`text/plain`","`text`","`ticker.mystock`","`wibble`","a)，我们最终得到的结果是：{a:value,","a/aaaa","a/b/c/page.html?param1=abc¶m2=xyz","a_n_other_verticle.rb","aaaa记录，您需要像下面那样做：","aaaa（ipv6）记录。第一个返回的（记录）将会被使用，因此它的操作方式与在操作系统上使用","aaaa（ipv6）记录时，第一条被返回的（记录）将会被使用。它的操作方式和操作系统上使用","abov","absoluteuri","abstractservicereference#close()方法。","abstractverticl","abstractverticle{","accept","accept(3)处理。","accept:","acceptablecontenttyp","acceptablecontenttype);","acceptablelocal","acceptable）的路由","access","accesstoken","access等）中找到这些功能。","access：","access：已翻译校对完成","acknowledg","action","action0","action1","actions），我们可以通过","activ","actor","actor。","actual","actualport","ad","adaptor","adaptor.receive();","add","addcertpath(\"/path/to/your/ca","addcertpath(\"/path/to/your/serv","addcertvalue(mycaasabuffer)","addcertvalue(mytruststoreasabuffer)","addcooki","addcrlpath(\"/path/to/your/crl.pem\");","addcrlvalue(mycrlasabuffer);","addenabledciphersuite(\"cdh","addenabledciphersuite(\"ecdh","addenabledsecuretransportprotocol(\"tlsv1.1\").","addenabledsecuretransportprotocol(\"tlsv1.2\");","addinboundpermitted(inboundpermitted));","addinboundpermitted(inboundpermitted1).","addinboundpermitted(inboundpermitted3).","addit","addoutboundpermitted(outboundpermitted1).","addoutboundpermitted(outboundpermitted2);","addr.arpa\",","addr.arpa的ptr概念。","address","address\"","address\"))","address\").handler(adaptor);","address\");","address\",","address',","address)","address);","address,","address1","address2","address3","address:挑选任务符合ip地址规则的地址，例如：192.168.*","addressregex","addressresolveroptions().","addressresolveroptions().addsearchdomain(\"foo.com\").addsearchdomain(\"bar.com\"))","address，这个选项会被忽略。","addserver(\"192.168.0.1\").","addserver(\"192.168.0.2:40000\"))","aes128","aes256","afterstartingvertx","ag","age:","age=86400，也就是一天。可以通过","agent","agent\"));","agent:","agent。agent是一个jvm代理，它会为运行它的jvm选择正确的alpn版本：","agent（服务器），并且会进行周期性的扫描，来更新服务情况：","aggregate（译者注：聚合）命令。请注意，命令的名称要做为","akka","akka）获得一个发布者，并将其数据泵入到服务端的","algorithm","alia","aliv","alive的连接将不会被客户端自动关闭，要关闭它们您可以关闭客户端实例。","along)","alpn","alpn(appl","alpn支持","alpn是一个tls的扩展，它在客户端和服务器开始交换数据之前协商协议。","alpn是一个小型的jar，它覆盖了几种java","alreadi","am\"));","amazon","annot","annotatedcli","annotatedcli();","announce\")","anoth","anotherpassword,manag","ant","apach","api","api\",","api=tru","api。","api。当在程序启动时，设置选项","api。我们会将它挂载到另一个","api。通过这些","api不会阻塞线程，所以通过vert.x您可以只使用少量的线程来处理大量的并发。","api中的一些对象提供了简单的流程控制（回压）功能。","api使用","api却没绑定。slf4j记录的消息将会丢失。您应该将绑定加入您的类路径。参考","api在verticle内部可用。","api或可以通过http请求访问的服务。http","api接口。它不能将服务导出到consul，并且也不支持服务的修改。","api服务提供的类型，服务对象的类型是一个配置好了host和port的httpclient（其location表现为一个url）","api来处理事件。例如每隔一秒发送一个事件的计时器：","api的jar，并在缺省情况下使用它。","api的三个步骤如下：","api的拷贝示例：","api等等。vert.x","api自然组合成链式处理","api通过这些接口将这些方法展现给用户，其他语言版本也应该类似。","api，它本质上是同步的，无论多么努力地去尝试，vert.x都不能像魔法小精灵撒尘变法一样将它转换成异步api。","api，总结如下：","api，所以熟悉基于","api，有两种方式：","api，此时您应当使用","api，毕竟不同的语言有不同的代码风格，若强行让","api，省去了手写命令的麻烦。例如，如果想通过","api，非常适用于简单的页面应用","app","app/1.2.3\");","appendxxx","appli","applic","application/*","application/json","application/json,","application/json;","application/json;q=0.7,","application/x","application:","application：应用","appropri","ar","ar.cause());","ar.cause().getmessage());","ar.cause();","ar.result()","ar.result())","ar.result(),","ar.result().body());","ar.result().handler(buff","ar.result();","arch_bits:","arg)","arg0","arg;","arg_value]相对应（译者注：key对应参数名，value对应参数值）。","argnam","args){","argument","argument\")","argument()","array","array.add(\"foo\").add(123).add(false);","array.getboolean(2);","array.getinteger(1);","array.getstring(0);","arraylist<>();","as:","assign","assigned\");","async","async.complete();","asyncfil","asyncfile,","asyncfile、netsocket、websocket","asyncfile。","asyncfile。关闭是异步的，如果希望在关闭过后收到通知，您可指定一个处理器作为函数（close）参数传入。","asyncfile实现了","asynchron","asyncmap","asyncmultimap","asyncresult","asyncresult.cause());","asyncresult.result().body(),","asyncresult.succeeded());","asyncresult2","asyncresult2.cause());","asyncresult2.succeeded());","asyncresult3","asyncresult3.succeeded());","asyncresult，而是具体的返回内容），需要返回一个新的需要链接的","asyncsqlcli","async。此组件让","attach","attribut","auth","auth.properties\");","authcod","authconfig","authconfig);","authent","authenticated\");","authentication：认证","authentication：验证","authenticity：真实性","authhandl","authinfo","authmechan","author","authoris","authorisation：授权","authority\");","authority：权限","authorization_uri","authorization_uri)","authorizt","authproperti","authproperties);","authprovid","authprovider.authenticate(authinfo,","authprovider.generatetoken(new","authsourc","authz","auth尽可能的尝试轻便。然而，可以通过使用前缀role:或者通过setroleprefix指定你想要的前缀在一个角色上执行断言。","auth提供者实现","auth提供者的示例代码：","auth提供者的示例：","auth提供者的类型，并且也可以指定一个json对象的配置。","auth提供者需要在类路径或文件系统上加载一个keystore文件，keystore文件要么有一个mac要么有一个signature用于签名和验证生成的令牌，。","auth本身并没有授权任何特定的许可（它们仅是不透明的字符串）模型，这个的实现和","auth自身并不要求使用特定的许可模型（它本身只是使用了不透明的字符串），但默认的实现使用了比较熟悉的：用户/角色/许可模型，这样在应用里你可以使用一个或者多个角色，而一个角色也可以拥有一个或者多个许可。","auth项目提供了处理认证和授权的功能，它可以被vertx","auth：http://vertx.io/docs/vertx","auto","automatically（为空内容建立文件夹结构）","availability）的verticle。这种情况下，当运行verticle的vert.x实例突然挂掉时，该veritlce将迁移到另一个vert.x","availability：高可用性","awaitevent(h","awaitresult(h","awar","away","azelcast.logging.typ","azur","azureadauth","b","b)，那我们的配置结果将是：{a:value2,","b:1,","b:1}","back","backend","backend组件是基于redis的后端存储实现。","backoff","bad","bad_shoe_s","bad_shoe_size_error","badkey","badsig","badtim","badver","balanc","balancer：负载均衡器","ball","ball\");","ball\",","bar","bar.txt","bare","base","base64","base64_access_token","base64encodedstr","base64encodedstring));","basesleeptimebetweenretries：","basicauthhandl","basicauthhandler.create(authprovider);","batch","batch,","batch.add(\"insert","batch.add(new","batchcallablewithparam","batchwithparam","be","be.complete(false);","be.complete(true);","be.getrawmessage();","be.setrawmessage(rawmessage);","be.type()","bean","bean(singleton)","bearer","befor","beforestartingvertx","beginningoffset","beginningoffset)","beginningoffset=\"+beginningoffset));","beginningoffset=\"+beginningoffset);","behavior","best","between","bin","binari","binaryobject","binaryobject));","binary），后边跟着零个或多个","bind","bind!\");","bind_addr","block","blockinghandl","blockingobservable.observeon(scheduler);","blocking：阻塞式","blockmulticastgroup(...)，如下所示：","block：阻塞","bodi","body);","body:","bodyasxxx()","bodycodec","bodycodec.jsonobject","bodycodec.non","bodycodec.pip","bodyhandl","bodystream().","body）应该是一个","body：消息体","body：请求/响应体（有些地方翻译成请求/响应正文）","boliza负责翻译，wuziqiang负责校对","bonecp","bonecp，并在命令行上加上","book","boolean","boolean）。","boolval","boot","boot${version}.jar","bower","box.com","boxauth","box）中包含了\"user\"集合（collection），用户名字段使用\"username\"进行存储和读取。","box）中包含了某些针对认证和授权的信息查询，如果你想要使用不同的数据库模式（schema），这些查询内容可以通过下边几个方法进行更改：","box：标准环境（开箱即用）","brain）。","branch(分支，默认为","breaker","breaker\",","breaker.execute(","breaker.execute(futur","breaker.executewithfallback(","breaker2","breaker:3.4.1'","breaker。","breaker是","breaker：已翻译校对完成","breaker：熔断器","bridg","bridgeev","bridgeeventtype.publish","bridgeeventtype.receive)","bridgeeventtype.send)","bridgeeventtype.socket_idle)","bridgeopt","bridgeoptions().","bridgeoptions().addinboundpermitted(inboundpermitted).setpingtimeout(5000);","bridgeoptions().addinboundpermitted(inboundpermitted);","bridgeoptions();","bridge：桥接","bson","bu","buff","buff.appendint(123).appendstring(\"hello\\n\");","buff.setint(1000,","buff.setstring(0,","buff.setunsignedbyte(pos,","buff.tojsonobject();","buffer","buffer(1,","buffer);","buffer.appendint(123).appendlong(245l);","buffer.buff","buffer.buffer(\"content\");","buffer.buffer(\"foo\");","buffer.buffer(\"hello\"),","buffer.buffer(\"som","buffer.buffer(),","buffer.buffer().appenddouble(12.34d).appendlong(432l);","buffer.buffer().appendfloat(12.34f).appendint(123);","buffer.buffer().appendfloat(12.3f).appendint(321);","buffer.buffer().appendint(12).appendstring(\"foo\");","buffer.buffer().appendint(123));","buffer.buffer().appendint(123).appendfloat(1.23f);","buffer.buffer();","buffer.buffer(1000);","buffer.buffer(10000);","buffer.buffer(128);","buffer.buffer(bytes);","buffer.class);","buffer.class,","buffer.length());","buffer.tostring(\"utf","buffer1:hello","buffer1:hello\\nhow","buffer2:how","buffer2:ou?\\ni","buffer3:","buffer3:i","buffer4:\\n","bufferconsum","bufferproduc","buffer、jsonobject","buffer、jsonobject、jsonarray","buffer。","buffer。buff","buffer。您也可以将","buffer。若您知道您的","buffer将会在添加到map之前拷贝","buffer长度","buffer，在写入请求体之前，vert.x","buffer，它也存在各种不同数据类型的方法。所有的","buffer，当数据从网络到达时，处理器可以多次被调用，这取决于请求体的大小。","buffer，这个","buffer，这个和先调用带","buffer，这个字符串可以用指定的编码方式编码，例如：","buffer：","buffer：缓冲区（一些地方使用的","buffer：要写入的缓冲","buffer：读取数据的","buil","build.gradl","build/libs/mi","builder","bundl","bundle则需要：","bundle，因此可以在任何osgi","bus\")","bus:","bus。","bus。只要服务器之间的链接存在，浏览器不需要每一次都与同一个服务器建立链接。","bus。而有了vert.x","bus。这个","bus。默认为false（非集群模式）。","bus上发布事件。事件发送的地址可以使用","bus上暴露（expose）一个服务，所以，只要它们在服务发布时清楚服务的地址（address），其他任意的vert.x组件都可以去调用它。","bus上注册处理器时，注册信息会花费一些时间才能传播到集群中的所有节点。","bus上的","bus上相互通信。","bus上访问你的服务的模板代码，同时也会生成对应的","bus上（可能是在不同的机器上），调用端代理类都能正常工作。","bus上）区分开，以便确定到底发生了哪一种业务逻辑错误。下面是一个例子：","bus上，你需要做以下的事情来调用服务：","bus上：","bus下","bus中使用ssl连接替换传统的tcp连接。","bus中注册一个处理器，当这个处理器中收到任意","bus中的地址是","bus中的消息、将其分派到合适的方法并将结果返回到ev","bus中的消息遵循一定的格式，因此能被用于服务的调用。","bus中都会触发一个事件，这个事件包含着被修改的服务记录。","bus也支持","bus会尝试将消息传递到注册在ev","bus发送消息。","bus发送消息。不管你的服务实际在哪个ev","bus发送消息到某个地址的组件。消息源服务的client是","bus发送消息，被调用端收到消息调用服务并且返回结果来实现的。为了使其更容易使用，服务代理组件可以生成一个代理类，你可以直接调用这个代理（通过服务接口中的api）。","bus可形成跨越多个服务器节点和多个浏览器的点对点的分布式消息系统。","bus地址、ip/dn","bus地址感兴趣）","bus实现的一种异步rpc服务。当从一个ev","bus支持","bus支持发布/订阅、点对点、请求/响应的消息通信方式。","bus支持的任何类型。如果需要表示调用失败，可以使用","bus服务中获取一个服务对象时，你实际上得到的某个服务类的服务代理。你也可以使用","bus服务，你可以通过先获取到服务记录然后获取服务引用的方式，也可以直接通过","bus服务，你需要创建一个","bus注册了对应的messagecodec，服务就可以直接向调用者返回自定义的异常类型：","bus注册了对应的默认messagecodec就可以。比如给定下面的serviceexception子类：","bus注册对应的自定义异常类型的messagecodec实例。","bus消息更加容易。下面我们就来看一下：","bus的address地址）","bus的api很简单。基本上只涉及注册处理器、撤销处理器和发送和发布消息。","bus的别处。想要利用多语言代码生成功能，不要忘记添加对应支持语言的依赖。以下是使用示例：","bus节点之间的传输，这是由","bus调用服务的约定（不使用服务代理的情况下）","bus：","bus：事件总线","byte","byte[40];","byte[]","bytebuffer）。","bytecod","bytes:","c","c3p0","c3p0（datasourceprovider），可以使用下面的配置参数：","c3p0，上面的连接池也可以通过传递一个","c:2}","c:2}。","c:2}。如果我们将配置顺序颠倒为","ca.pem\")","ca.pfx\");","cach","call","callable,","callback","called\"),","callwithparam","camel","canceltim","cartridg","case","catch","caus","cause;","cert.pem\")","cert.pem\");","certif","cet","cet63负责翻译","cfg","challeng","change.getnewconfiguration();","change.getpreviousconfiguration();","channel","channel，pattern","charset","check","chengen","chengenzhao负责翻译，zlf负责校对","chines","chunk","chunk.length());","chunk：块（http","cipher","circuit","circuitbreak","circuitbreaker.create(\"mi","circuitbreakeroptions()","circuitbreakeroptions().setmaxfailures(5).settimeout(2000)","class","class\":","class=io.vertx.cor","class=io.vertx.core.launch","class=io.vertx.core.launcher。要触发重新部署，您需要显示构造项目或模块（build","class=io.vertx.core.launcher，您还可以添加其他参数。随着","classes:lib/otherscripts:jars/myjar.jar:jars/otherjar.jar。始终使用路径引用您的verticle需要的任何资源，不要将它们放在系统类路径上，因为这会导致部署的verticle之间的隔离问题。","classifier会自动通过","classpath","classpath:","classpath），您可使用","class设置为io.vertx.core.launch","clause。您可以选择使用其中的一个","clean","clearus","clever","cli","cli.create(\"copy\")","cli.create(\"som","cli.create(\"test\")","cli.create(annotatedcli.class);","cli.parse(collections.singletonlist(\"","cli.parse(usercommandlinearguments);","cli.usage(builder);","cliconfigurator.inject(commandline,","client","client);","client...","client.connect(1234,","client.connect(4321,","client.get(\"/api/persons\")","client.get(\"/api/persons\").send(","client.get(\"/index.html\",","client.get(\"som","client.get(8080,","client.getabs(u).rxsend())","client.getconnection(r","client.getnow(\"/api/persons\",","client.getnow(\"/som","client.getnow(\"foo.othercompany.com\",","client.getnow(\"som","client.getnow(8080,","client.getnow(new","client.headnow(\"/oth","client.lookup(\"nonexisting.vert.xio\",","client.lookup(\"vertx.io\",","client.lookup4(\"vertx.io\",","client.lookup6(\"vertx.io\",","client.post(\"som","client.put(\"som","client.redirecthandler(respons","client.request(httpmethod.get,","client.request(httpmethod.post,","client.resolvea(\"vertx.io\",","client.resolveaaaa(\"vertx.io\",","client.resolvecname(\"vertx.io\",","client.resolvemx(\"vertx.io\",","client.resolvens(\"vertx.io\",","client.resolveptr(\"1.0.0.10.in","client.resolvesrv(\"vertx.io\",","client.resolvetxt(\"vertx.io\",","client.reverselookup(\"10.0.0.1\",","client.websocket(\"/som","client.websocketstream(8080,","client:","client:3.4.1'","clientconfig()","clientnetworkconfig().addaddress(\"hosts\"))));","clientopt","client、data","client、消息消费者","client会为您设置好传输泵以平滑传输流。如果流长度未知则使用分块传输（chunk","client使得发送","client使用vert.x","client可用","client可用与","client并未提供","client的回顾","client的目的并非为了替换vert.x","client请求发送之后，返回的结果将会被包装在异步结果","client配置选项继承自","client（web客户端）是一个异步的","client（以下简称客户端）底层实现基于","client（以下简称客户端）来与","client）是很不错的（optimized）一种方式。作为一个基于重定向的流程，客户端必须能和资源拥有者的用户代理交互（通常是浏览器），同时要能接受从授权服务器（author","client，可以让我们的","client，请先加入以下依赖：","client，需要添加下面的依赖：","client：客户端","client：已翻译校对完成","cliexcept","cli可以转换的类：","cli提供了一个描述命令行界面的模型，同时也是一个解析器，这个解析器可支持不同的语法：","close","close()","close();","close(handler)","closed\");","closed,","closehandl","closehandler：","cloud","cluster","cluster.xml","clusteredsessionstor","clusteredsessionstore.create(vertx);","clusteredsessionstore.create(vertx,","clustering：","clustering：boliza负责翻译，wuziqiang负责校对","clustering：已翻译校对完成","clustermanag","cluster开关，因为若要使用ha就假定是集群。","cluster：此选项确定vert.x实例是否尝试与网络上的其他vert.x实例形成集群，集群vert.x实例允许vert.x与其他节点形成分布式ev","code","code\"","code).put(\"redirect_uri\",","codec","codec/common","codec/handl","codec/sock","codec/transport","codec：响应体编解码器","codec：响应编解码器（编码及解码工具）","codegen","codegen:3.4.1'","codegen也提供数据对象转换器（data","code：授权码流程（对服务器和app可持久化存储信息）","cold","collect","collect(collectors.averagingdouble(d","collection,","collection：集合，mongodb专用（概念稍同database的table）","color\"));","columnnam","column：vert.x会为每个用户创建一个\"salt“值，并且存储在用户表定义的列中；","com.acme.foo中，com.acme.foo是一个参数。","com.acme.myverticl","com.hazelcast","com.hazelcast.level=info","com.hazelcast.map.merge.latestupdatemapmergepolici","com.mycompany.myproject","com.mycompany.myproject.*","com.mycompany.myproject.engine.myclass；也可以是包含通配符的可匹配某个包或子包的任何类，例如","com.mycompany.myverticl","command","command\")","command,","command.\")","command.observe().subscribe(result","commandfactory：","commandlin","commandline.getargumentvalue(\"source\");","commandline.getargumentvalue(\"target\");","commandline.getargumentvalue(0);","commandline.getoptionvalue(\"mi","commandline.getoptionvalue(\"r\");","commandline.isflagenabled(\"mi","commands。","command条目来配置默认命令。若在没有命令的情况下启动","commit","commit(handler>","commit/rollback","committed\");","commit）默认设置为","common","common/java/","common/java/jdbc","common:3.2.1","common:3.4.1'","common：http://vertx.io/docs/vertx","compil","compilation）。","compileonli","complet","completablefuture.thencompose()，也很接近于","complete（或","compos","compose(handler,","compose(mapper)：当前","compositefuture.al","compositefuture.all(arrays.aslist(future1,","compositefuture.all(httpserverfuture,","compositefuture.any(arrays.aslist(f1,","compositefuture.any(future1,","compositefuture.join(arrays.aslist(future1,","compositefuture.join(future1,","composition：并发合并","comput","concurr","conf","conf\")","conf);","conf.json","config","config()","config().getstring(\"name\"));","config();","config);","config,","config.conf\")","config.json","config.json\"));","config.put(\"acks\",","config.put(\"auto.offset.reset\",","config.put(\"bootstrap.servers\",","config.put(\"enable.auto.commit\",","config.put(\"group.id\",","config.put(\"key.deserializer\",","config.put(\"key.serializer\",","config.put(\"value.deserializer\",","config.put(\"value.serializer\",","config.put(consumerconfig.auto_offset_reset_config,","config.put(consumerconfig.bootstrap_servers_config,","config.put(consumerconfig.enable_auto_commit_config,","config.put(consumerconfig.group_id_config,","config.put(consumerconfig.key_deserializer_class_config,","config.put(consumerconfig.value_deserializer_class_config,","config.put(producerconfig.acks_config,","config.put(producerconfig.bootstrap_servers_config,","config.xml","config.yaml\")","config:3.4.1'","configmap","configmap:3.4.1'","configmap：","configprocessor","configretriev","configretriever.create(vertx);","configretriever.create(vertx,","configretriever.create(vertx.vertx(),","configretriever.getconfigasfuture(retriever);","configretrieveropt","configretrieveroptions()","configretrieveroptions().addstore(git));","configretrieveroptions().addstore(store));","configretriever：","configstorefactori","configstoreopt","configstoreoptions()","configstoreoptions().settype(\"sys\");","configur","configuration\")","configurations.compile.collect","configuration。","config会周期性的去检查变更并更新本地仓库。","config：已翻译校对完成","connect","connect\"),","connect/auth\")","connect/token\");","connect:","connected\");","connecthandler：","connection\"),","connection.batch(batch,","connection.batchwithparams(\"insert","connection.call(func,","connection.callwithparams(func,","connection.close();","connection.commit(r","connection.execute(sql,","connection.goaway(0);","connection.goawayhandler(goaway","connection.pinghandler(p","connection.query(\"select","connection.querystream(\"select","connection.querywithparams(query,","connection.remotesettingshandler(set","connection.setautocommit(false,","connection.shutdown();","connection.shutdownhandler(v","connection.update(\"insert","connection.updatesettings(new","connection.updatewithparams(update,","connection:","connection_fail","connection_str","connectionerror(\"fail","connecttimeoutm","connect、socks4a","consist","console.log('close');","console.log('message',","console.log('open');","console.log('receiv","consul","consul:3.4.1'","consulserviceimporter(),","consum","consumer(\"heat","consumer);","consumer.assign(topicpartitions,","consumer.assignment(done1","consumer.beginningoffsets(topicpartition,","consumer.beginningoffsets(topicpartitions,","consumer.bodystream().toobservable();","consumer.close(r","consumer.commit(ar","consumer.completionhandler(r","consumer.endoffsets(topicpartition,","consumer.endoffsets(topicpartitions,","consumer.exceptionhandler(","consumer.handler(messag","consumer.handler(record","consumer.listtopics(ar","consumer.offsetsfortimes(topicpartition,","consumer.offsetsfortimes(topicpartitionswithtimestamps,","consumer.partitionsassignedhandler(topicpartit","consumer.partitionsfor(\"test\",","consumer.partitionsrevokedhandler(topicpartit","consumer.pause(topicpartition,","consumer.resume(topicpartition);","consumer.seek(topicpartition,","consumer.seektobeginning(collections.singleton(topicpartition),","consumer.seektoend(collections.singleton(topicpartition),","consumer.subscribe(\"a","consumer.subscribe(\"test\",","consumer.subscribe(topics);","consumer.subscribe(topics,","consumer.toobservable();","consumer.unregister(r","consumer.unsubscribe();","consumer.unsubscribe(ar","consumer:","consumerrecord","consumer：消费者","container：容器","content","content\",","contentlength","contenttyp","context","context\");","context)","context.asserttrue(body.tostring().contains(\"hello\"));","context.async();","context.asyncassertsuccess());","context.get(\"data\");","context.get('foo')","context.isonvertxthread())","context.put(\"data\",","context.request().path()","context.runoncontext((v)","context.runoncontext(v2","context:","context。","context下(ev","context（vert.x","context（根据配置不同，可以是ev","context），之后此","context，不同于","context，例如同一个","context，它绑定到了一个特定的","context，并且所有的操作运都会运行在","context：上下文。非特别说明指代路由的上下文","context：上下文环境","continu","continue\"))","continue\");","continue...","continuehandler。它将在服务器发回一个状态","continue持续响应","continue，并且在发送剩余请求体之前先发送请求头。然后服务器可以通过回复临时响应状态","control","control、last","convert","converter）的生成，这使得在服务代理中处理数据实体更加容易。生成的转换器提供了一个接受","cooki","cookie(5)","cookiehandl","cookievalu","cookie。","cookie。可参考","cookie。客户端会在消息头里包含这个令牌。由于令牌基于","cookie头。","cookie，会自动回写到响应里","cookie，因此需要在","cookie，特指有效期为","copi","copied\");","copy、move、truncate、chmod","cor","core","core.jar","core:3.4.1'","core:3.4.1'//新增","core、您的jar和所有依赖项）。","core。","core。很酷的是：我们并不强迫您在书写诸如","core中的","core中的功能相当底层","core主题，该api也可在","core以提供资源或处理文件上传。","core提供了一个用于解析传递给程序的命令行参数api。","core的api，如您对此还不熟悉，请先熟悉","core的依赖","core被打包成了","core，提供了一系列更丰富的功能以便更容易地开发实际的","core：","core：已翻译校对完成","corner","coroutine)。fib","corshandl","cors（跨域资源共享）","count","counter","cp","cpu核数","cp标示。","creat","create(vertx","createcollect","createconnection(str","createproxi","createproxy(vertx","createrecord","createshar","creation","credenti","credentials);","credentials：客户端证书流程（客户端可仅仅可凭借客户端整数申请访问令牌【access","credentials：密码证书流程（之前的流程无法使用或开发阶段使用）","credential：证书","csrf","csrfhandler","ctx.fail(401);","ctx.next();","ctx.request().setexpectmultipart(true);","ctx.reroute(\"/mi","ctx.response()","ctx.response().end(authprovider.generatetoken(new","ctx.response().putheader(\"cont","curat","curv","customer_lastname(?,","customframehandler，每次当自定义的帧数据到达时，这个处理器会被调用。这而是一个例子：","customframehandler，每次自定义帧到达时就会调用它。以下是一个例子：","d))).","d...）。若您使用","dac1989负责翻译，kkkoko校对","dashboard","data","data\")","data\");","data\",","data()：保存接收数据的buff","data.tostring(\"utf","data:","databas","databind","datagrampacket","datagrampacket。","datagramsocket","datagramsocket,","datagramsocketoptions());","datagramsocket。","datagramsocket本地地址","datagram：数据报","dataob","dataobs.subscribe(buff","datasource);","data）包含的功能允许您可以安全地在应用程序的不同部分之间、同一","data）的方式。因为它能够避免把所有的返回值加载到内存中，而且得到的","data：","data：保存接收数据的buffer。","date","date,","date，oid","db","db\")));","db.user.createindex(","db:1,2::clever","db_name","db、建立连接、断开连接、授权相关的命令","db，您需要提供授权的密码，或者","ddthh:mm:ss.sss）格式的字符串。mysql","de","debug","default","default_db","defaultcachemanag","defaultcommand","defaultcommandfactori","default。如果环境变量中有","deflat","deleg","delet","deleted\");","delete。","delivery)。","deliveryopt","deliveryoptions().addheader(\"action\",","deliveryoptions().setcodecname(mycodec.name());","deliveryoptions();","deni","depend","deploy","deployed）。稍后，您完成了所有您需要做的事（如：启动其他verticle），您就可以调用","deployment.subscribe(id","deploymentopt","deploymentoptions().setconfig(config);","deploymentoptions().setinstances(10);","deploymentoptions().setinstances(16);","deploymentoptions().setisolationgroup(\"mygroup\");","deploymentoptions().setworker(true);","deploymentoptions().setworkerpoolname(\"th","deployverticl","depth=1）","description\")","destination\")","destroy","destroyed：销毁","details.","dev","devop","dhazelcast.config","dhazelcast.logging.type=slf4j","differ","dir","dir=lib","directori","disabl","disabledtransport","discoveri","discovery.close();","discovery.getrecord(","discovery.getrecord((jsonobject)","discovery.getrecord(new","discovery.getrecord(r","discovery.getrecords(new","discovery.getrecords(r","discovery.getreference(ar.result());","discovery.getreference(record1);","discovery.getreference(record2);","discovery.getreferencewithconfiguration(","discovery.getreferencewithconfiguration(record,","discovery.publish(record,","discovery.publish(record1,","discovery.unpublish(record.getregistration(),","discovery:3.4.1'","discovery中搜索服务，每次搜索得到的结果是0..n条服务记录（record）。通过这些服务记录，消费者可以获得服务引用（servicereference）。服务引用的作用是绑定服务消费者和服务提供者。通过服务引用，消费者可以得到服务对象来使用服务，也可以通过服务引用释放服务对象。","discovery实例","discovery：已翻译校对完成","distinct","diy","djava.awt.headless=tru","djava.net.preferipv4stack=tru","djava.net.preferipv4stack=true）。有关这方面更多的细节可在https://developer.jboss.org/wiki/ipv6。","djava.net.usesystemproxies=tru","djgroups.tcp.address=192.168.1.20","djgroups.tcp.address=non_loopback","dkey=value。","dn","dname","dnsclient","dnsexcept","dnsexception)","dnsresponsecod","dnsresponsecode，如：","dns客户端","dns查询服务器列表","do","do_actual_work","doc","doc:","docker","dockerlinksserviceimporter(),","document","document,","documentation。","document：文档，mongodb专用（概念稍同database中row）","dodbconnection(result","don't","done","done\");","done.result();","done1.result())","dont'","don’t","dorg.jboss.logging.provider=log4j2","dosomething();","down：服务不再可用","drainhandler：若writestream被认为不再满，则处理器将被调用。","drill123。","driver_class","driverclassnam","driver。","drop","dropbox","dropboxauth","dropcollect","dropwizard","dvertx","dvertx.cachedirbase=/tmp/vertx","dvertx.clustermanagerfactory=io.vertx.spi.cluster.ignite.igniteclustermanag","dvertx.clustermanagerfactory=io.vertx.spi.cluster.jgroups.jgroupsclustermanag","dvertx.disablednsresolver=tru","dvertx.disablefilecaching=tru","dvertx.disablefilecpresolving=true完全禁用高速缓存。这个设置不是没有后果的。vert.x将无法从类路径中读取任何文件（仅从文件系统）。使用此设置时要非常小心。","dvertx.hazelcast.async","dvertx.hazelcast.config=./config/mi","dvertx.hazelcast.config=classpath:my/package/config/mi","dvertx.infinispan.config=./config/mi","dvertx.infinispan.config=my/package/config/mi","dvertx.zookeeper.config=./config/mi","dvertx.zookeeper.config=classpath:my/package/config/mi","e)","e.data);","e.g.","e.g.:","e.getmessage());","e.printstacktrace();","eb","eb.consumer(\"news.uk.sport\");","eb.consumer(\"news.uk.sport\",","eb.consumer(\"som","eb.consumer(\"th","eb.onopen","eb.registerhandler('som","eb.send(\"som","eb.send(\"someaddress\",","eb.send('som","ebsocket","ec","ec2","ec2。","ecdsa","eclips","eclipse：创建一个运行配置，使用io.vertx.core.launcher类作为主类。在","ecmascript6","ee或者是java","ee的支持，幸运的是，我们不需要使用这些貌似很牛逼其实无用的功能，用社区版就好了。下载后安装。","effort","ejb","else,","embed","emp","empti","empty,","enabl","enable.auto.commit","enable_vertx_sync_ag","enabled：todo","encod","encodeprettili","encoding)。","encoding:","end","end(\"alert(\\\"push","end);","ended.","endhandl","endhandler：当流到达时将被调用。这有可能是到达了描述文件的eof、达到http请求的请求结束、或tcp","endoffset","endoffset)","endoffset=\"+endoffset));","endoffset=\"+endoffset);","endpoint","endpoint:","endpoint服务","endpoint服务发布好了，服务消费者就可以获取到这个服务。对应的服务对象是一个","endpoint服务对象就是一个配置了host、port和ssl的","endpoint服务，你需要一个","endpoint类型。","engin","enter_your_version_her","entiti","entry\"","entry：条目（一条key=value的键值对）","enum","env","equinox，（这个）bundle导出io.vertx.core*。","err","err;","error","error\");","error)，如服务代理没有对应的已注册的服务","error,","error.getmessage());","error:","errorhandler。您只需要在需要覆盖到的路径上将它设置为失败处理器(9)来使用它。","es256","es384","es512","etc","eval","evalsha","event","eventbu","eventbus('http://localhost:8080/eventbus');","eventbus('http://localhost:8080/eventbus',","eventbus);","eventbus.consumer(\"news.uk.sport\");","eventbus.j","eventbus.publish(\"news.uk.sport\",","eventbus.registercodec(mycodec);","eventbus.registerdefaultcodec(mypojo.class,","eventbus.send(\"news.uk.sport\",","eventbus.send(\"orders\",","eventbusopt","eventbusoptions()","eventbusoptions还允许您指定","eventbusservic","eventbusservice.createrecord(","eventbusservice.getproxy(discovery,","eventloop","exactli","exampl","exc","exc.getdebuginfo().getstring(\"shoesize\"))","exc.getshoesize())));","except","exception);","exception.code();","exception:","exceptionhandl","exceptionhandler若readstream发生异常，将被调用","exceptionhandler：若writestream发生异常，则被调用。","exclud","execut","executeandreport","executeblock","executor","executor,","executor.close();","executor.executeblocking(futur","executorservice等这些并发和线程相关的东西就不再需要使用了，可以由verticle全面接管，如果您不得不在vert.x代码中使用上诉内容，则多少暗示着您的设计或者使用vert.x的姿势出现了问题，建议再斟酌商榷一下。","executor。","exist","exists.","expect:","explicitli","expos","express","ext","extend","external：vert.x仅仅将密码最终加密结果存储在数据库中，\"salt“值可以在外部使用，并且可以调用setexternalsalt方法进行设置。","extra;","f","f)","f2,","f3));","f;","facebook","facebookauth","factori","factory:3.2.1'","factory。","factory会从","factory的maven依赖，如果你使用的是fat","factory：通过","factory？","fail","fail(int","failed!","failed!\");","failed\"","failed\");","failur","failurecode,","failureroutingcontext.response();","failureroutingcontext.statuscode();","failures:","fals","false);","false。","false。这样任何","false，可以通过","fanci","faq","fat","fat.jar","favicon.ico","faviconhandl","feed\",","felix","fiber","fiber(译者注：这个词国内有译作纤程，类似协程","fiberhandl","fiber。","fiber。字节码增强工作是在运行时使用","field","field（字段），默认值是","file","file);","file.endhandler((r)","file.endhandler(v","file.properties\"));","file.toobservable();","file:","filelen","filelen)","filer","fileres.result();","files.","files.\")","fileset","filestor","filestream","filesystem","filesystem.open(\"/data.txt\",","filesystem.open(\"myfile.txt\",","files，即文件上传），该功能可能在将来版本中予以支持。","fileupload","filter","final","final。","find","findbooks(ar","finder。tcp","findon","findone(str","findopt","findwithopt","fine\");","finish，随后会建立以下文件结构，跟maven文件夹结构几乎一样：","fire","fired!\");","fired\");","first","flag","flag\"))","flag\");","flag)","flag;","flatmap","flatmap(httpclientresponse::toobservable).","fli","flow","flow：流","fluent：流式的","flush","flush：刷新（指将缓冲区中已有的数据一次性压入，用这种方式清空缓冲区，传统上翻译成刷新）","fname","fname,","follow","foo(str","foo.c）","foo.j","foo.tar.gz）","foo.txt","foolish.","fooverticle.groovi","foo）","foreach(","forget","form","form.set(\"firstname\",","form.set(\"lastname\",","format","formattribut","formerror","formloginhandl","found","found\".","found)","foursquar","foursquareauth","fox","foxpaulo","frame","frame\");","frame.payload().tostring());","frame.type()","frame1","frame2","frame3","frame:","framestatu","framestatus,","frametyp","framework","frame：帧","franca)。但是若您不想用","freemark","freemarker:3.4.1。通过这个方法来创建","freemarker：io.vertx:vertx","fs","fs.copy(\"foo.txt\",","fs.copyblocking(\"foo.txt\",","fs.createfile(\"/foo\",","fs.move(\"/foo\",","fs.open(\"/data.txt\",","fs.open(\"content.txt\",","fs.writefile(\"/foo\",","full","fulli","func","func_proc_name()","func_proc_name(?,","function","function()","function(e)","function(error,","function方法当且仅当前一个异步流程执行成功时才会被调用。","function，funct","function，该","further","fut1","fut1.completer());","fut1.compose(v","fut1中文件创建完成后执行","fut2","fut2.completer());","fut2;","fut2文件写入完成后执行","futur","future(超时)","future)","future);","future.>future((future)","future.>future(f","future.complete();","future.complete(buffer.tostring());","future.complete(result);","future.complete(somecommand.execute()),","future.completer());","future.compos","future.compose(messag","future.fail(\"http","future.failedfuture(new","future.futur","future.future();","future.sethandler(ar","future.sethandler(asyncresult","future.succeededfuture(client.getabs(absoluteuri));","future/promis","future1","future1);","future1.sethandler(asyncresult","future2","future2).sethandler(ar","future2);","future2,","future2.sethandler(asyncresult","future3));","future3).sethandler(ar","future>","future。","future。如果桥接器的启动方法是阻塞型的，那么就必须使用","future。当返回的","future。比如：","future。这个特性可以用于定制您自己的消息过滤器、细粒度的授权或指标收集。","future（startfuture）会是成功的；其中任何一步失败，则最终","future，以此来汇报处理成功或者失败。","future，否则就标记为失败。（译者注：3.4.0","future，针对每一个异步的过程，需要在代码中声明中间变量","future：","future；当任一个","g","g1","g2","gcc_version:","gcm","gener","genkey","genkeypair","genseckey","get","get.copy()","get.send(ar","get.subscribe(resp","get/put/delet","getacceptablecontenttyp","getbodi","getbodyasjson；如果您知道它的类型是字符串，您可以使用","getbodyasstring；否则可以通过","getclusterport","getclusterwidemap","getcollect","getcolumnnam","getconnect","getcooki","getcount","getdefaultcommand","getkeys方法获得对应的主键。","getlock","getmainverticl","getmaxconcurrentstreams：按照","getnow。这些方法会创建http","getobservable();","getorcreatecontext","getpayload();","getrawmessag","getrecord","getrefer","getresult","getrow","getshoesize()","getsomecommandinstance();","getsslengineopt","getter/setter）时，并且有一个","getunsignedxxx、appendunsignedxxx","getupd","getx","getxxx","get、opt","get、post、put","get，options以及head请求没有请求体，可用以下方式发送无请求体的http","git","git:3.4.1'","gitbook","github","github\");","githubauth","githubauth.create(vertx,","given","global:挑选一个可用的全局地址。如果不能，使用","go","goaway","googl","google\");","googleauth","goroutin","grace","gradl","gradle(build.gradle)","gradle(gradle.xml)","gradle(在","gradle(在build.gradle文件里)","gradle(在你的build.gradle文件中)","gradle(在你的build.gradle文件里)","gradle中也可以进行配置：","gradle（在","gradle（在build.gradle文件中）","gradle（在build.gradle文件中）：","gradle（在您的","gradle（您的","gradle（译者注：两种常用的项目构建工具），将以下依赖项添加到您的项目描述文件的","grass\",","groovi","groovy:com.mycompany.somegroovycompiledverticl","groovy:io.vertx.example.mygroovyverticl","groovy。","group","group)，同一个组只有一个消费者可以消费特定的","group:","groupconfig(\"groupname\",\"password\")","groupid，artifactid在settings.gradle中","group）中（在创建消费者实例时通过配置指定）。当然你需要通过","group：消费组（kafka中的设计）","gssapi","gssapiservicenam","guava","gy负责翻译，chengenzhao校对","gzip","gzip,","gzip/defl","h","h\"));","h));","h2","h2c","h2c。","h2c之上的","h2c（未加密http/2服务器）的连接可能不受","h2c，所以在建站时，您应该使用","h2和tcp","ha","hagroup","hagroup开关。","hagroup：该参数需要和","half","halfopenhandl","handl","handlebar","handlebars:3.4.1。通过这个方法来创建","handlebarstemplateengine.create();","handlebars：io.vertx:vertx","handler","handler\").handler(ctx","handler\");","handler)","handler.handle(future.failedfuture(","handler.j","handler/handle：处理器/处理，有些特定处理器未翻译，如complet","handler1","handler2","handler3","handler>","handlerreceiveradaptor","handlerreceiveradaptor>","handler。","handler传入一个","handler等。","handler（译者注：关于","handler）","handler）：","handler，res.successed()","handler，以毫秒为单位计时。","handler，因此你可以将它直接作为回调的","handler，当操作完成或发生错误时调用该处理器。","handler：","handler：处理器","handler：处理器，某些特定的地方未翻译","handler：结果处理器","handler：设置一个处理器，它将从readstream读取项","handler：（事件）处理器","handling...","handshak","happened!\");","happened\");","hasauthor","hash","hashmap<>();","hashset<>();","hashtable,","haspermiss","hasrol","hawking\")","hawkular","hazelcast","hazelcast:${version}。","hazelcast:3.4.1\"){","hazelcast:3.4.1'","hazelcastclient.newhazelcastclient(","hazelcastclustermanag","hazelcastclustermanager();//创建clustermanger对象","hazelcastclustermanager(hazelcastconfig);","hazelcastclustermanager(hazelcastinstance);","hazelcastclustermanager。","hazelcastconfig","hazelcastinst","hazelcast支持多种不同的传输协议，包括组播和tcp。默认配置中采用组播传输协议，因此您必须在网络上启用组播才能使其工作。","hazelcast（默认实现）","hazelcast，需要做以下工作：","hazlecast","ha一起使用，它指定此节点将加入的ha组。集群中可以有多个ha组，节点只会故障转移到同一组中的其他节点。默认为__default__。","ha一起使用，它指定集群中所有ha部署id处于活动状态的最小节点数，默认为0。","ha参数到命令行：","ha开关时，您不需要提供","ha组","ha（高可用或故障转移）时，请不要使用","ha：若指定，该verticle将部署为（支持）高可用性（ha）。有关详细信息，请参阅相关章节。","head","header","header\",","headers);","headers.get(\"us","headers.set(\"cont","headers.set(\"oth","headers:","headers、path、queri","headers：","header允许一个特定的键包含多个值。","header：消息头","header：请求/响应头","heartbeat","heartbeat.socket","heartbeatfrequencym","heartbeatinterv","heat","heat);","hello","hello\\\")\");","hellocommandfactori","hellocommandfactory()","here","here!!!\");","here...","here?\");","hgetal","high","hikari","hispassword,develop","hmac","hmacsha256","hmacsha384","hmacsha512","hmset","hobbit\")","hobbit\").put(\"_id\",","hobbit\");","hocon","hocon)","hocon:3.4.1'","hocon。","hook","hook.getcomputationscheduler());","hook.getioscheduler());","hook.getnewthreadscheduler());","hops：跳数（一台路由器/主机到另外一台路由器/主机所经过的路由器的数量，经过路由转发次数越多，跳数越大）","host","host:","host:挑选任何符合域名规则的地址，例如：linux.*","host、port","host参数：","host和clust","host：若指定了cluster选项，则可以确定哪个主机地址将用于其他vert.x实例进行集群通信。默认情况下，它将尝试从可用的接口中选一个。若您有多个接口而您想要使用指定的一个，就在这里指定。","hot","hs256","hs384","hs512","html","http","http/1","http/1.0","http/1.0、http/1.1","http/1.1","http/1.1。","http/1.1升级","http/1.1）。","http/1.x","http/1.x，但可以连接到","http/2","http/2规范定义了可使用的","http/2，当响应到达时，可以使用","http/2：","http/http","http2set","http2settings().setmaxconcurrentstreams(100));","http2settings().setmaxconcurrentstreams(100),","http://cdn.jsdelivr.net/sockjs/0.3.4/sockjs.min.js。","http://localhost:8080","http://localhost:8081","http://vertx.io/docs/auth","http://www.slf4j.org/codes.html#staticloggerbind","http://www.somehost.com/path/file.html","http_2。","httpclient","httpclient;","httpclientconfiguration:","httpclientopt","httpclientoptions()","httpclientoptions());","httpclientoptions().","httpclientoptions().setdefaulthost(\"wibble.com\");","httpclientoptions().setkeepalive(false);","httpclientoptions().setlogactivity(true);","httpclientoptions().setprotocolversion(httpversion.http_2);","httpclientrequest","httpclientrequest,","httpclientrespons","httpclientresponse，并返回","httpclient。","httpclient可以在一个","httpclient，可用以下方式复用：","httpclient，而是基于该客户端，扩展并保留其便利的设置和特性，例如请求连接池（pooling），http/2的支持，流水线／管线的支持等。当您需要对","httpconnect","httpendpoint","httpendpoint.createrecord(","httpendpoint.createrecord(\"som","httpendpoint.getcli","httpendpoint.getclient(discovery,","httpendpoint.getwebclient(discovery,","httpmethod.put)","httprequest","httprespons","https://en.wikipedia.org/wiki/futures_and_promis","https://github.com/mauricio/postgresql","https://myserver.com/callback。这是您的处理器的第二个参数。至此，您完成所有必须的配置，只需要通过","https://myserver.com:8447/callback。注意，端口号可以不使用默认值。","https://nodejs.org/en/download/","httpserver","httpserver.listen(httpserverfuture.completer());","httpserver.requesthandler(request","httpserverfileupload","httpserverfileupload,","httpserverfutur","httpserveropt","httpserveroptions()","httpserveroptions().","httpserveroptions().setlogactivity(true);","httpserveroptions().setmaxwebsocketframesize(1000000);","httpserverrequest","httpserverrequest,","httpserverrequest。","httpserverrespons","httpserverresponse，websocket,","httpserverresponse，还包含了各种用于简化","httpstore","https。","http基本认证","http基础认证是适用于简单应用的简单认证手段。","http客户端。","http客户端请求","http方法用于非标准http方法，当使用此方法时，必须使用","http服务端请求","http请求通常包含我们需要读取的主体。如前所述，当请求头部达到时，请求处理器会被调用，因此请求对象在此时没有请求体。","http，对于一部分应用来是足够的。","human","hungry.","hyperloglog","hystrix","hystrixcommand","hystrixmetrichandl","hystrix带有一个仪表板（dashboard），用于显示熔断器的当前状态。","hystrix提供了熔断器模式的实现。可以在vert.x中使用hystrix提供的熔断器或组合使用。本节介绍在vert.x应用程序中使用hystrix的技巧。","i);","i++;","i,","i.v.e.h.s.httpserververticle@1","i.v.e.h.s.httpserververticle@2","i/o","i686\",","iatomiclong","icompletablefuture，这与","id","id),","id);","id,","id=mi","idea，有两个版本，社区版（community）和终极版（ultimate），后者需要付费使用，相比起前者而言，多了很多java","idea，选择创建新项目","idea：创建一个运行配置（应用）,将主类设置为io.vertx.core.launcher。在程序参数中写：run","ident","ide通常会支持注解处理器。","id。在","id可以在之后您想要撤销它时使用。","id，但是此","id，回调方法中可以获得保存后生成的","id，而在","id，配置参数如下：","id：应用程序id，若未设置，则使用随机uuid","if(asyncresult.failed()){","if(asyncresult.succeeded()){","if(done.succeeded())","if(res2.succeeded())","ifram","ignit","ignite.xml","ignite.xml。","ignite:3.4.1'","igniteclustermanag","igniteclustermanager();//创建","igniteclustermanager(cfg);","igniteconfigur","igniteconfiguration();","ignite。","ignor","illustr","imap","immut","implement","import","import（自动引入）以及cr","in,","inboundpermit","inboundpermitted.setrequiredauthority(\"place_orders\");","inboundpermitted1","inboundpermitted2","inboundpermitted3","includes,","increment","index.html","index.html。可以通过","indexoutofboundsexception。","index），你可以在mongodb服务器中运行下边的片段来完成此操作：","individualid","individualid));","inetsocketaddress","inf/servic","inf/services/io.vertx.core.spi.launcher.commandfactori","inf/services/io.vertx.core.spi.launcher.commandfactory）。","inf/services/io.vertx.servicediscovery.spi.servicetype文件，并把这个文件打包到自定义类型的jar包中，在这个文件中，需要标明第二步中所创建类的全限定名。","infinispan","infinispan.xml","infinispan.xml\");//加载自定义配置文件","infinispan:3.4.1'","infinispanclustermanag","infinispanclustermanager(\"custom","infinispanclustermanager();//创建","infinispanclustermanager(cachemanager);","infinispan（预览版）","initi","initial_pool_s","insert","insert(jsonobject","insert/update/delet","insertjsessionid","instagram","instagramauth","instal","instanc","instance);","instanceof","instrument","instrumentation)的技术实现了","instrumentation，指非运行时织入字节码)的效果。更多细节请参考","instrumentation：字节码修改/增强","int","int);\";","integ","integr","intellij","interesting!\");","interfac","interface:挑选任何匹配网络接口名的地址，例如匹配接口：eth\\","interface组件定义了","interface：已翻译校对完成","internalloggerfactory.setdefaultfactory(log4jloggerfactory.instance);","intval","invalid","invalidinputerror(\"y","io","io.exampl","io.example.main","io.example.mainverticl","io.example;","io.netty.handler.logging.logginghandl","io.undertow","io.vertx","io.vertx.core.abstractverticle;","io.vertx.core.http.httpclient;","io.vertx.core.json.jsonobject;","io.vertx.core.launch","io.vertx.core.launcher.example.hellocommandfactori","io.vertx.core.launcher。另外，将","io.vertx.core.net.impl.connectionbas","io.vertx.core.shareddata.asyncmap","io.vertx.core.spi.cluster.asyncmultimap","io.vertx.core.streams.pump，可以在将数据从一个流泵到另一个流时，实现流量控制。更多关于","io.vertx.core.streams.writestream","io.vertx.core.vertx","io.vertx.core.vertx;","io.vertx.core.vertx。","io.vertx.example.mverticl","io.vertx.example.myverticl","io.vertx.examples.http.sharing.httpserververticl","io.vertx.ext.auth.prng.algorithm","io.vertx.ext.auth.prng.seed.bit","io.vertx.ext.auth.prng.seed.interv","io.vertx.ext.jdbc.jdbcclient;","io.vertx.ext.sync.syncverticl","io.vertx.ext.unit.async;","io.vertx.ext.unit.junit.vertxunitrunner;","io.vertx.ext.unit.testcontext;","io.vertx.ext.web.client.webclient;","io.vertx.rxjava","io.vertx.rxjava.core.abstractverticl","io.vertx.rxjava.core.rxhelper.scheduler(vertx);","io.vertx.rxjava.core.rxhelper.scheduler(workerexecutor);","io.vertx.rxjava.core.rxhelper.schedulerhook(vertx);","io.vertx.rxjava.core.vertx.vertx();","io.vertx.serviceproxy.serviceproxyprocessor","io.vertx:vertx","io.vertx，同时还有","iot：","iot：lizhenxiang负责翻译，943470549@qq.com负责校对","iot：计划中","ip","ipv4","ipv4:","ipv6","ipv6，但路由表配置不正确，或使用","is:","isauthent","isfallbackonfailure，其结果是失败回调函数的输出。失败回调函数将","iso","issu","it.isdirectory()","item：对象","jackson","jade","jade4j","jade:3.4.1。通过这个方法来创建","jar","jar.jar","jar。","jar一样可直接执行：","jar中时，您必须将下边信息写入manifest：","jar包为","jar文件本质上就是一个zip文件，可以用打开zip的压缩工具解压，读者可自行解压拆开jar包，看看相关依赖的文件是否在里面。比如例子中的代码除了生成io.example.myfirstverticle.class和io.example.mainverticle.class文件以外，还同时将依赖的io.vertx.core中的内容压入jar包。","jar的方式，你可以用如下依赖：","jar（或包含在其中）的类路径中，或放在vert.x发行版的lib目录中，您将可以执行：","jar）里进行分发。","jar，则使用默认命令。","jar，要确保","java","java.io.ioexception:","java.util.logging.consolehandler.level=info","java.util.logging.filehandler.level=info","java.util.loging（jul）","java.util.loging（jul）配置文件。具体配置如下：","javaagent:/path/to/alpn/ag","javaagent:/path/to/quasar/core/quasar","javaobject","javascript","javascript），当消息发送时，vert.x","java中，lambda本身也是一个对象，是一个@functionalinterface的对象，verticle对象中包含了一个或者多个处理器（handler）对象，比如上述例子中myverticle中就包含有两个handler。在vert.x中，完成verticle的部署之后，真正调用处理逻辑的入口往往是处理器（handler），vert.x保证同一个普通verticle（也就是eventloop","java基础知识，您不需要了解java","java的知识点。请注意：vert.x","jboss","jca","jcek","jdbc","jdbc/java/","jdbc/java/jwt","jdbc/mysql/postgresql）的接口来获取数据库连接。","jdbc:3.2.1","jdbcauth","jdbcauth.create(jdbcclient);","jdbcclient","jdbcclient.create(vertx,","jdbcclient.createnonshar","jdbcclient.createnonshared(vertx,","jdbcclient.createshar","jdbcclient.createshared(vertx,","jdbcclient;","jdbcclientconfig);","jdbcclient。","jdbcclient，你需要同时提供：服务记录位置信息、元数据以及服务消费者提供的json对象：","jdbcdatasourc","jdbcdatasource.createrecord(","jdbcdatasource.getjdbcclient(discovery,","jdbcstatementhelper.fillstatement(statement,","jdbcurl","jdbc数据源服务，服务对象的类型是一个jdbcclient（该client的配置参数，将从location、元数据和服务消费者传递的参数中获取）","jdk","jdk1.8","jdksslengineopt","jdksslengineoptions());","jdk中alpn可用时使用","jetti","jgoup","jgoups.xml","jgroup","jgroup.xml","jgroups.bind_addr","jgroups.tcp.address","jgroups.xml","jgroups:3.4.1'","jgroupsclustermanager();","jgroups与","jgroups支持多种传播方式，包括多播与tcp。默认配置时多播方式，所以需要确保网络是否启用多播。","jgroups文档","jksoption","jksoptions().","jksoptions().setpath(\"/path/to/my/keystore\"));","jksoptions().setpath(\"keystore.jks\").setpassword(\"wibble\"))","jksoptions：","joda","join","js","js:foo.j","jsessionid，这样负载均衡器可以保证","json","json,","json.encod","json.stringify(message));","jsonarray","jsonarray()","jsonarray());","jsonarray().add(\"fox\").add(9);","jsonarray().add(\"fox\");","jsonarray().add(\"jane\"));","jsonarray().add(\"joe\"));","jsonarray().add(\"john\"),","jsonarray().add(\"john\").add(\"doe\"),","jsonarray().add(new","jsonarray().addnull().add(\"varchar\"),","jsonarray();","jsonarray(jsonstring);","jsonarray.class);","jsonarray.class,","jsonarrayconsum","jsonarrayproduc","jsonarray）还有buffer，这些对象在传递过程中是不可变的。","jsonarray，primit","jsonobject","jsonobject()","jsonobject());","jsonobject().put(\"$binary\",","jsonobject().put(\"$date\",","jsonobject().put(\"$oid\",","jsonobject().put(\"$set\",","jsonobject().put(\"_id\",","jsonobject().put(\"access_token\",","jsonobject().put(\"action\",","jsonobject().put(\"author\",","jsonobject().put(\"cache\",","jsonobject().put(\"code\",","jsonobject().put(\"connection_string\",","jsonobject().put(\"endpoint\",","jsonobject().put(\"header1\",","jsonobject().put(\"host\",","jsonobject().put(\"key\",","jsonobject().put(\"keystore\",","jsonobject().put(\"name\",","jsonobject().put(\"path\",","jsonobject().put(\"pattern\",","jsonobject().put(\"properties_path\",","jsonobject().put(\"shoesize\",","jsonobject().put(\"som","jsonobject().put(\"sub\",","jsonobject().put(\"title\",","jsonobject().put(\"url\",","jsonobject().put(\"username\",","jsonobject().put(\"wibble\",","jsonobject();","jsonobject(jsonstring);","jsonobject(map);","jsonobject.class","jsonobject.class);","jsonobject.class,","jsonobject.getinteger(\"som","jsonobject.getstring(\"som","jsonobject.mapto(user.class);","jsonobjectconsum","jsonobjectproduc","jsonobject），这些函数对于在服务代理中处理数据实体来说都是必要的。","jsonobject：","jsonobjetc","jsonstr","json。","json体","json体的编码和解码","json对象","json数组。","json解码","json还能提供options属性，可精确的被映射到deploymentoptions对象中。","json（bson）格式的文档数据库。","json）","json，并且为了保持稳定性，下一个","json，您可以使用","json，我们并不强制您使用它。","json：","jul","julien","jul）。如果想切换至其他日志库，通过设置","junit","jvm","jvm必须将","jwt","jwt/java/","jwt/java/shiro","jwt:3.2.1'","jwtauth","jwtauth.create(vertx,","jwtoptions()));","jwtoptions());","jwt主要的优点有：","jwt用法的典型流程是，在您的应用程序有一个终点颁发令牌，这个终点应在ssl模式下运行，终点这通过用户名和密码验证完请求用户之后，表示你将这样做生成令牌：","jwt，oauth","kafka","kafkaconsum","kafkaconsumer#exceptionhandl","kafkaconsumer.create(vertx,","kafkaproduc","kafkaproducer#exceptionhandl","kafkaproducer.cr","kafkaproducer.create(vertx,","kafkaproducer.createshar","kafkaproducer.createshared(vertx,","kafkaproducerrecord.create(\"test\",","kafkaproducer：","kafkareadstream用于读取","kafkawritestream用于向某些","keep","keepal","kerbero","kernel","key","key\");","key.pem\").","key.pem\");","key=\"","keyalg","keycertoptions和","keycloak","keycloakauth","keyname:","keypass","keys:","keysiz","keystor","keystore\")","keystore\");","keystore.jcek","keystore.jceks)","keystore.jks\").","keystore.jks\");","keystore.pfx\").","keystore.pfx\");","keytool","key）。需要注意","key：","kick","kill","kube_p","kubernet","kubernetes.nam","kubernetes.namespace,","kubernetes:3.4.1'","kubernetes_namespace，则会优先使用此值","kubernetes中的服务，在导入到vert.x后都会创建对应的服务记录（record）。服务类型是通过","kubernetes的所有服务，都将映射为一条","label\")),","label\",","lambda","lang","languag","larg","large_table\",","large_table;","last","later","launcher","launcher，单您已使用了您自己的主类。","launcher：启动器","layer","ldap","ldap_url：这个url是设置ldap服务器。这个url必须以ldap://开头，端口也必须要指定。这是一个示例ldap://myldapserver.mycompany.com:10389","lengh\");","length","length\",","length。","length。若您在使用http","length头，否则会出错。","length：要读取的数据的字节数","level","lib","librari","libraryurl","life","lift(io.vertx.rxjava.core.rxhelper.unmarshaller(mypojo.class)).","lift(io.vertx.rxjava.core.rxhelper.unmarshaller(mypojo.class));","lift：变换","like","limit","line","line.isaskingforhelp())","linhar","link","link_local:挑选一个链接本地ip地址从169.254.1.0到169.254.254.255","linkedin","linkedinauth","links:3.4.1'","linode28","list","list.stream().maptodouble(n","listen","listen(...)","listening!\");","listproductsauthhandl","listproductsauthhandler.addauthority(\"list_products\");","list）。当任意一个","list）。当所有的","lizhenxiang负责翻译，943470549@qq.com负责校对","lname","lname,","lname=?","lname=?\";","load","loader）功能查找集群管理器，以便在类路径中查找clustermanager的实例。","localaddress方法获取","localhost","localhost。","localhost）。","localmap","localsessionstor","localsessionstore.cr","localsessionstore.create(vertx);","localsessionstore.create(vertx,","local）","locat","location信息将从服务的第一个端口推断出来","lock","lock!","lock.release());","log","log4j","log4j2","logdelegatefactori","logger","logger.error(\"oops!\",","logger.info(\"someth","loggerfactory.getlogger(classname);","loggerformat。","loggerhandler。","logging.properti","logging.properties的jul配置文件（例如在您的fatjar中），vert.x将使用该配置文件配置jul。","logging：动词翻译成","long","long.max_value;","long.parselong(request.getparam(\"end\"));","long.parselong(request.getparam(\"start\"));","lookup","lookup4","lookup6","loop","loop\");","loopback:挑选一个环回地址，例如127.0.0.1","loop。","loop。为了帮助您诊断类似问题，若","loop中执行（只要您不创建自己的线程并调用它！）","loop中直接使用","loop中访问socket","loop线程。如果不这样做的话，您将失去vert.x并发模型的优势，并且必须自行管理线程同步和执行顺序：","loop线程中","loop线程或worker线程)","loop（如不同的","loop，任何一个特定的处理器永远不会被并发执行。大部分情况下（除了","loop，但是这并不能帮您避免在您自己的处理器中阻塞","loop，而且您希望每秒处理10000个","loop，那么您的应用就会完全停止！","lope","lord","lua","maco","macros等。","mac系统例子：","mail","mailchimp","mailchimpauth","main","main(string[]","main.java","main.js，并不在需要它。","mainrout","mainrouter.mountsubrouter(\"/productsapi\",","mainrouter.route(\".*\\\\.templ\").handler(mytemplatehandler);","mainrouter.route(\"/static/*\").handler(mystatichandler);","maintenancefrequencym","maintenanceinitialdelaym","mainverticl","make","manag","manager。","manager）来实现集群管理。在","mandatori","manifest","manual","map","map(sampl","map.foreach((topic,","map.get(\"foo\",","map.get(topic));","map.put(\"foo\",","map.put(\"xyz\",","map/reduc","map1","map1.get(\"foo\");","map1.put(\"foo\",","map2","map2.get(\"eek\");","map2.put(\"eek\",","map>","mapper将","mapreduce。更多详情，请参考说明文档","maps)允许从集群的任何节点将数据放到","mapto","map来实现，并包含了一个用于清理过期会话的回收器。","map：","map：动词翻译成","master","master)，并且可以指定","match","mauricio","maven","maven(pom.xml)","maven(在","maven(在你的pom.xml中)","maven/gradl","mavencentral()","maven相关知识，您需要知道什么maven是做什么用的，以及如何使用maven；","maven（在","maven（在pom.xml文件中）","maven（在pom.xml文件里）","maven（在你的pom.xml文件里）","maven（您的","max","max_idle_tim","max_pool_s","max_stat","max_statements_per_connect","maxbytesstream","maxexecutetim","maxexecutetime);","maxidletimem","maximumpools","maxlifetimem","maxpools","maxretries：尝试重新连接的次数，默认是","mechan","mechanism：todo","member\"","member。","memory:","messag","message)","message,","message.body());","message.body(),","message.body();","message.fail(…​)","message.put(\"collection\",","message.reply(\"how","message.reply(…​)","message:","messagecodec","messagecodec。消息编解码器有一个名称，您需要在发送或发布消息时通过","messageconsum","messageconsumer,","messageconsumer。","messageconsumer中。在某些情况下，发送者需要知道消费者何时收到消息并","messageconsumer，之后再来设置处理器。如：","messageproduc","messagesourc","messagesource.createrecord(","messagesource.getconsumer(discovery,","message。","meta","metadata","metadata\",","method","method,","method。","method（即get、post、put、delete、head、options等）。","method，您可以使用","method，您可以调用","metric","metrics\").handler(hystrixmetrichandler.create(vertx));","metric：指标","me的知识，但是需要您对java有所了解，在此文档中，我们不会介绍任何关于java","mgr","micro","microservic","microservices：","mime","min_pool_s","minheartbeatfrequencym","minpools","minutes.","mm","model","modifi","modified、date。","module:","mongo","mongo/java/","mongo/java/oauth","mongo:3.2.1","mongoauth","mongoauth.create(client,","mongocli","mongoclient.count(\"books\",","mongoclient.createcollection(\"mynewcollectionr\",","mongoclient.createnonshar","mongoclient.createnonshared(vertx,","mongoclient.createshar","mongoclient.createshared(vertx,","mongoclient.distinct(\"books\",","mongoclient.distinctbatch(\"books\",","mongoclient.dropcollection(\"mynewcollectionr\",","mongoclient.find(\"books\",","mongoclient.findbatch(\"book\",","mongoclient.getcollections(r","mongoclient.insert(\"books\",","mongoclient.remove(\"books\",","mongoclient.replace(\"books\",","mongoclient.runcommand(\"aggregate\",","mongoclient.save(\"books\",","mongoclient.update(\"books\",","mongoclient.updatewithoptions(\"books\",","mongoclientconfig);","mongoclient。","mongoclient，你需要同时提供：服务记录位置信息、元数据以及服务消费者提供的json对象：","mongodatasourc","mongodatasource.createrecord(","mongodatasource.getmongoclient(discovery,","mongodb","mongodb中可以设置下边几种salt的值（参考下边warning）：","mongodb的特性是先查询username字段中的值是否已经存在，然后会插入一个document，并不能作为一个原子性操作，基于这个原因你需要添加上边的唯一索引，使用了这个索引过后你的代码会尝试先插入一行数据，如果出现了重复记录则会失败。","mongoservice.findone(\"publishedbooks\",","mongoservice.findone(\"smartpeople\",","mongoservice.save(\"publishedbooks\",","mongoservice.save(\"smartpeople\",","mongo数据源服务，服务对象的类型一个mongoclient（该client的配置参数，将从location、元数据和服务消费者传递的参数中获取）","more","mount：挂载","ms","msdn。","mset","msetnx","msg.body(),","msg1","msg1);","msg2","msg2);","msg3","much","multi","multicast","multicast：多播（组播）","multimap","multimap.caseinsensitivemultimap();","multimap。","multipart","multipart/form","multipl","multiplexing_api:","multiplexing：多路复用","mvel","mvel:3.4.1。通过这个方法来创建","mxrecord允许您通过下边提供的方法访问mx记录的优先级和名称：","my.verticl","my_verticle.conf","my_verticle.j","my_verticle.rb","mycaasabuff","mycertasabuff","mycodec);","mycommand","myconf.json","mycrlasabuff","mydatabaseconnect","myfirstverticl","myfirstverticle.java","myfirstverticletest","mykeyasabuff","mykeystoreasabuff","myotherpojo","mypassword,administrator,develop","mypojo","mypojo());","mypojo(),","myservic","myservice.class","myservice.class,","myserviceexception(failurecode,","myserviceproxyhandl","myservicevertxebproxy。","myservice，则对应的处理器类命名为","mysql","mysql/postgresql","mysqlclient","mysqlclient.createnonshared(vertx,","mysqlclient.createshar","mysqlclient.createshared(vertx,","mysqlclientconfig","mysqlclientconfig);","mysqlclientconfig,","mytruststoreasabuff","myverticl","myverticle();","myverticle.groovi","myverticle.j","myverticle.java","n","n)","n).average()","n;","name","name\")","name\"));","name\"),","name\",","name)","name);","name:","name;","namespac","namespace\")","name未设置，将生成一个随机的id，并在命令提示符中打印。您可以将run选项传递给start命令：","name的系统属性，该属性的值是一个实现了","name：todo","naughi","naughti","need","negotiation)是应用层协议协商的tls扩展，它被http/2使用：在tls握手期时，客户端给出其接受的应用协议列表，之后服务器使用它所支持的协议响应。","negotiation：alpn，应用层协议协商","net","netclient","netclientopt","netclientoptions()","netclientoptions().","netclientoptions().setconnecttimeout(10000);","netclientoptions().setlogactivity(true);","netclientoptions().setssl(true).setkeystoreoptions(","netclientoptions().setssl(true).setpemkeycertoptions(","netclientoptions().setssl(true).setpfxkeycertoptions(","netflix","netserv","netserver.listen(netserverfuture.completer());","netserverfutur","netserverfuture).sethandler(ar","netserveropt","netserveroptions()","netserveroptions().","netserveroptions().setlogactivity(true);","netserveroptions().setport(1234).sethost(\"localhost\")","netserveroptions().setport(4321);","netserveroptions().setssl(true).setkeystoreoptions(","netserveroptions().setssl(true).setpemkeycertoptions(","netserveroptions().setssl(true).setpfxkeycertoptions(","netserveroptions。","netsocket","netsocket,","netsocket、http","netsocket：","netti","netty不依赖于外部日志配置（例如系统属性），而是根据netty类可见的日志记录库来实现日志记录：","netty日志记录","never","new","new_customer(?,","news.europe,","news.uk.sport","news.usa,","next","next)：当前","next，则下一个匹配的","no.","no_error(0)","no_error(0)错误代码，可发送另一个代码：","no_salt：密码就不会执行加密以明文的方式存储。","node.j","node:","nodej","nodes\");","noerror","non_loopback:挑选任何非回送地址","none","notfound","notimpl","notzon","now","npm","nslookup","null","null)","null,","null,\"","null;","null。","null（意味着不需要授权）","null，且","num","number","number,","nxdomain","nxrrset","o)","o2","oauth","oauth2","oauth2.addauthority(\"profile\");","oauth2.api(httpmethod.get,","oauth2.authorizeurl(new","oauth2.gettoken(new","oauth2.gettoken(tokenconfig,","oauth2.setupcallback(router.get(\"/callback\"));","oauth2.setupcallback(router.route());","oauth2/java/","oauth2:3.2.1","oauth2auth","oauth2auth.create(vertx,","oauth2authhandl","oauth2authhandler.create(authprovider,","oauth2authhandler.create(provider,","oauth2clientoptions()","oauth2flowtype.auth_code,","oauth2flowtype.client,","oauth2flowtype.password);","ob","obj","obj.dosomethingthattakestime(r","object","object,","object.put(\"foo\",","objectid","objectid().tohexstring();","objectid::getdate()","objectmapper#convertvalue()","object），该方法会自动调用","observ","observable#tim","observable.","observable.foreach(","observable.foreach(data","observable.interval(100,","observable.lift(io.vertx.rxjava.core.rxhelper.unmarshaller(mypojo.class)).subscribe(","observable.lift(rxhelper.unmarshaller(mypojo.class)).subscribe(","observable.subscribe(","observable.subscribe(id","observable.subscribe(msg","observable.subscribe(rxhelper.tosubscriber(handler1));","observable.timer(100,","observable.tohandler());","observable>","observable>：","observablefutur","observablehandl","observable。","observable，即不管是否有订阅，它们都会产生通知。","observable：","observer()","observer：观察者","oc","occurred:","offset","offset)","offset);","offset)。","offset,","offset=\"","offset=\"+offset.getoffset()+","offset=\"+offsetandtimestamp.getoffset()+","offsetandtimestamp","offsetsfortimes，调用此api可以返回大于等于给定时间戳的","offsettimestamp=\"+offset.gettimestamp()));","offsettimestamp=\"+offsetandtimestamp.gettimestamp());","offset。因为","offset：偏移量","offset：读取数据将被放到","oh","ok","ok!","ok!\");","ok\"));","ok\");","ok。","old","on","onc","once、at","once。不同语义情况下要考虑的情况不同。","oncomplet","oncomplete);","oncompleted()","one_hour_ago()","onerror","onerror(throw","onerror);","onerror,","onnext","onnext(httpserv","onnext(long","onopen","open","opened\");","openjdk","openopt","openoptions());","openoptions(),","openoptions();","openshift","openshift3","openshift_kube_ping_namespac","openssl","opensslengineopt","opensslengineoptions());","openssl中alpn可用时使用","openssl提供了原生的alpn支持。","openssl提供比jdk引擎更好的性能和cpu使用率、以及jdk版本独立性。","openssl支持","openssl需要配置","oper","operator：操作符","opt","option","option\"))","option\"));","option\");","option()","option().setlongname(\"help\").setshortname(\"h\").setflag(true).sethelp(true))","option().setlongname(\"mandatory\").setrequired(true));","options);","options,","options.addheader(\"som","options.setisolatedclasses(arrays.aslist(\"com.mycompany.myverticle.*\",","options.setkeepalive(false);","options上使用path设置客户端受信存储位置。如果服务器在连接期间提供不在客户端受信存储中的证书，则尝试连接将不会成功。","options上的功能路径设置客户端密钥库位置。","options：配置项，作为参数时候翻译成选项","opts来配置jvm（","opts配置调试器。每次重新部署后，请勿忘记重新插入(r","opts：java虚拟机选项，若未设置，则使用java_opts环境变量","order","order_worker.rb","org.acme.myverticl","org.apache.ignite.level=info","org.apache.maven.plugin","org.jboss.logging.provid","org.jgroups.kubernet","org.jgroups.level=info","org.junit.after;","org.junit.before;","org.junit.runner.runwith;","org.junit.test;","origin","origin）","os:","osgi","other_table\",","otherkeyname:","otherpublisher.subscribe(rrs);","otherscore:","out","out)）：","out_of_service：服务目前不可用，但是过段时间会继续提供服务。","outboundpermitted1","outboundpermitted2","output","output).start();","output：重定向生成的进程输出和错误流到父进程流","overloading：重载","over：故障转移","p","packag","package\"","package命令打包。","package命令打包，随后在src的同级目录下会出现target目录，进入之后，会出现vert","packet","page","param","param\",","param0","param1","param1:","param1=abc¶m2=xyz","param2:","paramet","params,","parser","parser.handle(buffer.buffer(\"\\n\"));","parser.handle(buffer.buffer(\"do","parser.handle(buffer.buffer(\"hello\\nhow","parser.handle(buffer.buffer(\"ou?\\ni","parser）允许您轻松解析由字节序列或固定尺寸带分隔符的记录的协议。","parse解析方法返回包含值的commandline对象。默认情况下，它验证用户命令行，并检查每个必填选项和参数的设置以及每个选项接收的值的数量。您可以通过传递","part","part/form","partit","partition)","partition=\"","partition=\"+","partition=\"+topic.getpartition()+\"\\n\"+","partition=\"+topicpartition.getpartition()+\"\\n\"+","partitioninfo","partitions)","partitionsassignedhandl","partitionsfor","partitionsrevokedhandl","partition。","partition。如果某个消费者并不属于任何消费组，那么整个程序就不能依赖","partition。它是","partition。您可以通过","partition，同时此消费组也可以接纳其他的消费者，这样可以实现","partition，所以我们可以保证所有的消息被发送到同样的","partition：分区（kafka中的设计）","password","password:","password：todo","patch","path","path/to/dir/conf/cluster_xml","path（本地路径）","pattern","paus","pause，resume，writequeueful","pause：暂停处理器，暂停时，处理器中将不会受到任何项","payload","payload\"","payload);","pebbl","pebble:3.4.0","pebble：io.vertx:vertx","peer","pem","pemkeycertopt","pemkeycertoptions().","pemopt","pemtrustoptions().","peopl","people\",","per","period","period\",","periodicstream","period：停止应用程序后等待的时间（在启动用户命令之前）。这个在windows上非常有用，因为这个进程并没立即被杀死。时间以毫秒为单位，默认20m","period：在2次重新部署之间等待的时间（以毫秒为单位），默认为1000m","period：文件系统检查周期（以毫秒为单位），默认为250m","permission/role模型","permissions：权限","permission：","permission：许可","permittedopt","permittedoptions().setaddress(\"demo.ordermgr\");","permittedoptions().setaddress(\"demo.orderservice\");","permittedoptions().setaddress(\"demo.persistor\")","permittedoptions().setaddress(\"demo.someservice\");","permittedoptions().setaddress(\"ticker.mystock\");","permittedoptions().setaddressregex(\"news\\\\..+\");","permittedoptions().setmatch(new","persist","personconverter())","pfxoption","pfxoptions().","ping","pipe","pipe：管道","pkcs＃12格式的密钥/证书（http://en.wikipedia.org/wiki/pkcs_12，通常为.pfx或.p12扩展名）也可以用与jks密钥存储相似的方式加载：","play_golf,say_buzzword","plug)调试器，因为它每次都会创建一个新进程。","plugin","plugin:","plugin和maven","plugin插件的manifestentries的main","plugin，前者用来将.java的源文件编译成.class的字节码文件，后者可将编译后的.class字节码文件打包成可执行的jar文件，俗称fat","po","pojo","polici","pom.xml","pom.xml文件中):","pom.xml文件中）：","pool","pool\"));","pool\");","pool\",","poolsiz","poolsize,","pool。当所有的","pool）创建调度器也是可以的，如果你想为了调度阻塞操作复用特定的线程池，这将会很有帮助：","pool：事件轮询线程池，大部分地方未翻译","pool：工作者线程池，大部分地方未翻译","port","port:","port参数。","port：若指定了cluster选项，则可以确定哪个端口将用于与其他vert.x实例进行集群通信。默认为0——这意味着“选择一个空闲的随机端口”。除非您帧需要绑定特定端口，您通常不需要指定此参数。","position：一个整数指定在文件中写入缓冲的位置，若位置大于或等于文件大小，文件将被扩展以适应偏移的位置","position：从文件中读取数据的位置","post","postgr","postgresql","postgresqlcli","postgresqlclient.createnonshared(vertx,","postgresqlclient.createshar","postgresqlclient.createshared(vertx,","postgresqlclientconfig","postgresqlclientconfig);","postgresqlclientconfig,","postgress","pox.xml","predicate，即判断函数）","preferredlocal","pressure：背压机制","pretti","previou","pri*http/2.0\\r\\nsm\\r\\n","primit","primitive：基本（描述类型）","principal：凭证","printed\");","privat","prng","probabl","process","process_id:","processor","processor）会在编译期生成这些类。这是java编译器的一个特性，所以不需要额外的步骤，只需要去配置一下对应的构建配置：","prod.jar","prod.jar两个jar文件，后者是可执行文件，在有图形界面的操作系统中，您可双击执行，或者用以下命令：java","prod.jar执行。","produc","producer\",","producer.close(r","producer.partitionsfor(\"test\",","producer.write(record);","producer.write(record,","producer1","producer1.close();","producer:","producerrecord","producer。您可以通过","producer，那么当对应","producer：","productid","producttyp","program","project","projecthelp）","project）。","promis","properti","properties();","properties,","protect","protocol","provid","provider.generatetoken(new","provider_class","provider。例如一些支持角色/权限的模型，另一些可能是其他的模型。","provider。完整的","provider则需要创建一个类实现authprovider接口。","provider的认证示例实现代码：","provider，则可以按照文档中的内容实施。","provider：提供者","proxi","proxy\")","proxy:3.4.1'","proxy:3.4.1:processor\"","proxy:processor","proxyhelp","proxyhelper.createproxy(somedatabaseservice.class,","proxyhelper.registerservice(somedatabaseservice.class,","proxyhelper.unregisterservic","proxyhelper.unregisterservice(consumer);","proxyopt","proxyoptions().settype(proxytype.http)","proxyoptions().settype(proxytype.socks5)","proxy组件，请先加入以下依赖：","proxy）的目的。它允许你在ev","proxy），这样你的服务调用端就可以使用一个相当符合习惯的api（译者注：即相同的服务接口）进行服务调用，而不是去手动地向ev","proxy）：一个编译时产生的代理类，用","proxy：已重新翻译","pub/sub","public","public（或者有","publish","publishedrecord","publisher(n.)：发布者","pug。","pump","pump.pump(file,","pump.pump(readstream,","pump.pump(request,","pump.pump(rrs,","pump.pump(sock,","pump.start();","pump，所以即使","pump：泵（平滑流式数据读入内存的机制，防止一次性将大量数据读入内存导致内存溢出）","push","push)是","pushedrequest.handler(pushedrespons","pushedrequest.path());","pushedrequest.reset();","pushedrespons","pushedresponse.","put","puthead","putheader(\"cont","puttrail","q","q)","q):default","q=0.7,","q=0.9,","qualifi","qualiti","quasar","queri","queries）。此方法接受含参数占位符的sql查询语句以及","query,","querytimeout","querywithparam","quora","quora。","quora（多数派机制）。quorum","quorum","quorum（法定人数）。","quorum，例如：","quorum：该参数需要和","quux\",","r","r,","r.","r.getname().equals(\"som","r4.2+环境中使用，如","r]","rang","rawmessag","rawmessage.put(\"headers\",","rc","rc.acceptablelanguages())","rc.fail(ar.cause());","rc.preferredlocale());","rc.response().end(\"bonjour!\");","rc.response().end(\"hello!\");","rc.response().end(\"hola!\");","rc.response().end(\"olá!\");","rc.response().end(\"sorri","rc.response().end(\"welcom","rc.response().end();","rc.response().end(tojson(ar.result()));","rc.response().end(toxml(ar.result()));","rc.response().putheader(\"cont","rc.response().write(productjson);","rc.user().principal().getstring(\"somekey\");","rc.user().principal().getstring(\"sub\");","re","reach","reactiv","reactivereadstream","reactivereadstream.readstream();","reactivewritestream","reactivewritestream.writestream(vertx);","reactive：","reactive：已翻译校对完成","reactor","reactor即多反应器","reactor：反应器，multi","read","readabl","readfil","readi","readstream","readstream中一样读取数据（例如使用一个","readstream（例如","readstream（可读流）","readstream）：","real","realm","realm);","realm从一个ldap服务器上获取","realm对象创建一个auth提供者的示例是可以的。","realm里。","realm：","receiv","receivebuffers","received,","received.body().getjsonobject(\"value\");","received1","received1.body());","received:","receiver/recipient：接收者","reconfiguration)","reconstitutedbase64encodedstr","reconstitutedbinaryobject","reconstitutedindividualid","record","record()","record.key()","record.name();","record.offset());","record.partition()","record.port();","record.priority();","record.protocol();","record.service();","record.target();","record.value()","record.value())","record.weight();","record1","record2","record:","recordmetadata","recordmetadata.getoffset());","recordmetadata.getpartition()","recordmetadata.gettopic()","recordpars","recordparser.newdelimited(\"\\n\",","recordparser.newfixed(4,","records)","record。目前桥接器只支持将服务从kubernetes中导入到vert.x中（反过来不行）。","record，您可以使用原生的","record：","redeploy","redeploy\"选项指定在应用程序关闭后和重新启动之前调用的命令。因此，如果更新某些运行时工作，则可以钩住构建工具。例如，您可以启动gulp或grunt来更新您的资源。","redeploy=\"**/*.class\"","redeploy=\"**/*.groovy\"","redeploy=\"**/*.groovy,**/*.rb\"","redeploy=\"**/*.java\"","redeploy=\"mvn","redeploy=\"src/**/*.java\"","redeploy='./gradlew","redeploy=**/*.class","redeploy=**/*.java","redi","redirect","redirectauthhandl","redirectauthhandler.create(authprovider);","redis.get(\"mykey\",","redis.publish(\"channel1\",","redis.subscribe(\"channel1\",","redis:3.4.1'","redis_git_dirty:","redis_git_sha1:","redis_version:","rediscli","redisclient.create(vertx,","redisclient。","redisclient，你需要同时提供：服务记录位置信息、元数据以及服务消费者提供的json对象：","redisdatasourc","redisdatasource.createrecord(","redisdatasource.getredisclient(discovery,","redisopt","redisoptions()","redisoptions());","redis存储后端是基于","redis数据源服务，服务对象的类型是一个redisclient（该client的配置参数，将从location、元数据和服务消费者传递的参数中获取）","refer","reference.get();","reference.getas(httpclient.class);","reference.getas(jdbcclient.class);","reference.getas(messageconsumer.class);","reference.getas(myservice.class);","reference.getas(redisclient.class);","reference.getas(webclient.class);","reference.release();","reference1","reference1.getas(httpclient.class);","reference1.release();","reference2","reference2.getas(messageconsumer.class);","reference2.release();","referral：todo","refresh_token","refus","regist","registerserviceimport","registerverticlefactori","registr","reject","rejectandclos","releas","remot","remoteaddress","remotesettingshandler：","remote（远程）仓库名称（默认读取","remov","removecooki","removed,","removedocu","render","replac","replace,","repli","replicaset","replied\");","reply.body());","reply:","repositori","repository)的","req.response()","req.response().end(\"blah\");","req.response().end(\"hello!\"))","req.response().end();//要关闭请求，否则连接很快会被占满","req.response().end(“”+i);","request","request\");","request);","request)。","request.","request.addqueryparam(\"param1\",","request.addqueryparam(\"param3\",","request.bodyhandler(bodi","request.bodyhandler(buff","request.bodyhandler(totalbuff","request.connection();","request.connectionhandler(connect","request.continuehandler(v","request.customframehandler(fram","request.end(\"som","request.end());","request.end();","request.end(buffer);","request.endhandler(v","request.exceptionhandler(","request.exceptionhandler(err","request.formattributes();","request.handler(buff","request.handler(respons","request.headers();","request.path();","request.pushhandler(pushedrequest","request.putheader(\"cont","request.putheader(\"expect\",","request.putheader(\"oth","request.reset();","request.reset(8);","request.response()","request.response().end(\"hello","request.response().end();","request.response().exceptionhandler(err","request.response().putheader(\"cont","request.response().reset();","request.response().reset(8);","request.response().sendfile(\"web/\"","request.response().sendfile(\"web/mybigfile.txt\",","request.response().setstatuscode(400).end();","request.response().writecontinue();","request.response();","request.setchunked(true);","request.setexpectmultipart(true);","request.setqueryparam(\"param2\",","request.toobservable().","request.toobservable().subscribe(","request.toobservable();","request.upgrade();","request.uploadhandler(upload","request.uri(\"/som","request.write(\"som","request.write(body);","request.write(buffer);","request.writecustomframe(frametype,","requestabs：","requesthandler：","requestobserv","requestobservable.subscribe(request","requestopt","requestoptions()","requeststream","requests（http请求）：","request。这些方法都不会立即发送请求，而是返回一个","request，允许您在运行时指定","requir","rerout","res.cause()","res.cause());","res.cause().getmessage());","res.cause().printstacktrace();","res.result()","res.result())","res.result());","res.result().encodeprettily());","res.result().getjsonarray(\"result\");","res.result();","res.successed()","res1","res2","res2.cause().printstacktrace();","res2.result().getjsonarray(0));","res2.result().getjsonobject(\"binarystuff\").getbinary(\"$binary\");","res2.result().getjsonobject(\"binarystuff\").getstring(\"$binary\");","res2.result().getjsonobject(\"individualid\").getstring(\"$oid\");","res2.result().getjsonobject(\"publicationdate\").getstring(\"$date\"));","res2.result().getstring(\"title\"));","res2.result();","resarr","research\");","reset","reset.getcode());","resget","resget.result();","resolv","resolvea","resolveaaaa","resolvecnam","resolvemx","resolven","resolveptr","resolvesrv","resolvetxt","resolveuri(response.request().absoluteuri(),","resourc","resource!\");","resp","resp.bodyhandler(bodi","respons","response).start();","response);","response.body();","response.bodyasjsonobject();","response.bodyhandler(totalbuff","response.customframehandler(fram","response.end(\"hello","response.end());","response.end();","response.endhandler(v","response.getheader(\"location\")","response.getheader(\"location\"));","response.handler(bodi","response.handler(buff","response.headers().get(\"cont","response.headers();","response.push(httpmethod.get,","response.putheader(\"cont","response.putheader(\"location\",","response.puttrailer(\"x","response.sendfile(\"\");","response.setchunked(true);","response.setstatuscode(400).end();","response.setstatuscode(statuscode).end(\"sorry!","response.statuscode()","response.statuscode());","response.statusmessage());","response.toobservable();","response.trailers();","response.write(\"hello","response.write(\"route1\\n\");","response.write(\"route2\\n\");","response.write(\"route3\");","response.write(\"som","response.write(buffer);","response.write(somejson).end();","response.write(whatever).end();","response.writecustomframe(frametype,","responsecontenttypehandl","response，您可使用任意一个","resput","rest","restapi","restapi);","restapi.delete(\"/products/:productid\").handler(rc","restapi.get(\"/products/:productid\").handler(rc","restapi.put(\"/products/:productid\").handler(rc","result","result);","result.cause());","result.cause().getmessage())","result.cause().getmessage()));","result.cause();","result.getkeys());","result.getupdated());","result.result())","result.result();","result:","result;","resulthandler)","resulthandler);","resulthandler.handle(future.succeededfuture(mydbconnection));","resulthandler.handle(future.succeededfuture(result.result()));","resulthandler.handle(serviceexception.fail(bad_shoe_size,","resulthandler.handle(serviceexception.fail(connection_failed,","resulthandler.handle(shoesizeexception.fail(shoesize));","results)","results.foreach((topic,","resultset","resultset.getcolumnnames();","resultset.getresults();","resultset.getrows();","resultset，此时，返回的结果集会被转成纯","resulttyp","resum","resume：恢复处理器，若任何项到达则处理器将被调用","resumi","retriev","retriever,","retriever.configstream()","retriever.getcachedconfig();","retriever.getconfig(ar","retriever.getconfig(json","retriever.listen(chang","retriever，只需要在依赖中增加以下代码片段：","return","return;","reus","reverselookup","revok","revoked\");","revoked.\");","rfc6750","rfc定义的。","rfc建议推荐值为100","rings\").put(\"author\",","robin)的方式发送到对应","robin：轮询","role","role.administr","role.develop","role.manag","role.{rolename}={permissionname1},{permissionname2},...,{permissionnamen}","role：角色","rollback","root","round","rout","route.failurehandler(frc","route.failurehandler。","route.handler(routingcontext","route.pathregex(\"\\\\/([^\\\\/]+)\\\\/([^\\\\/]+)\").handler(routingcontext","route1","route1.handler(routingcontext","route2","route2.handler(routingcontext","route2.order(","route3","route3.failurehandler(failureroutingcontext","route:","router","router.get(\"/\").handler(ctx","router.get(\"/api/books\").produces(\"application/json\").handler(rc","router.get(\"/api/books\").produces(\"text/xml\").produces(\"application/json\").handler(rc","router.get(\"/dynamic\").handler(routingcontext","router.get(\"/dynamic/\").handler(handler);","router.get(\"/dynamic/*\").handler(handler);","router.get(\"/hystrix","router.get(\"/localized\").handler(","router.get(\"/mi","router.get(\"/some/path\").handler(routingcontext","router.get(\"/some/path/\").handler(routingcontext","router.get(\"/some/path/*\").handler(routingcontext","router.get(\"/some/path/b\").handler(routingcontext","router.get(\"/some/path/other\").handler(routingcontext","router.get(\"/somepath/*\");","router.get(\"/somepath/path1/\");","router.get(\"/somepath/path2\");","router.get().failurehandler(ctx","router.get().handler(routingcontext","router.getwithregex(\".*foo\").handler(routingcontext","router.getwithregex(\".+\\\\.hbs\").handler(handler);","router.post(\"/login\").handler(formloginhandler.create(authprovider));","router.post(\"/some/endpoint\").handler(ctx","router.post(\"/some/path/uploads\").handler(routingcontext","router.route(\"/\").handler(ctx","router.route(\"/api/*\").handler(responsecontenttypehandler.create());","router.route(\"/eventbus\").handler(sockjshandler);","router.route(\"/eventbus/*\").handler(basicauthhandler);","router.route(\"/eventbus/*\").handler(sockjshandler);","router.route(\"/foo/\").handler(timeouthandler.create(5000));","router.route(\"/listproducts/*\").handler(listproductsauthhandler);","router.route(\"/login\").handler(ctx","router.route(\"/myapp/*\").handler(sockjshandler);","router.route(\"/private/*\").handler(basicauthhandler);","router.route(\"/private/*\").handler(redirectauthhandler);","router.route(\"/private/settings/*\").handler(settingsauthhandler);","router.route(\"/private/somepath\").handler(routingcontext","router.route(\"/protected/*\").handler(jwtauthhandler.create(authprovider));","router.route(\"/protected/*\").handler(oauth2);","router.route(\"/protected/somepage\").handler(ctx","router.route(\"/protected/somepage\").handler(rc","router.route(\"/some/path/\").handler(routingcontext","router.route(\"/some/path/*\");","router.route(\"/someotherpath\").handler(routingcontext","router.route(\"/somepath/blah\").handler(routingcontext","router.route(\"/somepath/blah/\").handler(routingcontext","router.route(\"/static/*\").handler(statichandler.create());","router.route(\"some/path/\").handler(routingcontext","router.route()","router.route().blockinghandler(routingcontext","router.route().consumes(\"*/json\").handler(routingcontext","router.route().consumes(\"text/*\").handler(routingcontext","router.route().consumes(\"text/html\").consumes(\"text/plain\").handler(routingcontext","router.route().consumes(\"text/html\").handler(routingcontext","router.route().handler(bodyhandler.create());","router.route().handler(cookiehandler.create());","router.route().handler(corshandler.create(\"vertx\\\\.io\").allowedmethod(httpmethod.get));","router.route().handler(csrfhandler.create(\"abracadabra\"));","router.route().handler(rc","router.route().handler(routingcontext","router.route().handler(sessionhandler);","router.route().handler(sessionhandler.create(localsessionstore.create(vertx)));","router.route().handler(statichandler.create());","router.route().handler(usersessionhandler.create(authprovider));","router.route().handler(virtualhosthandler.create(\"*.vertx.io\",","router.route().method(httpmethod.post).method(httpmethod.put);","router.route().method(httpmethod.post);","router.route().path(\"/some/path/\");","router.route().path(\"/some/path/*\");","router.route().pathregex(\".*foo\");","router.route().produces(\"application/json\").handler(routingcontext","router.route().produces(\"application/json\").produces(\"text/html\").handler(routingcontext","router.route(httpmethod.post,","router.route(httpmethod.put,","router.router(vertx);","router.routewithregex(\".*foo\");","router。","router。因此，您可以包含若干级别的","router。在这之后，我们创建了一个没有匹配条件的","router。这也有利于您在多个不用的应用中通过设置不同的根路径来复用处理器。","router）。sub","router，那么例如","router：","router：路由器","route。","route。停用的","route。您可以使用正则表达式来实现，但更简单的方式是在声明","route的流程。","route，并且","route，并且会接收到参数","route，然后将请求传递给这个","route，这个","route：路由","routingcontext","routingcontext.addcookie(cookie.cookie(\"othercookie\",","routingcontext.fail(403);","routingcontext.fileuploads();","routingcontext.get(\"foo\");","routingcontext.getacceptablecontenttype();","routingcontext.getcookie(\"mycookie\");","routingcontext.next());","routingcontext.next();","routingcontext.put(\"foo\",","routingcontext.put(\"request_path\",","routingcontext.put(\"session_data\",","routingcontext.request().getparam(\"param0\");","routingcontext.request().getparam(\"param1\");","routingcontext.request().getparam(\"productid\");","routingcontext.request().getparam(\"producttype\");","routingcontext.request().path());","routingcontext.reroute(\"/some/path/b\");","routingcontext.response().end();","routingcontext.response();","routingcontext.session().data());","routingcontext.session();","routingcontext.user()","routingcontext.vertx().settimer(5000,","routingcontext，这个实例会被传递到所有处理这个请求的处理器上。","row","row...","row.getinteger(\"shoe_size\");","row.getinteger(3);","row.getstring(\"fname\");","row.getstring(\"id\");","row.getstring(\"lname\");","row.getstring(0);","row.getstring(1);","row.getstring(2);","row_stream_fetch_s","rows)","rows:","rr","rrset不存在","rs","rs.getnext();","rs256","rs384","rs512","rsa","rsassa","rubi","run","run()","runcommand","runnable,","runoncontext","runtimeexcept","runtimeexception(\"someth","run命令可以使用几个可选参数，它们是：","rw","rws);","rws.subscribe(othersubscriber);","rx","rx*","rx.observ","rx.observable.oper","rx.observable.operator（rx","rx.observable：","rx.schedul","rxfifi","rxhelper","rxhelper.blockingschedul","rxhelper.blockingscheduler(vertx);","rxhelper.deployverticl","rxhelper.deployverticle(vertx,","rxhelper.get","rxhelper.get(client,","rxhelper.observablefutur","rxhelper.observablefuture();","rxhelper.observablehandler();","rxhelper.schedul","rxhelper.scheduler(vertx);","rxhelper.schedulerhook","rxhelper.schedulerhook(vertx);","rxhelper.tofuture(observer);","rxhelper.tofuture(onnext);","rxhelper.tofuture(onnext,","rxhelper.tohandl","rxhelper.toobserv","rxhelper.toobservable(file);","rxhelper.toreadstream","rxhelper.toreadstream(observable);","rxhelper.unmarshal","rxifi","rxified：rx化","rxjava","rxjavahooks.setoncomputationscheduler(f","rxjavahooks.setonioscheduler(f","rxjavahooks.setonnewthreadscheduler(f","rxjavaschedulershook","rxjava的","rx化的","rx化的辅助类也能做同样的事：","s3","s3_ping","safe/线程安全的，verticle之间传递的数据是immutable/不可改变的。","salesforc","salesforceauth","same","samples.","save","save(str","scala","scan","schedul","scheduler);","scheduler。rxhelp","score","score:","script","sd","sd.getclusterwidemap(\"mymap\",","sd.getcounter(\"mycounter\",","sd.getlocalmap(\"mymap1\");","sd.getlocalmap(\"mymap2\");","sd.getlock(\"mylock\",","sd.getlockwithtimeout(\"mylock\",","second","second\");","second)","secret","secret\")","section","see","seek","seektobegin","seektoend","select","selfsignedcertif","selfsignedcertificate.create();","send","send('address1',","send('address2',","send('address3',","sendbuff","sendbuffers","sender()：表示数据报发送方的inetsocketaddress","sender.j","sender：发送者","sender：表示数据发送方的inetsocketaddress。","sendfil","sendform","sendhead","sendjson","sendjsonobject","sendstream","sendstream：","sendxxx","sensor\").","sent/published/registered/unregist","sequences：可观察序列","serial","server","server\")","server\");","server.actualport());","server.close(r","server.com\")","server.connecthandler(sock","server.connecthandler(socket","server.connectionhandler(connect","server.j","server.listen();","server.listen(0,","server.listen(1234,","server.listen(8080);","server.listen(8080,","server.requesthandler(request","server.requesthandler(router::accept).listen(8080);","server.requeststream().toobservable();","server.websockethandler(websocket","server.websocketstream().toobservable();","server:","server:3.4.1'","serveropt","serverselectiontimeoutm","serverwebsocket","server可配置成接收到","server）得到访问令牌；","server）通过重定向发送过来的请求。","server：服务器","servfail","servic","service\"","service\")","service\"),","service\",","service);","service,","service,foo","service,org.widgets.widget","service,那么他的服务描述符文件为：`com.mycompany.clev","service.createconnection(\"8\",","service.dosomethingthatblocks();","service.json","service.save(\"mycollection\",","service.typ","service.type.l","service2","service:com.mycompani","service:com.mycompany:myorderservic","service_address);","servicediscoveri","servicediscovery.create(vertx)","servicediscovery.create(vertx);","servicediscovery.create(vertx,","servicediscovery.releaseserviceobject","servicediscovery.releaseserviceobject(discovery,","servicediscoverybackend","servicediscoveryopt","servicediscoveryoptions()","serviceexcept","serviceexception)","serviceexception.fail","serviceimport","servicerefer","servicereference）并且使用这个服务","servicetyp","serviceverticlefactory());","service：微服务","session","session.get(\"age\");","session.put(\"foo\",","session.remove(\"myobj\");","sessionhandl","sessionhandler.create(store);","sessionstor","sessiontimeout","set","set...","setaccess","setaddress","setaddressregex","setaddressresolveroptions(","setarg(str","setauthenticationqueri","setautocommit","setbodylimit","setbroadcast设置或清除so_broadcast套接字选项，设置此选项时，数据报（udp）数据包可能会发送到本地接口的广播地址。","setcacheentrytimeout","setcachingen","setcertpath(\"/path/to/your/cli","setcertpath(\"/path/to/your/serv","setcertvalue(mycertasabuffer);","setchunck","setclientauth(clientauth.required).","setclustered、getclusterhost和","setclusterhost","setclustermanag","setcollectionnam","setcompressionlevel","setcompressionsupport","setconfig","setcreatenew","setdecompressionsupport","setdeleteonclos","setdirectorylist","setdirectorytempl","setdsync","setexpectmultipart(true)","setexpectmultipart(true)。","setextraclasspath","setfilesreadonli","setflag","setflag(boolean","sethandle100continueautomat","sethidden","sethost(\"localhost\")","sethostnameverificationalgorithm(\"https\");","sethostspath(\"/path/to/hosts\"))","sethost）","sethttp2cleartextupgrad","sethttp2maxpoolsize(3);","sethttp2multiplexinglimit","sethttp2multiplexinglimit(10).","setincludehidden","setindexpag","setinitialset","setisolatedclass","setjdksslengineoptions(new","setkeepal","setkeypath(\"/path/to/your/cli","setkeypath(\"/path/to/your/serv","setkeystoreoptions(jksoptions);","setkeystoreoptions(keystoreoptions).","setkeystoreoptions(keystoreoptions);","setkeyvalue(mykeyasabuffer).","setmatch","setmaxagesecond","setmaxcaches","setmaxpools","setmaxredirect","setmaxretries。如果将其设置为高于0的值，则您的代码在最终失败之前进行尝试多次执行。如果代码在其中一个重试中成功，则处理程序将得到通知，并且跳过剩余的重试。此配置仅当熔断器未生效时工作。","setmergeformattribut","setmulticastnetworkinterface设置或清除ip_multicast_loop套接字选项，设置此选项时，多播数据包也将在本地接口上接收。","setmulticasttimetolive设置ip_multicast_ttl套接字选项。ttl表示“活动时间”，单这种情况下，它指定允许数据包经过的ip跳数，特别是用于多播流量。转发数据包的每个路由器或网管会递减ttl，如果路由器将ttl递减为0，则不会再转发。","setmultivalu","setname(str","setndot","setnotificationaddress","setopensslengineopt","setopensslengineoptions(new","setpassword(\"password","setpasswordcredentialfield","setpasswordfield","setpath(\"/path/to/your/cli","setpath(\"/path/to/your/serv","setpath(\"/path/to/your/truststore.jks\").","setpath(\"/path/to/your/truststore.pfx\").","setpemkeycertoptions(pemoptions);","setpemtrustoptions(","setperiod","setperm","setpermissionfield","setpermissionqueri","setpfxkeycertoptions(pfxoptions);","setpfxtrustoptions(","setpipelininglimit","setport(1234).","setprotocolvers","setprotocolversion(httpversion.http_2).","setrawmethod","setread、setwrit","setreceivebuffersize设置tcp接收缓冲区大小（以字节为单位）。","setreconnectattempt","setreconnectattempts(10).","setreconnectinterv","setreconnectinterval(500);","setrequiredauthor","setreuseaddress若为true，则time_wait状态中的地址在关闭后可重用。","setrolefield","setrolesqueri","setrotateserv","sets)，所以通常被用做结构化数据存储服务器。要使用本组件，您必须有一个运行中的","setsendbuffersize以字节为单位设置发送缓冲区的大小。","setssl","setssl(true).","setssl(true)。","setstatuscod","setstatusmessag","setter","settim","settimeout设置一个特定","settings\");","settings.gradl","settings_max_concurrent_stream","settingsauthhandl","settingsauthhandler.addauthority(\"role:admin\");","settrafficclass","settruncateexist","settrustall(true);","settruststoreoptions(","settruststoreoptions(trustoptions).","settryusecompress","setunsignedxxx","setup(testcontext","setupcallback","setusealpn","setusealpn(true).","setusernamecredentialfield","setusernamefield","setvalue(mykeystoreasabuffer).","setvalue(mytruststoreasabuffer).","setwebroot","setwork","setworkerpools","setwritequeuemaxs","setwritequeuemaxsize：与","setwritequeuemaxsize：设置写入队列被认为是","setxxx","sever","severe:","se又称cor","sha","sha1prng","sha256\").","sha256withecdsa","sha256withrsa","sha384\").","sha384\");","sha384withecdsa","sha384withrsa","sha512withecdsa","sha512withrsa","shade","shadowjar'","share","shareddata","sharing）是一个安全机制。该机制允许了浏览器在一个域名下访问另一个域名的资源。","shell","shell中使用。","shiro","shiro/java/mongodb","shiro:3.2.1'","shiroauth.create(vertx,","shiroauthrealmtype.properties,","shiro从一个配置文件里获取","shiro的auth提供者的实现。","shoe","shoe_siz","shoesiz","shoesize)","shoesize));","shoesize);","shoesize,","shoesize;","shoesizeexcept","shoesizeexception(str","shoesizeexception)","shoesizeexceptionmessagecodec());","shopifi","shopifyauth","short","shutdown","shutdownhandl","shutdownhook。参考上述的","side","side\");","side）可以检查它接收到的失败状态的asyncresult包含的throwable对象是否为serviceexception实例。如果是的话，继续检查内部的特定的错误状态码。调用端可以通过这些信息来将业务逻辑错误与系统错误（如服务没有被注册到ev","sigalg","signint。","silentbalanceyh负责翻译，chengenzhao、kkkoko、gy、hxl、toyer、漓江校对","simpl","simplestart","simplestart将会使用gradle，而非maven来简化相关设置。","simplestart将会使用ide，也就是集成开发环境来简化开发流程；","sinatra","singl","single.","single.subscribe(resp","single.subscribe(respons","single.subscribe(rxhelper.tosubscriber(handler2));","single>","single>，故单个","site_loc","site_local:挑选一个本地（非路由）的ip地址，例如从192.168.0.0或10.0.0.0地址","size","size!\");","size:","skip","slf4j","slf4j:","slf4j。详见","slf4j启动警告","slice","small","snapshot","snapshot'","snapshot.jar和vert","snapshot.jar执行。","snapshot.jar，在有图形界面的操作系统中，您可双击执行，或者用以下命令：java","snapshot。通过这个方法来创建","sock","sock).start();","sock.close();","sock.drainhandler(don","sock.handler(buff","sock.onclos","sock.onmessag","sock.onopen","sock.pause();","sock.resume();","sock.send('test');","sock.write(buffer);","socket","socket.blockmulticastgroup(\"230.0.0.1\",","socket.closehandler(v","socket.handler(buff","socket.handler(packet","socket.listen(1234,","socket.listenmulticastgroup(\"230.0.0.1\",","socket.send(\"a","socket.send(buffer,","socket.toobservable();","socket.unlistenmulticastgroup(\"230.0.0.1\",","socket.write(\"hello!\").end())","socket.write(\"som","socket.write(buff);","socket.write(buffer);","socket_clos","socket_cr","socket_iddl","socket_idl","socket_p","socketobserv","socketobservable.subscribe(","sockettimeoutm","sockettimeoutms，","socket。","socket的连接被关闭","socket这边的地址，它将返回一个inetsocketaddress，否则返回null。","socket（so_keepalive）连接。默认为","socket）","socket，则不会给我们任何加密的机会。","socket：套接字","socket：套接字（有些地方未翻译，直接用的","sockj","sockjs('http://mydomain.com/myapp');","sockjshandl","sockjshandler.bridge(new","sockjshandler.bridge(options);","sockjshandler.bridge(options,","sockjshandler.cr","sockjshandler.create(vertx);","sockjshandler.create(vertx,","sockjshandler.sockethandler(sockjssocket","sockjshandleropt","sockjshandleroptions().setheartbeatinterval(2000);","sockjssocket","sockjssocket.handler(sockjssocket::write);","sockjs。","socks4","socks4a","socks5","some_table\",","someapi.blockingmethod(\"hello\");","somecommand","somecommand.execute();","somecooki","somecookie.getvalue();","somedata);","somedatabaseservic","somedatabaseservice.createproxy(vertx,","somedatabaseserviceimpl","somedatabaseserviceimpl();","somedatabaseserviceimpl(vertx","somedatabaseserviceimpl(vertx);","somedatabaseserviceimpl.bad_shoe_size)","somedatabaseserviceimpl.connection)","somedatabaseservicevertxebproxy(vertx,","somedatabaseservicevertxebproxy。","somedatabaseservice，则代理名就是","somejavasourcefile.java","somekey","someon","somescript.groovi","someth","something...","sort","soundcloud","soundcloudauth","sourc","source\")","sourcecompat","source使用手册","source）等等。","speak:","specif","spi","spi接口，可以自定义服务类型：","spi提供了一种可插拔的存储后端扩展机制。","spi，用来增加对新格式的支持","spi，用来增加对配置仓库（读取配置的位置）的支持","spring","sql","sqlconnect","sqlrowstream","sqlrowstream.moreresults();","sql语句传给数据库时，不会经过任何处理。操作结束时将调用回调方法。","src","src/main/resources/meta","srvrecord允许您访问srv记录本身中包含的所有信息：","ssl","ssl/tl","ssl/tls。默认是禁用的。","ssl/tls，该值设置成false将禁用ssl/tls。","ssl/tls，该值设置成true将启用ssl/tls，实际的客户端ssl/tls（如受信、密钥/证书、密码、alpn","ssl可以通过每个请求的","ssl引擎","stack","stack.json","stack.json，就会下载此客户端及它的依赖。","stack=","standard","stardand","start","start()","start(){","start(futur","startfutur","startfuture)","startfuture);","startfuture.complete();","startfuture.completer());","startfuture.fail(res.cause());","start等","start：启动泵。","state:","stateless","statement","statements），例如","state）。在这种状态下，允许下一次熔断器的调用实际调用如果成功，熔断器将复位并返回到关闭状态，回归正常的模式；但是如果这次调用失败，则熔断器返回到熔断状态，直到下次半开状态。","static","statichandl","statu","status:","statuscod","statusmessag","stay","step","step).","step），等待下一步的指示。","step，英国父母会在家里选择一个角落作为小孩罚站或静坐的地方，被称为","still","stomp","stop","stop()","stop(futur","stopfuture)","stopfuture.complete();","stopfuture.fail();","stop：停止泵，当泵启动时它要处于停止模式。","store","store1","store2","store3","storepass","storetyp","store：受信存储","store：配置仓库","straight","stream","stream().","stream(n.)：可写流","stream(n.)：可读流","stream.print(builder.tostring());","stream.result().handler(row","stream.result();","streamadaptor();","streamresetexcept","streamresetexception)","streams:3.4.1'","streamtofilesystem","stream：可写流","stream：可读流","string","string\");","string\",","string,","string.class);","string.class,","string.class.getname(),","string.valueof(key),","string/buff","stringbuild","stringbuilder();","stringdeserializer.class);","string、number、boolean","string是不可变的，所以不需要复制","stripe","stripeauth","stuff!\");","sub","sub.unsubscribe();","subscrib","subscribe(","subscribe(heat","subscribe(new","subscribe(v.)：注册","subscribed\");","subscriber()","subscriber(n.)：订阅者","subscriber，然后将其注册在","subscriber：订阅者","subscript","subscription(n.)：订阅","succeed","succeeded,","succeeded?","success","successfulli","sudo","suite：密码套件","summary.\")","super(bad_shoe_size_error,","super(hellocommand.class);","support","support\")","support），因此我们提供了两个类，以便在","switch","sync","sync.awaitev","sync.awaitresult","synchron","syncverticl","syspropsstor","system","system.err.println(\"access","system.err.println(\"cannot","system.err.println(\"fail","system.err.println(\"oh","system.err.println(\"woops:","system.getenv(\"home\");","system.getproperty(\"prop\");","system.out.println(\"a","system.out.println(\"and","system.out.println(\"begin","system.out.println(\"block","system.out.println(\"book","system.out.println(\"callback","system.out.println(\"circuit","system.out.println(\"clos","system.out.println(\"configuration:","system.out.println(\"connect","system.out.println(\"connected!\");","system.out.println(\"consum","system.out.println(\"context","system.out.println(\"copi","system.out.println(\"could","system.out.println(\"deploy","system.out.println(\"end","system.out.println(\"error","system.out.println(\"everyth","system.out.println(\"fail","system.out.println(\"failed:","system.out.println(\"fil","system.out.println(\"first","system.out.println(\"found","system.out.println(\"ful","system.out.println(\"gener","system.out.println(\"got","system.out.println(\"hello","system.out.println(\"i","system.out.println(\"insert","system.out.println(\"key=\"","system.out.println(\"last","system.out.println(\"listen","system.out.println(\"messag","system.out.println(\"nev","system.out.println(\"no.","system.out.println(\"offset","system.out.println(\"partit","system.out.println(\"paused\");","system.out.println(\"process","system.out.println(\"produc","system.out.println(\"read","system.out.println(\"receiv","system.out.println(\"registr","system.out.println(\"remot","system.out.println(\"sav","system.out.println(\"seek","system.out.println(\"send","system.out.println(\"serv","system.out.println(\"should","system.out.println(\"someth","system.out.println(\"statu","system.out.println(\"stream","system.out.println(\"subscribed\");","system.out.println(\"subscript","system.out.println(\"t","system.out.println(\"th","system.out.println(\"thi","system.out.println(\"tim","system.out.println(\"titl","system.out.println(\"to","system.out.println(\"token","system.out.println(\"top","system.out.println(\"tot","system.out.println(\"un","system.out.println(\"undeploy","system.out.println(\"unexpect","system.out.println(\"unlisten","system.out.println(\"upd","system.out.println(\"us","system.out.println(\"w","system.out.println(\"web","system.out.println(\"whi","system.out.println(\"written","system.out.println(ar.result());","system.out.println(asyncresult.cause());","system.out.println(asyncresult.result().body());","system.out.println(asyncresult2.result().body());","system.out.println(body.tostring(\"iso","system.out.println(buff.getunsignedbyte(pos));","system.out.println(buffer));","system.out.println(h.tostring());","system.out.println(i);","system.out.println(json.encodeprettily());","system.out.println(partitioninfo);","system.out.println(record);","system.out.println(resp.body());","system.out.println(resp.statuscode());","system.out.println(result.result());","system.out.println(topicpartition.gettopic()","system:serviceaccount:$(oc","systemerror(\"an","tabl","target","target/mi","targetcompat","task,","tcnativ","tcp","tcpdiscoverymulticastipfind","tcpdiscoverys3ipfind","tcpdiscoveryvmipfind","tcpkeepalive:","tcpnodelay:","tcpping","teardown(testcontext","templ","templat","templateengin","templatehandl","templatehandler.create(engine);","templatehandler。这个处理器会根据","template：这是用来决定实际的查找使用当通过一个特定的id来查找一个用户的时候。一个例子是uid={0},ou=users,dc=foo,dc=com","termin","test","test.git\")","testapplication(testcontext","testcompil","testdb。","text","text\").end();","text\");","text/html","text/html;q=0.8,","text/html。","text/html。这也是可以配置的。","text/html，但会更倾向于","text/html，因为其具有更高的","text/html，它需要提供","text/plain","text/plain,","text/plain;","thead.sleep()","then,","then...","thesubject","theverticl","this);","this.arg","this.flag","this.nam","this.shoes","thread","thread\");","thread,","threadedwork","thread：内核线程","throw","throwabl","thymeleaf","thymeleaf:3.4.1。通过这个方法来创建","thymeleaf：io.vertx:vertx","tid","time","time:","timeid","timeout","timeout:","timeouthandl","timeoutstream,","timeout）。","timer","timerid","timerstream","timer：定时器","timer：计时器","timestamp","timestamp)","timestamp);","timestamp,","timestamp=\"+timestamp+\",","timeunit.milliseconds,","timeunit.seconds).","title=","tl","tlsv1.2。","tls（传输层安全性协议）。早期版本的tls被称为ssl。","today\");","todo","todo展示了使用jwt的验证和授权的例子并解释了如何通过传入到授权的许可字符映射到jw令牌中的声明。","tohandl","tojson","token","token.principal().getstring(\"access_token\")),","token.refresh(r","token.revoke(\"access_token\",","token.revoke(\"refresh_token\",","tokenconfig","tokens实现auth。","token】）","token或oauth","token的实现还会在认证信息中包含令牌token信息。vert.x中的认证是异步执行，在调用过程中，认证结果被传给结果处理器中的用户user对象里，异步调用结果包含了一个用户user的实例，这个实例表述了已经认证过的用户信息，并且包含了这些用户允许执行的合法操作。","token（默认是使用/var/run/secrets/kubernetes.io/serviceaccount/token中的内容）","token）和刷新令牌（refresh","token），对安全性要求高的客户端（confidenti","token：","token：令牌","tolkien","tolkien\"));","tolkien\");","toobserv","toobservable().","toobservable();","tools，参数","topic","topic\");","topic\",","topic);","topic.getpartition()+\",","topic=\"","topic=\"+topic.gettopic()+","topic=\"+topic.gettopic()+\",","topic=\"+topicpartition.gettopic()+","topic=\"+topicpartition.gettopic()+\",","topicpartit","topicpartition()","topicpartition().settopic(\"test\").setpartition(0);","topicpartition.getpartition());","topicpartition.getpartition()+\",","topicpartitions)","topicpartitions.add(new","topicpartitions.add(topicpartition);","topicpartitionswithtimestamp","topicpartitionswithtimestamps.put(topicpartition,","topics.add(\"topic1\");","topics.add(\"topic2\");","topics.add(\"topic3\");","topic、目的分区","totalbuff","totalbuffer.appendbuffer(buffer);","totalbuffer.length());","trailer","trailers.set(\"x","trailers方法读取响应尾，尾数据也是一个","transact","transfer","transfer）。","translat","transport","transport，例如","tri","troopson@163.com，me.yan.xia@qq.com负责翻译和校对","true","true)","true);","true,","true;","true。","true。完成后，执行命令：vertx","true。这意味着您的每个操作都将在单独的事务中有效执行。","true）。此配置项决定是否在初次获取系统属性时对其进行缓存，并且在后面不会重新加载。","true，则可以在没有查询到要更新的文档时，新增该文档","true，则可以更新多个文档","true，则客户端将信任所有服务端证书。连接仍然会被加密，但这种模式很容易受到中间人攻击。即您无法确定您正连接到谁，请谨慎使用。默认值为false。","true，可以通过","true，让解析器使用轮询选择。它会在服务器之间传播查询负载，并避免所有的查找都找到列表中的第一个服务器。","true：","trust","trustal","trustopt","truststore\")","tsao、宋子豪","tsao，校对","ture，这样可以启用","turing\")","twitter","twitterauth","type","type\");","type\",","type:","type=\"","type`","typedargument()","typedoption()","typedoption和typedargument可以指定一个类型，因此（string）原始值将转换为指定的类型。","types）的路由","types：互联网媒体类型","type。因此，您可以很容易地使用同一个处理器来提供不同类型的数据：","type）。","type）：","type：","udp是无连接的传输，这意味着您与远程客户端没有建立持续的连接。","un","undeploy","undeploy：撤销（反部署，对应部署）","undertow","unexpect","unique:","unit","unit：待认领","unit：计划中","unmarshall：重组","unregist","unregister()","unregistercodec","unregisterverticlefactori","unregister：注销（反注册，对应注册）","unsubscrib","unsubscribe();","unsubscribed\");","up","updat","update,","updatecollect","updatecollectionwithopt","updated:","updateopt","updateoptions().setmulti(true);","updateoptions.","updateresult","updateresult.getupdated());","updates）。此方法接受含参数占位符的sql更新语句以及","updatewithopt","updatewithparam","upgrade方法：","upload","upload.filename());","upload.handler(chunk","upload.name());","upload.streamtofilesystem(\"myuploads_directory/\"","uploadhandler。","uploads。","upsert","upserted。upsert","upsert（upsert","up：服务已经可以使用了","uri","uri\")","uri\");","uri\",","uri?param1=param1_value¶m2=param2_value\");","uri。","uri。在这种情况下它只会匹配路径和该路径一致的请求。","uri。由于我们创建的桥接器是以","uri，path，param","url","url\"),","url:","urlencod","urlencoded，您亦可将其设置为","url、用户名、密码等）。这些属性既依赖于数据库，同时也依赖于所使用的连接池。","url。connect","url。用法很简单，只需要为这个处理器提供一个路由(route)，其他的配置都会自动完成。一个典型的情况是您的","url时，它要求代理使用","url时，它连接到代理服务器，并在http请求中提供完整url（get","url（地址）","url（必填）","url），如：http://localhost:8080/metrics。仪表板将使用vert.x熔断器的指标。","url，则您的输入类似于","us","us,","usag","usage:","usagemessageformatt","useobjectid","user","user(\"dale\",","user.bob","user.getfirstname()","user.getlastname());","user.isauthorised(\"commit_code\",","user.isauthorised(\"newsletter:edit:13\",","user.isauthorised(\"printers:printer1234\",","user.isauthorised(\"role:manager\",","user.isauthorised(mongoauth.role_prefix","user.jo","user.principal()","user.tim","user.{username}={password},{rolename1},{rolename2},...,{rolenamen}","user:","usernam","username:","username：todo","users.properties。","users.properties的文件。如果你想要改变这个，你可以使用properties_path配置元素来定义属性文件的路径，默认的值是classpath:vertx","user：用户","utf","uuid","uuid，可并不是所有都支持，比如说","uuid，因此它是无法推测的(6)。","v","v3）中导入服务到vert.x的服务发现组件中。","val","valid","valid.","valu","valuation.\")","value\"","value\")","value\"));","value\"),","value\");","value\".equals(r.getmetadata().getstring(\"som","value]","value。","value数据库。它可以存储字符串、哈希(hashes)、列表、无序集合(sets)和有序集合(sort","value的话，可以这样：","var","varchar(255),","varchar(36)","variabl","vector,","version","version:","vert","vert.x","vert.x\");","vert.x。","vert.x中国用户社区默认获得所有翻译内容的发布权。","vert.x中提供了一个authprovider的实现，它可以让你使用mongoclient针对mongodb数据库执行认证和授权。若要在自己的项目中使用它，则需要在构建描述信息的dependencies节点中添加如下信息：","vert.x中提供了一个使用jdbcclient的authprovider实现，它针对任何兼容jdbc的关系数据库执行认证和授权。若要在自己的项目中使用它，则需要在构建描述信息的dependencies节点中添加如下信息：","vert.x中的oauth2支持下边三种流程：","vert.x中的默认角色前缀使用了role:，这个值可通过setroleprefix进行更改。","vert.x为您的应用程序提供了简单的认证api。我们还提供了一些开箱即用的实现","vert.x会尽它最大努力去传递消息，并且不会主动丢弃消息。这种方式称为","vert.x使用内置的日志api进行记录日志，默认实现使用jdk（jul）日志，不需要额外的依赖项。","vert.x使用地址解析器将主机名解析为ip地址，而不是jvm内置的阻塞解析器。","vert.x允许您很容易编写非阻塞的tcp客户端和服务器。","vert.x允许您运行支持高可用（ha，high","vert.x发行版中使用的默认集群管理器是使用的hazelcast集群管理器，但是它可以轻松被替换成实现了vert.x集群管理器接口的不同实现，因为vert.x集群管理器可替换的。","vert.x在这里有一点魔法。","vert.x将按照特定发送者发送消息的顺序来传递消息给特定处理器。","vert.x提供了异步文件访问的抽象，允许您操作文件系统上的文件。","vert.x提供了用户对象的抽象实现abstractuser，你可以创建这个类的子类对自己的用户user对象提供自定义实现。这个抽象实现中包含了缓存逻辑，所以你在实现的时候不需要考虑自己处理缓存问题。","vert.x支持","vert.x有多个对象可以用于文件的读取和写入。","vert.x服务发现框架还提供了一些现成的后端存储机制支持。","vert.x本身只是一个库，您可以在自己的应用程序使用任何日志库的api来记录日志。","vert.x用一个java接口来描述一个","vert.x的handler内部是atomic/原子操作，verticle内部是thread","vert.x的工作方式有所不同。每个","vert.x的这个组件包含了标准的oauth2的实现。若要在自己的项目中使用它，则需要在构建描述信息的dependencies节点中添加如下信息：","vert.x的默认标准配置（out","vert.x线程模型保证verticle内部代码线程安全，同时要求在verticle之间传递的消息是不可变的，通过此方法保证verticle之间传递的消息也是线程安全的，从而进一步保证vert.x内部整体是线程安全的，从而将开发人员从繁琐的，容易错的各种多线程并发问题中解脱出来。","vert.x还提供了一种更方便的方式指定配置文件，无需设置系统属性。您只需在您的类路径中提供名为vertx","vert.x默认实现中的密码在数据库中使用了sha","vert.x，对应集群管理器","vert.x，而","verticl","verticle\",","verticle\":","verticle);","verticle.groovi","verticle.j","verticle.jar","verticle.js的vert.x","verticle.js）时，迁移才是可能的。","verticle.js，所以现在这个vert.x","verticle.rb","verticlefactory。","verticlefactory，所以需要你的classpath中确保vertx","verticle。","verticle。为此，您需要下载并安装vert.x","verticle中。","verticle中的自动清理","verticle中调用：","verticle则没有此限制，需要开发者手工处理并发冲突，我们并不推荐这类操作。","verticle可以启用高可用方式（ha）部署。在这种方式下，当其中一个部署在","verticle名称到factory的映射规则","verticle实例","verticle对应的值，最后修改main.class为io.vertx.core.launcher，修改后的pom.xml如下：","verticle对象则会被worker线程所共享，会依次顺序访问，但不会并发同时访问，如果声明为multipl","verticle属性，对应mainverticle类","verticle工厂在运行时动态的从maven中加载服务：","verticle并传入一些配置：","verticle指定要运行的main","verticle撤销时调用","verticle的名称。","verticle的实例","verticle的部署是异步方式，可能在","verticle部署时调用","verticle部署模型，避免在","verticle（java完全限定类名或脚本文件名）","verticle）内部的所有处理器（handler）都只会由同一个eventloop线程调用，由此保证verticle内部的线程安全。所以我们可以放心地在verticle内部声明各种线程不安全的属性变量，并在handler中分享他们，比如：","verticle）：","verticle，也可用于其他目的，例如加载服务、运行时从maven中获取verticle实例等。","verticle，仅需要追加","verticle，以下是run命令的几个实例：","verticle，但是它可以由不同的线程同时执行。","verticle，其部署方法和其他","verticle，否则verticle内部环境全部都是线程安全的，不会出现多个线程同时访问同一个verticle内部代码的情况。","verticle，在","verticle，并让它们彼此在网络上的其他任何服务器上集群在一起：","verticle，当父","verticle，您可以通过","verticle，您可以通过在命令行上使用","verticle，非work","verticle：","verticle：这是最常用的一类","verticle：这类","vertx","vertx)","vertx);","vertx,","vertx.cachedirbas","vertx.cachedirbase=/tmp/vertx","vertx.canceltimer(timerid);","vertx.circuit","vertx.close(context.asyncassertsuccess());","vertx.clusteredvertx(new","vertx.clusteredvertx(options,","vertx.createdatagramsocket(new","vertx.creatednsclient(53,","vertx.createhttpclient(","vertx.createhttpclient().getnow(8080,","vertx.createhttpclient();","vertx.createhttpclient(clientoptions);","vertx.createhttpclient(new","vertx.createhttpclient(options);","vertx.createhttpserver()","vertx.createhttpserver().requesthandler(1sthandler).listen(8080);","vertx.createhttpserver().requesthandler(2ndhandler).listen(8081);","vertx.createhttpserver().requesthandler(fiberhandler(req","vertx.createhttpserver().requesthandler(req","vertx.createhttpserver().requesthandler(request","vertx.createhttpserver();","vertx.createhttpserver(http2options);","vertx.createhttpserver(new","vertx.createhttpserver(options);","vertx.createnetclient();","vertx.createnetclient(clientoptions);","vertx.createnetclient(options);","vertx.createnetserver(","vertx.createnetserver();","vertx.createnetserver(options);","vertx.createnetserver(serveroptions)","vertx.createsharedworkerexecutor(\"mi","vertx.deployverticle(\"com.foo.otherverticle\",","vertx.deployverticle(\"com.mycompany.myorderprocessorverticle\");","vertx.deployverticle(\"com.mycompany.myorderprocessorverticle\",","vertx.deployverticle(\"com.mycompany.myverticle\",","vertx.deployverticle(\"com.mycompany.myverticle.verticleclass\",","vertx.deployverticle(\"service:com.mycompany.clev","vertx.deployverticle(\"th","vertx.deployverticle(\"verticles/my_verticle.rb\");","vertx.deployverticle(\"verticles/myverticle.js\");","vertx.deployverticle(myfirstverticle.class.getname());","vertx.deployverticle(myfirstverticle.class.getname(),","vertx.deployverticle(myverticle);","vertx.disablefilecach","vertx.discovery.announc","vertx.discovery.announce，你可以自己配置一个（查看服务使用章节）。","vertx.discovery.usag","vertx.eventbus().","vertx.eventbus().consumer(\"io.vertx.redis.channel1\",","vertx.eventbus().registerdefaultcodec(shoesizeexception.class,","vertx.eventbus().send(\"address\",","vertx.eventbus().send(\"address\",\"message\",","vertx.eventbus().send(\"address\",message.body(),f.completer());","vertx.eventbus().send(\"address1\",","vertx.eventbus().send(\"address1\",\"message\",","vertx.eventbus().send(\"address2\",","vertx.eventbus().send(\"address3\",","vertx.eventbus().send(\"databas","vertx.eventbus().send(\"new","vertx.eventbus();","vertx.executeblock","vertx.executeblocking(","vertx.executeblocking(futur","vertx.filesystem().copy(\"target/classes/readme.txt\",","vertx.filesystem().delete(\"target/classes/junk.txt\",","vertx.filesystem().exists(\"target/classes/junk.txt\",","vertx.filesystem().open(\"target/classes/hello.txt\",","vertx.filesystem().open(\"target/classes/les_miserables.txt\",","vertx.filesystem().openblocking(\"target/classes/plagiary.txt\",","vertx.filesystem().readfile(\"target/classes/readme.txt\",","vertx.filesystem().readfileblocking(\"/path/to/your/ca","vertx.filesystem().readfileblocking(\"/path/to/your/cli","vertx.filesystem().readfileblocking(\"/path/to/your/crl.pem\");","vertx.filesystem().readfileblocking(\"/path/to/your/serv","vertx.filesystem().readfileblocking(\"/path/to/your/truststore.jks\");","vertx.filesystem().readfileblocking(\"/path/to/your/truststore.pfx\");","vertx.filesystem().writefile(\"target/classes/hello.txt\",","vertx.filesystem();","vertx.getorcreatecontext().runoncontext(v","vertx.getorcreatecontext();","vertx.hazelcast.config","vertx.infinispan.config","vertx.io","vertx.periodicstream(1000).","vertx.registerverticlefactory(new","vertx.runoncontext(v","vertx.setperiodic(100,","vertx.setperiodic(1000,","vertx.settimer(1000,","vertx.settimer(10000,","vertx.settimer(5000,","vertx.shareddata();","vertx.timerstream(1000).","vertx.undeploy(deploymentid,","vertx.vertx","vertx.vertx();","vertx.vertx(new","vertx.zookeeper.config","vertx.zookeeper.host","vertx;","vertxebproxy。比如你的服务接口类名是","vertxexampl","vertxopt","vertxoptions()","vertxoptions().","vertxoptions().setclustered(true),","vertxoptions().setclustermanager(clustermanager);","vertxoptions().setclustermanager(clustermanager);//设置集群管理器实现","vertxoptions().setclustermanager(mgr);","vertxoptions().setclustermanager(mgr);//","vertxoptions().setclustermanager(mgr);//设置到vertx启动参数中","vertxoptions().setworkerpoolsize(40));","vertxoptions();","vertxoptions对象有很多配置，包括集群、高可用、池大小等。在javadoc中描述了所有配置的细节。","vertx工具也可以使用start、stop和list命令，start命令支持几个选项：","viettim","view","void","volatil","vpn","vpn软件通常通过创建不支持多播虚拟网络接口来进行工作。如果有一个","wait","waitqueuemultipl","waitqueuetimeoutm","want...","web","web!\");","web:3.4.1'","web:3.4.1:client'","webclient","webclient.create(vertx);","webclient.create(vertx,","webclient.wrap(httpclient);","webclient;","webclientopt","webclientoptions()","webclientoptions().setfollowredirects(false));","webclientoptions().setmaxredirects(5));","webclient。你可以通过如下方式来获取一个","webclient：","webroot","webroot/css/mystyle.css。","webroot/css/mystyle.css。这意味着您可以将所有的静态资源打包到一个","webroot。","websocket","websocket,","websocket.framehandler(fram","websocket.reject();","websocket.writebinarymessage(buffer);","websocket.writefinalbinaryframe(buff);","websocket.writefinaltextframe(\"geronimo!\");","websocket.writeframe(frame1);","websocket.writeframe(frame2);","websocket.writeframe(frame3);","websocket.writetextmessage(message);","websocketfram","websocketframe.binaryframe(buffer1,","websocketframe.binaryframe、websocketframe.textfram","websocketframe.continuationfram","websocketframe.continuationframe(buffer2,","websockethandler。","websocket、event_source、html_file、json_p、xhr。","websocket。","websocket实例：","websocket客户端","websocket服务端","websocket等。","websocket，可使用writebinarymessag","web。","web中如何将根路径对应到某个特定的html文件？","web对请求中的路径进行了规范，以防止恶意客户端通过伪造url来访问web根目录以外的资源。","web应用程序的服务器场中的会话状态存储非常有用。","web提供上传到磁盘上已知位置的功能，且不依赖客户端提供的文件名，客户端提供的文件名可被恶意伪装成上传到硬盘上的不同位置。","web替代。","web而非直接使用vert.x","web项目使用，若要在自己的项目中运用它，则需要在构建描述信息的dependencies节点中添加如下信息：","web：","web：已翻译校对完成","weiyiysw","went","we’ll","whether","wibble\",","wide","wire：报文","woker","work","worker","worker\");","workerexecutor","worker：此选项可确定一个verticle是否为work","world","world!","world!\");","world!\",","world!。","world!啦。","world\");","world”","world例子，但在此之前，我们需要您具备有以下基础知识：","world字符串。","world字符串。与start部分不同的是：","world开始，下面我们将引导您制作一个最基本简单的hello","worms）。","write","write:","writeconcern","writecontinu","writecustomfram","writefinalbinaryfram","writefinaltextfram","writefram","writehandlerid","writeopt","writeoption.acknowledg","writequeuefull：若写队列被认为已满，则返回true。","writestream","writestream。","writestream一样，往其中写入数据（例如使用一个","writestream（可写流）接口的实现类包括：httpclientrequest,","writestream）。","writestream，然后启动它：","writestream，该方法将永远不会阻塞，内部是排队写入并且底层资源是异步写入。","writetextmessag","write：写入一个对象到","writing：编写（有些地方译为开发）","written","written\");","wrong","wrong!","ws","www","www.vertx.io。","x","xbootclasspath/p:/path/to/alpn","xhr。服务器端返回一个响应之后，客户端一旦接受了响应，会立刻再发一个","xml","xsrf","xsrf。它是一种可以再未授权的网站获取用户隐私数据的技术。vet.x","xxxblocking，它要么返回结果或直接抛出异常。很多情况下，一些潜在的阻塞操作可以快速返回（这取决于操作系统和文件系统），这就是我们为什么提供它。但是强烈建议您在","xxxnow","x，","y","y\"));","yaml","yaml:3.4.1'","yaml。","yoke","you?","yxdomain","yxreset","zadd","zaddmani","ziptree(it)","zk","zkconfig","zkconfig.put(\"retry\",","zkconfig.put(\"rootpath\",","zkconfig.put(\"zookeeperhosts\",","znode","zookeep","zookeeper.json","zookeeper:3.4.1'","zookeeperclustermanag","zookeeperclustermanager();//创建","zookeeperclustermanager(zkconfig);","zookeeper（预览版）","zookeeper，因此不支持","zxvf","{","{\"vertxbus_ping_interval\":","{...},","{1,","{a:value,","{a:value2,","{name:","{}","{});","{};","|","||","}","}\";","})","})).listen(8080,","}));","}).blockinghandler(ctx","}).closehandler(v","}).compose(v","}).end(\"som","}).end();","}).listen();","}).listen(8080);","}).listen(8081);","}).putheader(\"cont","}).setfollowredirects(true).end();","}).sethandler(ar","});","},","};","}els","}else{","}，也可以选择使用占位符传参数的形式，例如：{","·io.vertx.rxjava.core.vertx·类。","—","——","“armadillos”","“hello","“username\":","“冷的”(cold)，对应的","“压缩级别”","“映射”，名词为数据结构未翻译","“记录”，名词翻译成日志器","”漂亮“","│","└──","├──","、","。","。jboss","。不建议在生产或测试环境中使用","。如果开发者想使用其他版本的","。如果您保存的文档中，没有设置","。如果我们想使用其他的类，可以自己设置这个参数，但参数对应的类，必须实现接口datasourceprovider。","。异步","。当全部","。有关连接字符串格式的更多信息，请参考驱动程序文档。","。此参数默认为","。这意味着，counter","一下是随机访问读的示例：","一个","一个json","一个jul日志记录配置文件可以使用普通的jul方式指定——通过提供一个名为java.util.logging.config.file的系统属性值为您的配置文件。更多关于此部分以及jul配置文件结构的内容，请参阅jul日志记录文档。","一个vert.x实例/进程内有多个eventloop和worker线程，每个线程会部署多个verticle对象并对应执行verticle内的handler，每个verticle内有多个handler，普通verticle会跟eventloop绑定，而work","一个处理订单的消息消费者也许会用true确认这个订单已经成功处理并且可以从数据库中删除。","一个复杂一点的例子：","一个实现了持久化队列的消息消费者，当消息成功持久化到存储时，可以使用true来应答消息，或false表示失败。","一个应用程序通常是由在同一个","一个接收","一个文件被创建（fut1）","一个最简单的方法是直接获取已经读取的数据，并立即将其写入netsocket：","一个服务提供者可以：","一个服务消费者可以：","一个泵可以启动和停止多次。","一个流式的api表示将多个方法的调用链在一起。例如：","一个独立的","一个用户的行应该是这样的结构：","一个简单地实现了返回当天时间的服务，在应答的消息里会包含当天时间信息。","一个简单粗暴的判断标准：任何涉及到io操作的代码，都可以认为是可能造成阻塞的代码，纯粹内存操作的代码，只要执行时间没有明显超长（例如执行循环几万次的处理便可认为是执行时间超长），都可以认为是非阻塞代码。","一个编译时产生的","一个角色行应该是这样的结构：","一个路径为","一个非ssl/tls连接可以通过upgradetossl方法升级到ssl/tls连接。","一个非常简单的例子是从netsocket读取然后写回到同一个netsocket","一些","一些东西被写入到文件（fut2）","一些代码","一些例子：","一些合法的地址形如：europe.news.feed1、acme.games.pacman、sausages和x。","一些处理过程","一些用于创建服务实例和服务代理实例的工厂方法","一些配置仓库需要一些额外的配置项（比如路径）。我们可以通过","一定要保持一个指向服务记录对象的引用，因为这个返回的服务记录会带有一个","一旦","一旦一个http","一旦你创建了一个jdbcclient实例后，就可以按下边代码创建jdbcauth实例：","一旦你创建了一个mongoclient实例后，就可以按照下边的代码创建mongoauth实例：","一旦你拥有了一个用户user的实例过后，你就可以调用它的方法对这个用户进行授权。","一旦使用完后释放服务对象","一旦在后台启动，可以使用stop命令停止它：","一旦完成了","一旦完成以上步骤，我们第一步所需要做的就是实例化","一旦您完成了","一旦您有了一个实例，您可以获取当前的计数，以原子方式递增、递减，并使用各种方法添加一个值。","一旦您用完一个数据库连接后，请确保关闭它。","一旦您的","一旦您的cli实例配置好后，您可以生成","一旦您获取到了","一旦您这样做，您将发现echo服务器在功能上与之前相同，但是服务器上的所有核都可以被利用，并且可以处理更多的工作。","一旦成功实例化","一旦注册了，这个服务就可用了。如果你的应用运行在集群上，则集群中节点都可访问。","一旦添加完依赖，我们就需要配置","一旦添加完依赖，我们需要配置","一次性计时器","一次性计时器会在一定延迟后调用一个","一点知识","一般情况下，http","一般来说，consum","一般来说，不应该在不同的","一节）的执行。这是通过","一词同时具有名词和动词的含义。为了避免混淆，原文中所有使用名词的地方都统一按照专有名词","一词没有找到合适的方式来描述，译为了","一词的消息：","一起使用。选项可以获取用法中显示的描述（见下文）。选项可以接受0、1或几个值。接受0值的选项是一个标志(flag)，必须使用","上","上。","上。使用","上。您需要确保会话处理器在您的应用处理器之前被执行。","上。这个处理器用于处理","上一个流行的库，用于组合异步的、使用可观察序列的、基于事件的程序。","上下文数据","上下文环境之间共享客户端，因为它可能导致不可预知的意外。例如：保持活动连接将在打开连接的请求上下文环境调用客户端处理器，后续请求将使用相同上下文环境。","上也可以挂载其他的","上传对象实现了","上传的文件可能很大，我们不会在单个缓冲区中包含整个上传的数据，因为这样会导致内存耗尽。相反，上传数据是以块的形式被接收的：","上使用","上创建","上发送消息来相互通信。","上发送的消息可包含头信息。这可通过在发送或发布时提供的","上启用","上寻找","上所有的普通代码都会在此","上执行的所有阻塞式处理器的执行是顺序的，也就意味着只有一个处理器执行完了才会继续执行下一个。","上执行的操作总是在同一个","上执行（即对应的","上接收或者发送超时的时间。默认为","上注册了一个服务，用于访问和删除数据。但我们并不希望恶意的客户端能够通过这个服务来操作数据库中的数据。并且，我们也不希望客户端能够监听所有","上注册会话处理器","上注册过的处理器。","上添加","上的ssl，可调用函数","上的例子：","上的地址。","上绑定的处理器（handler）会被调用。当一个操作失败（其中的某一个","上调用","上调用了","上边代码段描述了如何在event","上边所有操作的结果都是通过处理器handler异步调用提供的。","上边生成的","上进行非阻塞的带背压机制的异步流处理，","上述的例子描述了这样一个流程：","上面的","上面的例子中，在回应返回前，fiber","上面的例子有一个问题：如果从socket读取数据的速度比写回socket的速度快，那么它将在netsocket的写队列中不断堆积，最终耗尽内存。这是有可能会发生，例如，若socket另一端的客户端读取速度不够快，无法快速地向连接的另一端回压。","上，它会使用一个","上，这个例子使用了","上：","下共用一个","下添加文件c3p0.properties。","下边例子中，值","下边是apach","下边是基于github中使用vert.x的oauth2","下边是示例：","下面例子中的失败处理器只会在路由路径为","下面定义了如何允许服务端向客户端发送消息","下面我们将会介绍测试部分，首先引入两个新的测试依赖，修改后的pom.xml如下：","下面我们将这个","下面我们来看一下","下面是一个","下面是一个使用","下面是一个例子：","下面是一个示例：","下面是一些例子：","下面是将结果集作为","下面有更多的例子：","下面的代码也是可以的（直接基于action）：","下面的代码片段，展示了如何通过","下面的例子中的","下面的例子展示了如何配置并处理","下面的例子展示了这个过程：","下面的例子设置了一个超时处理器。对于所有以","下面的例子，文档已有","下面这些配置参数同样有效：","不严格的轮询算法","不仅仅存在于单个","不仅可以在多个","不会强迫您用这种方式创建您的应用程序。","不会自动关闭","不像在调用中提供响应处理器来创建客户端请求对象，相反您可以当请求创建时不提供处理器、稍后在请求对象中调用","不允许在模板中随意地调用对象的方法，因此我们不能像对待其他模板引擎一样将路由上下文传递到引擎里并让模板来识别它。","不允许请求或响应流执行清除重置，如当客户端上传的资源已经存在于服务器上，服务器就需要接受整个响应。","不允许请求或响应流进行重置，如当客户端上传了服务器上存在的资源时，服务器依然要接收整个响应。","不兼容。","不同。","不同于","不同的","不存在，将创建新的","不存在，那首先将配置的","不推荐但是有效的命名：account","不支持alpn的客户端仍然可以执行经典的ssl握手。","不是一个容器，您可以只使用您需要的部分。","不是有序的，但","不是默认","不正确配置的话，vpn","不正确配置的话，vpn接口将被选择，而不是正确的接口。","不能够很容易的处理","不能部署一个已经存在的","不要忘记释放服务对象！","不要阻塞我！","不难看出，若写入对象的速度比实际写入底层数据资源速度快，那么写入队列就会无限增长，最终导致内存耗尽。","不需要特别的部署器，使用","与","与关闭","与发布消息的不同之处在于，发送(send)的消息只会传递给在该地址注册的其中一个处理器，这就是点对点模式。vert.x","与各种","与授权用户关联的数据库名称。默认值为","与此对应的api还有","与集群相关的命令。要使用这些命令，redi","两个处理器过后，在流重置完成时您将会收到通知。","两个处理器过后，在流重置完成时您将会收到通知：","两者都支持。若找到这样的请求头，服务器将使用所支持的压缩算法之一自动压缩响应正文并发送回客户端。","个","个步骤：","中","中。","中。举个例子：","中。然后，这个自定义类型就可以使用了。","中不同的概念和特性。","中也可以：","中了解如何去使用它。","中会有一个内置的","中作为主类，由","中使用","中使用启动器","中使用它之前测试使用它们究竟需要耗费多长时间，以避免打破黄金法则。","中使用或者嵌入使用。","中使用时，verticl","中内嵌","中内嵌了一个默认配置文件","中内嵌相应的配置文件","中写入数据。","中写入数据。它是","中创建了计时器，当这个","中创建的","中创建，那么","中加载一个文件为自定义配置文件","中加载，并在","中包含","中包含了响应体的这一分片（部分）内容：","中反映处理。","中发布者和订阅者的角色；这使得我们能够以对待","中发送任何对象，只要你为这个对象类型注册一个编解码器","中发送任意对象。您可以通过为您想要发送的对象自定义一个","中可以设置以下参数：","中启动：","中国用户组发动社区内的志愿者翻译","中处理的非","中安装包中。","中完成此操作。","中完成，也可以在你的代码的任何其它位置完成。","中定义的。","中定义默认的根路径是","中导入服务到","中已经通过注释的形式，详细说明每个配置项的作用。","中并行执行。","中开始写入数据的位置。buffer","中异步执行代码了。换句话说，您提交的任务将会在同一个","中心库下载。","中您不能直接让线程休眠以引入延迟，因为它会阻塞","中所有的","中执行它的","中执行，通过","中找到，简单来说您会像这样使用：","中指定一个spi的实现；如果没有指定，那么将使用默认的存储后端。","中指定一个超时时间。如果在这个时间之内没有收到应答，则会以失败为参数调用应答处理器。默认超时是","中指定这些查询要求。","中指定，但建议您将代码编写成verticle，并使用vert.x中的launcher类（io.vertx.core.launcher）作为您的主类。这是在命令行中运行vert.x使用的主类，因此允许您指定命令行参数，如","中推断出服务类型；如果没有设置，那么服务类型被设置为unknown","中插入一个","中撤销处理器，则同样会花费一些时间在节点中传播。若您想在完成后收到通知，可以使用unregister(handler)","中有用到。","中查找文件","中标准的","中没有其它的","中注入一个","中注册了","中添加","中添加一个","中添加对应的文件。如果想在","中的","中的一个通用模式，所以请适应这种代码风格。","中的偏移量","中的全部或部分发生故障时，则可能会丢失消息。","中的哪个键值对是命令名称，我们也就必须把命令名称单独设置为一个参数：","中的字符会以","中的操作同时运行。当组合的处理操作完成时，该方法返回的","中的数据库表）中的一个或多个文档。其中","中的数据进行保存、获取、搜索和删除。redi","中的方法并传入了处理器时，vert.x","中的日志框架实现。","中的最新特性。","中的服务导入到vert.x的服务发现组件中。","中的某个线程来执行。","中的消息是按顺序持久化在磁盘上的，所以消费者可以在某个","中的状态不会在响应中描述","中的线程上。一个实例可以由多个线程同时执行（译者注：因此需要开发者自己确保线程安全）。","中的线程上。一个实例绝对不会被多个线程同时执行。","中的线程执行。","中的线程而不是","中的自动清理","中的资源","中的资源写入socket。这种做法是非常高效的，它可以被操作系统内核直接处理。","中的通常做法是使用","中的部分api：仅关闭操作，实现了关闭处理器和异常处理器。该协议并不提供其他操作的语义。","中的配置保持一致。","中的集合概念对应","中直接调用阻塞式操作，因为这样做会阻止","中移除的服务将会被移除","中第一次找到一个资源时，会将它提取到一个磁盘的缓存目录中以避免每一次都重新提取。","中背压机制传播方面的方法（在请求更多数据项时）。","中自动关闭","中自动清理","中自动清除定时器","中自定义","中节点中的通信是直接由","中英对照表","中英文对照表","中获取","中获取单个","中获取配置。这种方式让你可以在本地和分布式组件中分发你的配置。","中获得配置。","中被多个线程同时执行，但它可以在不同时间由不同线程执行。","中解析读取的，若您已经将表单属性存放在请求体中发送出去，并且该请求为","中设置了java","中设置多个值。需要注意","中设置多个值（译者注：hmset","中设置多个值（译者注：msetnx","中设置实际的会话数据，这个","中访问环境变量","中读写流的方式处理任意","中读取一批消息的时候自动执行提交偏移量的操作。需要在创建","中读取或追加/设置到","中读取数据","中读取数据，它存在各种不同数据类型的方法，这些方法的第一个参数是从哪里获取数据的索引（获取位置）。","中读取数据，必须设置","中运行了多个处理函数时，可能需要在它们之间共享数据。","中运行：","中集群管理器中的默认实现。由于","中（或构建工具的依赖中）包含","中）","中）之间安全共享数据。","中，vert.x将自动检测到，并将其作为集群管理。需要注意的是，要确保","中，vert.x将自动检测到，并将其作为集群管理。需要注意的是，要确保vert.x的","中，zadd","中，写调用是立即返回的，而写操作的实际是在内部队列中排队写入。","中，可以按照","中，并且是有序的。","中，并从任何其他节点读取。","中，您可以使用","中，想要延迟之后执行或定期执行操作很常见。","中，有些操作通常会有接受一个","中，消费者负责处理最新读取消息的偏移量（offset）。consum","中，用来跟踪服务的使用情况。","中，类路径中jar文件或其他文件）时，它会把文件复制到缓存目录。背后原因很简单：从","中，该","中，通过构建工具可以轻松引入：","中，采用","中，集群化与高可用均是开箱即用的。vert.x","中，集群管理器可用于各种功能，包括：","中：","临时响应信息。这个可通过","为","为rest","为主版本分支，主要进行里程碑式的发布；dev","为了从","为了使","为了使服务访问的方式一致，所有的服务都必须遵循以下的消息格式。格式非常简单：","为了使用","为了使用熔断器我们需要以下的步骤：","为了使这个特性正常工作，需要在启动","为了利用更多的服务器核，您将需要部署更多的服务器实例。您可以在代码中以编程方式实例化更多（server的）实例：","为了在短时间内完成调度循环，就需要用户正确估算出，哪些程序代码会相对长时间地占用eventloop线程的执行时间，然后将该部分代码的执行交由其它线程去处理。值得注意的是，这里所说的其它线程，可能是内核线程，也就是操作系统的线程，也有可能是用户线程，用户线程中包括了其它应用程序的线程，也就是其它进程中的线程，或者是我们用户自定义的线程。","为了提升性能，sqlrowstream","为了支持在","为了清空内部缓存，则你可以使用clearcache方法。","为了确保","为了解决后边一个问题，vert.x也允许您调整原始的","为了解决这个问题，sockj","为了解决这个问题，vert.x","为了进行调试，可以记录网络活动：","为了进行调试，可记录网络活动。","为了连接池（能）工作，配置客户端时，keep","为了避免在\"user\"集合中出现重复的用户名，应该在\"user\"集合中给\"username\"添加唯一索引（uniqu","为依赖，在项目中直接使用","为包名前缀，例如","为参数被调用。","为响应设置处理器","为开发分支，日常的提交都在","为当前请求推送资源","为服务提供者创建一个服务记录","为桥接器配置哪些消息允许通过是很容易的。","为此，您可以调用其中一个指定的请求方法，如","为此，您应该设置一个名为vertx.logg","为此，您需要下载并安装","为此，您需要使用loggerfactory获取一个logger对象以记录日志：","为若干流行的模板引擎提供了开箱即用的支持，通过这种方式来提供生成动态页面的能力。您也可以很容易地添加您自己的实现。","为让返回的服务器信息易于操作，vert.x","为避免歧义，实现类需要遵循以下规则（译者注：可参考","主机名使用以下方式解析为ip地址：","主机名解析","主机映射","主要分为两个分支，master","主要针对轮询方式的","举个例子，假如我们要去执行一个名为save的操作，此操作接受一个字符串类型的collection参数和一个jsonobject类型的document参数：","之前","之前执行","之前执行，可以将其指定为负值。","之前执行：","之前的例子可写成","之前，需要为您的构建工具在描述文件中添加依赖项：","之后再调用此方法，只会返回一个新的","之后再调用此方法，只会返回一个新的客户端实例，但使用的是相同的数据源。这时","之后再调用此方法，只会返回一个新的客户端对象，但使用的是相同的数据源。这时","之后，您的应用另外一部分","之后，我们为这个","之后，我们告诉服务器监听","之间互相转化的静态方法。","之间分享对象，那这种情况您无需考虑。","之间安全共享的","之间的差异等）。本着翻译准确的原则，本译文没有进一步展开描述。","之间设置一个对话窗口。这种消息模式被称作","也会运行在","也即","也可以与ha组合使用，在这种情况下，每个特定组会解决","也可以从json表单中实例化选项。","也可以作为","也可以匹配多个精确的值（mime","也可以在ide中使用重部署功能：","也可以在创建","也可以在失败处理器中转发。由于转发的性质，在这种情况下，当前的状态码和失败原因也会被重置。因此在转发后的处理器应该根据需要生成正确的状态码，例如：","也可以指定消息传递的配置","也可以提供一个失败时回调方法(fallback)：","也可以达到配置","也可以通过命令行的方式部署：","也就是说，你可以通过以下方式进行服务调用：","也提供额外的格式支持组件，并可以在你的应用中使用。","也提供额外的配置仓库支持，并可以在你的应用中使用。","也支持通过","也支持通过buffer来配置：","也支持采用","也是一个","也是可以的。","也是多语言的，而不同语言之间的类型转换实现起来十分的复杂和困难。所以，我们会用","也能以同步的方式获得一次性的事件，例如定时器的触发，或者","也能被配置成使用","也需要加载","了消息。","予以配置：","事件。","事件。(10)","事件。延时时间由这个配置决定。默认的服务端会在","事件。注意，setpingtimeout(5000)","事件可能是以下的某一种类型：","事件对象同时是一个","事件总线","事件流","事件通知收集的。如果您不使用默认通知地址，则需要在创建时指定。","事先配置好","事实是，很多，也非所有的库，特别是在jvm生态系统中有很多同步api，这些api中许多方法都是阻塞式的。一个很好的例子就是","事物提交失败!","事物提交成功!","互联网的基础知识，知道什么是网络协议，尤其是tcp，http协议。","产生的服务代理和处理器的命名是在类名的后面加相关的字段，例如，如果一个服务接口名为","仅仅遵循301状态代码","仅当用户已登录并且拥有权限","仅当用户已经登录并且包含","仅当需要通过多个处理器输出响应时才需要","仅限java语言。","介绍","仍然使用缓存，但始终使用原始源刷新存储在缓存中的版本。因此，如果您编辑从类路径提供的文件并刷新浏览器，vert.x","从","从buffer中读取","从foo.txt拷贝到bar.txt","从map读取数据","从socket读取数据","从vert.x","从websocket","从一个处理器捕捉到异常时会标记一个状态码为","从上面可以看出，服务提供者和服务消费者，通过服务记录来共享关键的信息。","从代码中可以看到，如果一个到达的请求包含路径","从会话中删除值","从会话中获取值","从命令行直接运行vert.x","从命令行运行verticl","从响应中读取cooki","从字符串创建一个","从字节数组","从磁盘中读取了一些数据","从路径中提取参数","仓库(git","仓库(repository)中获取配置。","仓库中中的","仓库克隆下来，然后从中读取匹配的文件集合。","仓库克隆的","代理。","代理可以在","代理支持，因为代理仅支持","代理的例子：","代理的创建","代理访问","代理（如squid）或","代理：","代码可以发送任何消息到任何的服务端处理器或其他所有浏览器上。","代码块会","代码生成","代表的文档已经存在，插入就会失败：","代表的是匹配符","令","令牌","令牌是一种简单的方法来发送明文信息（通常是url），其内容可以被验证为是可信的。像下面的这些场景jwt是非常适用的：","令牌来作为访问令牌。这对于需要混合基于客户端的授权和基于","以","以utf","以一个现有的","以上就是如何在您的服务器上绑定处理器","以上是未使用future时的代码，以下是使用future改造后的代码：","以下","以下两种写法是等效的：","以下是一个使用","以下是一个例子，一个处理器设置了一些数据，另一个处理器获取它：","以下是一个例子：","以下是一个查询和添加","以下是一个简单的路由示例：","以下是一些事件的例子：","以下是一些创建","以下是二进制帧的示例：","以下是使用","以下是使用阻塞","以下是使用隔离组隔离","以下是例子:","以下是例子：","以下是操作会话数据的例子：","以下是文件异步拷贝的示例：","以下的例子定义了一个应用，该应用的不同部分需要不同的权限。注意，权限的含义取决于您使用的的","以下的参数可供配置：","以下路径的请求都会调用这个处理器:","以便更轻松地扩展应用程序。","以及","以及使用它们的方法其实与原生的","以及分区。在这种情况下，消息会以轮询(round","以及分区信息","以及分配的偏移量","以及对应的","以及相关的分区(partition)的方法，类似于向","以及相关的分区(partition)，或者将消息以","以及相应的值而省略消息的","以及：","以后不需要再使用","以外）它们总是在同一个","以执行后续的处理。","以指定的编码方式写入一个字符串","以满足任何希望升级到","仪表板中，配置流网址（stream","仪表板使用。","仪表板需要一个发送指标的sse流，此流由","任何发生的事件都会被传递到这个处理器。事件由对象","任何可控制的写入流对象都实现了","任何服务都可能存在潜在的漏洞，无论是使用vert.x还是任何其他工具包，因此始终遵循安全最佳实践，特别是当您的服务面向公众。","任何枚举类型","任何被","任意一个","任意原生类型或包装的原生类型。","会一步一步检查每一个","会一直被阻塞住，而内核线程不会。","会从类路径读取它，将其复制到缓存目录并从中提供。不要在生产环境使用这个设置，它很有可能影响性能。","会以一个新的","会使用","会使用当前工作目录的子目录","会使用轮询策略来管理请求处理。","会像对应的处理函数传入一个","会写入一定量的数据，您可以创建","会匹配任何","会匹配所有","会匹配所有到达这个服务器的请求。","会发送一个基本的","会变得很麻烦。可以通过在","会在","会在响应里设置这些消息头：cach","会在每次从某个","会声明一个","会定期地从配置仓库处读取配置。如果读取的结果和当前的配置不一样，那么应用就会重新进行配置，默认情况下，配置的刷新时间是","会将事件传给处理器来处理。","会将文件复制到其缓存目录中，并随后读取该文件。这个行为也可配置。","会将状态消息替换为状态码的默认消息。","会将资源的最后修改日期缓存在内存里，以此来避免频繁地访问取磁盘来检查修改时间。","会循环执行，处理所有到达的事件并传递给处理器处理。","会抛出一些异常（注意，以下代码只是同步代码的示例，和","会按照以下的顺序进行配置：","会是一个","会查找模板","会检查每一条输入许可。如果存在匹配，则消息可以通过。","会检查每一条输出许可。如果存在匹配，则消息可以通过。","会每隔","会给于警告。","会自动关闭。","会自动在event","会自动撤销任何子","会自动设置响应的","会舍弃毫秒项，所以您会看到","会被传递到失败处理器里，失败处理器可以通过获取到的错误或错误编码来构造失败的响应内容。","会被标记为失败。当所有的操作都成功时，返回的","会被赋值为其被添加到","会被销毁。","会话","会话中的键的类型必须是字符串。本地会话存储的值可以是任何类型；集群会话存储的值类型可以是基本类型，或者","会话处理器会创建会话","会话处理器会自动从会话存储中查找会话（如果没有则创建），并在您的应用处理器执行之前设置在上下文中。","会话存储","会话存储持有一个伪随机数生成器（prng）用于安全地生成会话标示。prng","会话永远转发到正确的服务器上。默认值为","会话维持了","会话超时","会运行在","会返回列表的第一个元素。","会返回客户端能够理解的排序好的语言列表。","会配置一个正确的","传入之后，这个配置可以通过","传入到异步方法里。该方法的返回值是提供给异步调用使用的","传入配置","传递一个事件给处理器或者调用","传递给","传递给处理器的对象是一个","传递给此方法，则通知将被禁用。默认情况下，使用的地址是","但不包括:","但不包括：","但不幸的是，java","但它可以满足服务器所要求的cpu周期的不可控的成本（注意现在vert.x不支持任何缓存形式的响应数据，如静态文件，因此压缩是在每个请求体生成时进行的）,它可生成压缩过的响应数据、并对接收的响应解码（膨胀）——","但是","但是config是一个例外。任意的config在部署时传递的任何配置都将覆盖任何呈现在文件描述符文件中对应的属性。","但是……真实世界并非如此（您最近看新闻了吧？）","但是在某些情况下，您可能需要部署一个verticle，它包含的类要与应用程序中其他类隔离开来。比如您想要在一个vert.x实例中部署两个同名不同版本的verticle，或者不同的verticle使用了同一个jar包的不同版本。","但是如果存储过程有返回值的话，需要像下面这样调用：","但是当您使用存储过程时，还是需要使用它的参数来返回结果集。如果一个存储过程没有返回值的话，可以像下面这样调用：","但是要注意，即使数据包尺寸小于mtu，它仍然可能会发送失败。","但是，命令执行是阻塞的，必须结合","但是，当","但是，您也可以从命令行直接运行","但是，若您愿意，也可以使用上述的vert.x日志记录工具为应用程序记录日志。","位的熵作为种子。这个策略可以通过系统属性来设置：","位置开始消费消息。我们可以通过","位置设置到","低位就是时间戳，所以","何时停止，何时恢复，何时结束。对于查询返回多个结果集的情况，您应该使用","作为","作为parse的第二个参数来禁用验证。如果要检查参数或选项，即使解析的命令行无效，这也是有用的。","作为verticl","作为前缀的，因此我们需要将","作为压缩级别，但是该参数可通过","作为参数（最多6个），并将结果归并成一个","作为参数（最多6个，或传入","作为参数，以表示操作和结果的成功或失败。","作为可写流或可读流时，它只能用于不分割多个帧的二进制帧一起使用的","作为最后的参数，例如用","作为标准的消息格式，这使得客户端在接受数据类型时受到很多限制。我们只能从","作为根目录。可以通过","作为消息发送。不过在","作为结尾。","作为缓存目录，它在此之间创建一个唯一的目录，以避免冲突。可以使用","作为访问","作为返回值的方式获取配置：","作为默认的集群管理器。","作参数被调用。方法执行完时，verticl","你也可以使用","你也可以使用生成的代理类，代理类名是服务接口类名加上","你也可以利用","你也可以将多语言api生成功能（@vertxgen注解）与","你也可以直接传递服务接口类：","你也可以通过setusageaddress方法，将事件发送地址设置为null，这样就可以禁用服务使用情况的监听功能了。","你也可以通过编程的方式用registerverticlefactory方法注册verticlefactory实例","你也可以配置","你仅仅需要将","你可以使用jwtauth来创建一个提供者的实例，并指定一个json对象的配置。这是创建一个jwt","你可以做一些配置：","你可以利用","你可以把它当成一个普通的","你可以把这个类的实例传递给任意的","你可以获取一条服务记录，也可以通过","你可以通过","你可以通过一个json","你可以通过下列示例自定义配置：","你可以通过以下spi对其进行扩展：","你可以通过声明一个特殊方法，并给其加上","你能够配置熔断生效/关闭时回调。","你需要一个同时实现了","你需要对配置仓库进行配置，来找到正确的","你需要将服务接口抽象成一个java接口，并且加上","使你能以同步的方式从这种流中接收事件。","使其可用","使用","使用buffer结束","使用cli","使用http","使用javascript的factori","使用json","使用openssl引擎","使用put","使用query读取uri中的查询部分。","使用servic","使用setdefaultvalue设置默认值","使用sethidden隐藏","使用setmultivalued设置接收多个值——只有最后一个参数可以是多值的。","使用setrequired设置必填","使用shiroauth创建提供者的实例。使用shiroauthrealmtype指定shiro","使用vert.x","使用vpn","使用web","使用一个预先创建的apach","使用不严格的轮询算法来选择绑定的处理器。","使用不同的连接池时，可能会稍有不一样。","使用了","使用事务","使用代理类进行服务调用","使用会话","使用会话，vert.x","使用公共","使用其他","使用另一个shiro","使用另一个日志框架","使用失败码拒绝并关闭这个连接，这可能是长连接最好的","使用失败码拒绝忽略请求体，若体很小，这是适用的","使用字符串紧跟着一个冒号，它用于查找存在的factory，参考例子。","使用完后，不要忘记释放服务引用。","使用客户端","使用已存在的","使用已有","使用所有默认选项创建","使用无符号数","使用本仓库进行翻译工作的协作。git","使用正确的网络接口。当通过命令行模式时，可以设置","使用正确的网络接口，在配置文件中将","使用此客户端，需要添加下列依赖：","使用此配置仓库通常需要配置","使用注解","使用流式响应","使用流式请求","使用流的方式读取配置","使用熔断器","使用熔断器执行代码","使用的","使用的东西。","使用的配置参数不一样：","使用组合来实现链式调用","使用说明","使用这个处理器涉及","使用这种方式，可以发挥出","使用这种服务，将不会产生服务使用的事件。","使用配置文件","使用错误的网络接口","使用阻塞式处理器","使用集群模式运行groovy的verticl","使用静态valueof方法，如基础类型和枚举","使用静态的from或fromstring方法","使用高于","使用默认共享连接池","使用默认设置运行javascript的verticle：server.js：","例如","例如保存一个","例如删除作者为","例如匹配所有文档：","例如在下面的例子中，对应的结果就是rest调用的输出：","例如对于","例如您可以提供一个失败处理器只处理在某个路径上发生的失败，或某个","例如执行","例如插入一个","例如插入含有","例如更新","例如替换","例如用","例如获取","例如获取批量模式下","例如计算作者为","例如，下面的","例如，对于一个路径为","例如，您可以将磁盘上的文件直接泵送到http","例如，您可能在event","例如，您应该始终在dmz中运行它们，并使用具有受限权限的用户账户，以限制服务受到损害的程度。","例如，若您使用\\n分割的简单ascii文本协议，并输入如下：","例如，若您部署了一个创建netserver的verticle，该netserver在处理器中提供了netsocket","例如，请求的uri为：","例如：","例如：jgroups.bind_addr=192.168.1.5。","例如：对于一个服务名：com.mycompany.clev","例如：我们在部署","例子中使用了：","例子忽略了","依照udp的本质，它最适合一些允许丢弃数据包的应用（如监视应用程序）。","依赖,","依赖。","依赖与","依赖添加至","侦听分配结果","便可看到熟悉的hello","便是一个","保存文档","保存这个发布记录的引用，后面可以用来取消发布或者修改发布","保护","保持一致。","信息","信息。","信息如下：","信息，请查阅","信息：","借助","值。","值不为空时，将覆盖","值为","值传入存储过程","值得注意的是，示范代码可能会抛出nullpointerexception，因为当操作失败时，asyncresult.result()方法返回值为null，此时调用.body()方法会抛出空指针异常，在生产环境中正确写法应该是：","值时，有其他一些更简洁的方式。","值来确定","值来表示权重。q","值（默认值为","值，对于","值，或者使用","假设我们拿到两个数万个节点的链表（linkedlist），要求删除两个链表的交集，那么在没有任何算法优化的前提下，该操作的时间复杂度是o(n^2)，又因为内存中该链表节点数庞大，多达数万个节点，所以如果在eventloop中执行该操作，将有可能使得执行时间超长，此时需要将这部分代码交由其它线程予以执行，vert.x提供了除了eventloop线程池以外的线程池，名曰worker线程池。此时就需要用户自行将该部分代码包装成worker线程执行的代码，并交给worker线程予以执行，执行完成之后再由eventloop线程执行回调函数处理其结果。注意：vert.x中将代码交给worker线程执行的方式有两种，一种是通过executeblocking函数包装，另外一种是写入work","偏移量查询","做一些事","做一些事情。。。","做一些其他的事情","做一些工作","做了一些初创性的工作来提供这样一份标准。","像下面这样做的：","允许","允许单个","允许向客户端发送地址为","允许向客户端发送地址以","允许客户端向地址","允许您传递一个handler，一旦查询完成将会传入一个asyncresult给handler并通知它。","允许您向令牌中添加任何您需要的信息，只需要在创建令牌时向","允许您在同一个","允许您在客户端请求对象中设置一个","允许您轻松编写非阻塞的","允许该处理器为您处理回调地址","先于","免费下载集成开发环境（ide）intellij","全限定类名（fqcn）然后尝试实例化它。","公共","公共接口定义了3种批量操作的方法：","共享","共享数据","共享数据包括本地共享map、分布式、集群范围map、异步集群范围锁和异步集群范围计数器。","共享数据（share","关于","关于如何编写","关于服务事件的更详细内容参考后续章节。","关于高可用的功能和配置的更多细节可参考","关键字返回输出结果集，这时可以这样调用：","关闭","关闭datagramsocket","关闭处理器","关闭客户端","关闭底层连接","关闭操作也是异步的，可能直到方法调用返回过后一段时间才会实际关闭。若您想在实际关闭完成时收到通知，那么您可以传递一个处理器。","关闭时","关闭时收到通知，可以设置一个","关闭时（endhandl","关闭连接","其中","其中location是一个json对象，包含了访问mongo数据源的所有属性（url、端口等）","其中my_verticle.conf也许会包含以下配置：","其中第二个方法会接受一个","其他map操作","其他命令","其他存储后端","其他很多情况","其他通用oauth2的provider配置示例","其他默认的","其优点是与tcp相比具有更少的开销，而且可以由netserver和netclient处理（参考前文）。","其它连接池实现：","具体","具体见翻译计划文档。","具体详细配置，请参阅","具有不同的会话处理机制。sessiontimeout","具有单个string参数的构造函数，例如file或jsonobject","具有附加值的短选项（即gcc","内创建了","内容协商","内容协商(2)","内嵌在对应jar包中。","内的文件必须是同一种格式）。","内置的一个","内联阻塞式代码。","内设置","内部创建的","内部进行偏移量定位(seek)操作，并从任意指定的","内部，大部分数据被重新组织（shuffle，表意为洗牌）成","再次发送同样的请求","再次发送请求","写","写buffer","写utf","写一个简单文本消息","写一些块","写入","写入到http","写入响应并结束处理","写入字符串，这种请求字符串将使用","写入带编码方式的字符串，这种情况字符串将使用指定的编码方式编码，并将结果写入到报文中。","写入帧","写入操作是异步的，可能调用","写入数据的方式有两种：追加和随机写入。任何一种情况下","写入消息","写处理器","写好的","写指定编码的字符串","写操作的可靠性（译者注：源码中是用","写数据到磁盘","写文件","写最终帧","写的异步驱动","写请求体","写请求头","决定的。","决定路由一个请求到匹配的","出了些问题","出来继续等下一个消息。如果超过了默认的","出现一些错误","出错了","函数","函数只使用","函数处理。","函数完成写入和请求的发送操作。","函数将当前线程切换回event","函数或者存储过程。此方法接受以下参数：","函数（译者注：用于将数据实体类转换为","函数：","分别是","分区偏移量定位","分块","分块传输编码(http","分块则不需要担心这点。","分块模式，则不需要","分块，则必须在写入请求之前设置content","分块，那么必须在写入响应之前设置","分布式","分布式map的支持","分布式计数器","分布式锁","分支上边。基本两个分支足够使用，但可以根据每个人的喜好创建个人分支，不做约束。","分支的","分配给组内其它消费者继续去消费。","分钟。","分钟使用一个新的","分钟发送一个","分隔的","切换","列举目录","列表。","列表。或者您可以在响应中自己解析set","列表传参：","列表（可能为空）：","列表，其中的每个元素代表一行结果。","列表：","则您可以配置一个","则暂停读取","创建","创建http服务器，并分配路由","创建meta","创建servic","创建web","创建。如果您需要完整的控制处理器的执行顺序（例如您期望它在处理链中首先被执行），您也可以先创建这个","创建一个","创建一个kafka","创建一个可以反序列化成buffer的consum","创建一个可以反序列化成jsonarray的consum","创建一个可以反序列化成jsonarray的consumer.","创建一个可以反序列化成jsonobject的consum","创建一个可以反序列化成jsonobject的consumer.","创建一个可以序列化成buffer的producer.","创建一个可以序列化成jsonarray的producer.","创建一个可以序列化成jsonobject的producer.","创建一个实现了","创建一个指定初始大小的","创建一个熔断器，并配置成你所需要的(超时，最大故障次数)","创建一个空的","创建一个继承io.vertx.ext.discovery.types.abstractservicereference的类。你可以对类进行参数化，添加上你要返回的服务对象的类型信息，你必须实现abstractservicereference#retrieve()这个方法，在这个方法中创建服务对象，这个方法只会被调用一次，如果你的服务对象需要释放资源，那另外还需要覆写","创建不共享数据源的","创建不共享数据源的客户端对象","创建了一个默认的集群会话存储","创建会话处理器","创建好上边的实例过后你就可以如使用任何authprovider执行认证和授权功能了。","创建好上边的实例过后，你就可以使用任何authprovider针对mongodb执行认证和授权功能了。","创建客户端","创建客户端对象","创建客户端将使用的新的可用请求","创建客户端时可使用","创建或者部署的时候，我们应该把对应的配置参数传给它。","创建时，我们同时指明了消息体（payload）的类型，这不是必须的。","创建的","创建的时候设置。","创建的虚拟网络接口。","创建空的缓冲区","创建自己的认证实现","创建认证处理器","创建连接","创建集群模式的","初始化","初始化时分配了更多的内存，比数据写入时重新调整大小的效率更高。注意以这种方式创建的","初探","删除产品","删除单个文档","删除文档","到","到http请求中，您可以直接调用","到目前为止，通过上述的路由机制您可以顺序地处理您的请求，但某些情况下您可能需要回退。由于处理器的顺序是动态的，路由上下文并没有暴露出任何关于前一个或后一个处理器的信息。唯一的方式是在当前的","制作web","前缀，而短名称与单个","前设置环境变量","前面提到，服务发现使用了服务类型的概念，来封装各种服务的差异性。","功能。","加入多播组","加入某个","加载","动态性","包","包(","包。","包。也可以通过设置启动参数:","包中内嵌的","包中内嵌的两个文件来配置自身属性：","包加入","包加入到","包含一个整形（int）的错误状态码、一条消息和一个可选的","包含输出类型的输出结果集（output），jsonarray","包或任意子包中的任意类名。","包里。","包：","匹配对应","匹配所有\"color\"","匹配所有名称为","匹配所有名称为\"a\"的记录","匹配所有设置了","区域（参数选项卡中），写入run","升级到","半开启状态","协作","协议","协议。","协议中使用","协议之上实现。","协议使用","协议依赖：","协议版本可以通过显式添加启用协议进行配置：","协议版本可在netserveroptions或netclientoptions配置项中指定。","协议的","协议的安全路由。这个处理器简化了获取","协议的语义，而不至于崩溃并断开","协议达成一致，尽管服务器或客户端决定了仍然使用","协议，这样的连接是使用","单一线程的问题在于它在任意时刻只能运行在一个核上。如果您希望单线程反应器应用（如您的","单个连字符的长选项（即ant","单个连接的管道请求限制数由","占位符由","即","即使客户端配置成不使用","即使客户端配置成使用","即可达到目的。","即异步开发模式中的","即最初不运行任何verticle的实例，它们也将为集群中的节点进行故障转移。要启动一个裸实例，您只需做：","却是，而且","卸载（undeploy）的时候自动关闭。","压缩","压缩。","压缩功能。这意味着客户端可以让远程服务器知道它支持压缩，并且能处理压缩过的响应体（数据）。","压缩时，服务器将检查客户端请求头中是否包含了","压缩的客户端和不支持的客户端。","压缩算法。vert.x","压缩算法的","压缩级别允许根据所得数据的压缩比和压缩/解压的计算成本来配置","压缩级别是从","压缩，则它可以发回没有压缩过的请求。","压缩，它将包含例如下边的头：","原文上次编辑于2017","原文档","原文档更新于","原文档更新于2017","原文档最后更新于","原文档：vert.x","原生对象","去掉","去考虑线程和扩展问题。您不用再考虑","参数","参数。","参数。因为","参数中。这么做是因为","参数中添加数据即可。这样做服务器上不存在任何的会话状态，您可以在不依赖集群会话数据的情况下对应用进行扩展。","参数也可以从json表单中实例化。","参数也就不再有作用。","参数会在运行时传给此","参数决定了要删除集合中的哪些文档。","参数决定更新集合中的哪个文档。","参数创建一个数据源。","参数找到的整个文档。","参数是必须的。","参数没有名称，使用基于","参数用来匹配集合中的文档。","参数用来指示存储配置对应的","参数的","参数的值设为","参数的元素值不是","参数的元素值也是","参数的元素值将被注册为输出参数","参数的元素值，再做判断","参数的元素将被当作","参数的元素是","参数的变量，以指定多个的dns服务器来尝试查询解析dns。它将按照此处指定的相同顺序查询dns服务器，若在使用上一个dns服务器解析时出现了错误，下一个将会被继续调用。","参数的第一个键值对是命令的名称。所以，为了明确","参数的重载方法用于设定","参数确定哪一个才是我们要读取的。另外，应用必须要拥有对","参数类型可以是以下类型中任意一个：","参数类型和异步返回类型","参数，就会忽略","参数，就会忽略host","参数：","参考代码如下：","参考这里。","又例如匹配","又或者收到一个http请求：","发出请求","发回响应","发布","发布/订阅模式","发布/订阅消息","发布event","发布http","发布一个","发布一个服务记录","发布后，更新相应的文档翻译。","发布服务","发布服务记录","发布消息","发布消息很简单，只需使用","发布消息源服务","发布消息的","发布消息：","发布的消息载体","发布者（例如来自","发布这个服务记录","发布这条服务记录","发布／订阅模式","发布／订阅模式的消息队列相关命令","发现器","发现并管理集群中的节点","发生了一个异常","发生这些情况时，应答处理器将会以这些失败为参数被调用。","发行版，并将安装目录中的bin添加到path环境变量中，还要确保您的path上有一个java","发起了重载操作，则会因为验证错误而请求失败。","发送","发送100","发送buffer","发送buffer到多播地址","发送get请求","发送head请求","发送main.js响应","发送一个字符串","发送一帧到服务器","发送一次请求，并处理其响应，rx通常通过订阅触发各种响应","发送到一个","发送到服务器），当消息到达时，vert.x","发送多播数据包","发送失败","发送数据。","发送数据包很容易，如下所示：","发送数据报包","发送文件或","发送文件是异步的，可能在调用返回一段时间后才能完成。如果要在文件写入时收到通知，可以在","发送消息","发送消息(records)。","发送消息到某个","发送消息给接收者并等待回复","发送由单个最终二进制帧组成的websocket消息：","发送缓冲区大小（so_sndbuf）。默认为","发送者：","发送请求","发送请求的资源内容","发送通用请求","取决于jvm的版本，如","取得可访问的","取消发布的服务","取消计时器","取消订阅/离开多播组","受信存储。","变换为对象的","变量来访问路由上下文","变量，使代码更为简洁。","另一个代理类","另一种单独提供服务器私钥和证书的方法是使用","另一种您可以访问上下文数据的方式是使用","另一种提供服务器证书颁发机构的方法是使用一个","另一种提供服务器证书颁发机构的方法是使用一个.pem文件列表。","另外","另外web","另外一个例子对基于角色模型的用户进行授权就是使用role:前缀，请注意，就像上边讨论的一样，权限字符串如何被解释完全取决于底层实现，这里vert.x不对解释细节提供假设。","另外一种写法，通过对应的服务类型接口获取的方式：","另外一种分别提供服务器私钥和证书的方法是使用.pem文件。","另外一种运行阻塞式代码的方法是使用","另外也可以使用","另外如果想知道消息是否成功被消费掉，可以在调用","另外，listtop","另外，如果需要修改打包好的","只匹配指定的","只支持","只是做了一层异步封装。","只是在服务器上查找实际的会话数据时使用的标示。这个标示是一个通过安全的随机过程生成的","只有","只有在第一次调用","只有当订阅发生时，才会开始发射数据，而","只要不存在对象的循环引用，嵌套的","只要向event","只要您从数据库从获取时间格式的数据，此客户端都将会隐式将它们转换成","只要提供商被配置为支持","只读取一个配置文件，而这种方式会从一个目录中读取一批配置文件。","只需使用","只需要在构建配置中加上","只需要调用","可与其它rxjava","可以为不同的用途创建不同的池：","可以为您处理这种情况。在与现有服务端相同的主机和端口上部署另一个服务器时，实际上并不会尝试创建在同一主机/端口上监听的新服务端，它只绑定一次到socket，当接收到请求时，会按照轮询策略调用服务端的请求处理函数。","可以从字符串或字节数组初始化，或者直接创建空的","可以使用","可以使用消息的","可以使用静态方法","可以使用默认构造函数创建空的json对象。","可以使用默认构造函数创建空的json数组。","可以发送或发布消息，或注册处理器来接收消息。","可以在","可以在事件到达时快速地分发到不同的处理器中。","可以在创建会话处理器时配置超时时间。默认的超时时间是","可以在创建的时候配置：","可以在接收服务器推送的请求/响应的请求上设置一个推送处理器：","可以在服务器上设置连接处理器，任意连接传入时可得到通知：","可以在请求上设置连接处理器在连接发生时通知：","可以在部署配置项中指定不同的worker","可以在集群环境中的另一个","可以在集群管理器通过设置","可以处理以","可以处理在客户端通过","可以对消息流进行流量控制。如果我们读到一批消息，需要花点时间进行处理则可以暂时暂停（pause）消息的流入（这里实际上是把消息全部缓存到内存里了）；等我们处理了差不多了，可以再继续消费缓存起来的消息（resume）。","可以将","可以将客户端配置为在无法连接的情况下自动重试。这是通过","可以嵌套在非","可以快速、无需“等待”地获得最近一次获取的配置内容：","可以把它想象成一把构建现代的、可伸缩的","可以持有一个与之关联的处理器用于接收请求。您可以通过这个处理器对请求做一些事情，然后结束响应或者把请求传递给下一个匹配的处理器。","可以指定熔断器在生效之前的尝试次数，使用","可以提供哪些","可以是另一种代理类型（所以一个代理类可以作为另一个代理类的工厂）。","可以有多种风格，包括回调、promise和rx风格。vert.x","可以根据请求中的","可以用utf","可以用来协调多个异步操作的结果。它支持并发组合（并行执行多个异步调用）和顺序组合（依次执行异步调用）。","可以看到此时为了保证顺序结构，产生了两层缩进，回调金字塔开始形成，多次缩进之后便会出现所谓的回调地狱，这便是异步开发中为了保证顺序所可能会遇到的问题，那么我们可以通过以下方式解决代码过多缩进的问题：","可以看到，使用了future之后，原先的两层缩进被抽取出来，变成了最多单层的缩进，从而使得代码可读性更强，更加美观。","可以自动转换。需要注意的是，我们可以选择性的使用","可以被映射为单个元素的","可以被适配为","可以让你在熟悉的同步风格下继续使用异步","可以让你用同步的方式得到这种一次性的异步操作的结果。这是通过调用","可以访问","可以调用","可以这样注册一个订阅者：","可以通过","可以通过以下几种方式为服务端配置证书/密钥：","可以通过占位符声明路径参数并在处理请求时通过","可以通过参数","可以通过提供值为","可以通过设置","可以通过调用","可以通过配置证书吊销列表（crl）来吊销不再被信任的证书机构。crlpath配置了使用的crl：","可以阅读","可以非常迅速地处理数千个","可使用","可使用jdk随附的keytool实用程序来管理java","可发送请求体剩余部分","可在短时间内分发大量的事件。例如，一个单独的","可在部署时传给","可替换主机文件：","可用","可用于实例化不同语言的","可用于提供自签名pem证书，并可以提供","可用如下代码获取配置：","可用的各种选项完整信息，可以直接在命令行键入","可用的服务发现桥接器","可能对应多个","可能是一个系统错误(system","可能的dnsresponsecode值是：","可被多次订阅。","可读流支持","可读流的背压时，你会用到","可读流转换为","可读流：","可调用语句","可调用语句。可以使用标准","可选","可通过设置io.netty.util.internal.logging.internalloggerfactory强制netty使用某个特定实现。","号来代表必须存在某个key值，而不管value值","各个组件的常见问题以及相应的注意事项和解决方案。","各路径作用为：","合并表单属性","同","同一个地址可以注册许多不同的处理器，一个处理器也可以注册在多个不同的地址上。","同任何花哨的寻址方案相比，vert.x的地址格式并不麻烦。vert.x中的地址是一个简单的字符串，任意字符串都合法。当然，使用某种模式来命名仍然是明智的。如：使用点号来划分命名空间。","同其他集群管理器，亦可通过编程的形式来进行配置，举例：","同时vert.x","同时也可以通过编程的形式达到配置的目的：","同时也表示（客户端）可以发送请求的剩余部分。通常将其与","同时用作客户端和服务器，因此这些配置近似于","同时要确保","同样在","同样意味着您可以将您的应用中的所有代码用单线程方式编写，让","同样的（与默认使用共享的数据源），只有在第一次调用jdbcclient.createshared方法的时候，才会真正的根据","同样的（与默认使用共享的数据源），只有在第一次调用mongoclient.createshared方法的时候，才会真正的根据","同样的，将一个","同样的，我们为","同样的，这儿也有一个异步版本的","同样重要。如果第二个参数代表输出结果集，那么应该设置结果集的","同样需要设置项目命名空间作为发现范围：","同样，requestab","同步拷贝从foo.txt到bar.txt","名称","名称不在区域内","名称创建了一个本地会话存储","名称创建了一个集群会话存储","名称可以有一个前缀","名称或传入您已经创建好的","名称来记录网络活动。使用网络活动记录时，需要注意以下几点：","名称错误","后的值：","后续的的","后缀的请求方法，如","后，可以让文档基于创建时间排序（译者注：前4个字节用来存储创建的时的时间戳，精确到秒）。您也可以通过使用","后，直接调用","向","向buffer写入数据","向socket中写入数据","向会话中设置值","向其泵送数据，如","向响应里写入了数据并结束了响应。","向响应里写入了数据，5秒之后","向响应里写入了数据，再5秒之后","向客户端发送一帧","向数据库中存储一些数据","否则使用jdksslengineopt","否则失败","否则若log4j可见，再使用该库","否则退回使用java.util.log","吧。","含有","启动会耗费一些时间，您想要在这个过程做一些事，并且您做的这些事并不想等到verticle部署完成过后再发生。如：您想在","启动器","启动器和退出代码","启动器子类","启动应用程序。使用此设置，vert.x","启动时注册。","启动服务端监听","启用和停用","启用时，vert.x","周期性、延迟性动作","周期性的任务可以通过","周期性计时器","命令","命令。","命令。vert.x","命令。不同之处在于，zaddmani","命令。但是，您可以通过设置","命令传入一个","命令使用单个字符串或者字符串数组来作为参数，并且返回的也是单个字符串或者字符串数组。不过在处理","命令十分特殊，因为它们可以返回任意类型。vert.x","命令提供了一套十分简洁的","命令来检索配置。","命令的参数最终会传递给应用程序，可使用","命令的返回值，即便是像下面这样简单的脚本：","命令行","命令行启动，要确保","命令行实用程序调用。它可执行一组命令，如run、bar","命令行工具","命令行工具中使用。另外，它支持多语言（可用于任何支持的语言），并可在vert.x","命令行工具和更普遍的","命令行工具用于在终端中与","命令行工具，可以在执行","命令行接口api","命令运行verticle了，这儿是一些例子：","命令返回的结果将被转换成","命令）：14","命令，如果给定","命令，必须当且仅当所有给定","命令，请参考","和","和上文一样，我们创建了一个","和其他一些语言不同，java","和其他服务类型一样，发布","和其他服务类型一样，发布一个消息源服务包含两个步骤：","和参数名构成。参数名由字母、数字和下划线构成。","和客户端使用的方式一致，这种操作随着压缩级别的增长会变得更加倾向于cpu密集型。","和当前线程关联，那么它直接重用这个","和服务器上的","和服务器配置相同，也可通过以下几种方式配置受信客户端：","和许多其他文件操作。我们不会在这里列出所有内容，请参考","和设置处理器处理请求一样，您可以设置处理器处理路由过程中的失败。","和选项不同，参数不具有","和集群端口","响应","响应、异步文件","响应。","响应。浏览器会显示一个登录窗口并提示用户输入他们的用户名和密码。","响应。若底层操作系统支持，这会导致操作系统不通过用户空间复制而直接将文件内容中字节数据从文件传输到socket。这是使用","响应中。","响应中，或者写入任意","响应中，通常直接操作","响应体中。其间，背压机制是自动执行的。","响应体以块的形式写入，通常在响应体预先不知道尺寸、需要将很大响应正文以流式传输到客户端时使用。","响应体编解码器对二进制数据流解码，以节省您在响应处理中的代码。","响应写入数据","响应写入是异步的，并且在写操作进入队列之后会立即返回。","响应包含响应体（正文），它可能会在响应头被读取后的某个时间以分片的方式到达。在调用响应处理器之前，我们不要等待所有的响应体到达，因为它可能非常大而要等待很长时间、又或者会花费大量内存。","响应发送回来时调用该处理器来处理响应结果。","响应变得更加便捷，同时提供了额外的高级功能，例如：","响应可包含头信息。您可以使用","响应和附加尾部","响应处理器","响应头中单个键可以关联多个值。","响应头可直接添加到","响应头和尾","响应头必须在写入响应正文消息之前进行设置。","响应头提供的重定向，并且响应处理器将传递重定向响应以替代原始响应。","响应完成处理器","响应时间处理器","响应模式","响应编解码器","响应还可以包含响应尾(trailer)","响应附加尾部(trailers)写入响应，这种方式实际上是在写入响应的最后一块。","响应，则可使用","响应，可调用","响应：","唯一的保证是，它既不会被完全接收到，也不会完全不被接收到，即只有部分会被接收到。","唯一的区别是您可以将多播组的地址传递给","回到event","回到vert.x","回收的周期可以通过","回调","回调，因此您不需要处理授权服务器的响应。一个很重要的事情是，来自授权服务器的响应只有一次有效。也就是说如果客户端对回调","回顾","因为","因为http允许同一个键支持多个请求头的值。","因为netsocket既实现了readstream也实现了writestream","因为vert.x","因为其具有更高的","因为协议不会将消息发送回客户端。","因为服务代理会共享同一个vertx实例","因为每一个数据包将会作为一个包发送，所以在通常情况下您不能发送大于网络接口的最大传输单元（mtu）的数据包。","因此在构建容器镜像时，需要显式声明：","因此，vert.x","因此，服务器可直接扩展可用的核，而每个","因此，要监听指定的地址和端口、并且接收多播组230.0.0.1的数据报，您将执行如下操作：","图标可以指定为文件系统上的某个路径，否则","在","在cli定义中使用typedoption和typedargument，而不是option和argument。","在equinox上，您可能需要使用下边的框架属性禁用contextfilter：eclipse.bundle.settccl=false。","在hystrix","在java中，你可以使用","在java，groovy以及kotlin语言中，json对象可被解码映射成pojo：","在java，groovy以及kotlin语言中，您亦可使用","在vert.x","在vert.x中使用用户数据报协议（udp）就是小菜一碟。","在一个单一的报名场景中，你想要有一个隔离的认证服务用可被信任的方式发送用户信息","在一个完美的世界中，不存在战争和饥饿，所有的api都将使用异步方式编写，兔兔和小羊羔将会在阳光明媚的绿色草地上手牵手地跳舞。","在一个标准的反应器实现中，有","在一些情况下，运行环境中，无法开启组播。在这种情况下，需要配置合适的","在上述例子中，如果您发送一个包含如下","在上述所有情况下，当您的线程在等待处理结果时它不能做任何事，此时这些线程并无实际用处。这意味着如果您使用阻塞式api处理大量并发，您需要大量线程来防止应用程序逐步停止运转。所需的内存（例如它们的栈）和上下文切换都是线程的开销。这意味着，阻塞式的方式对于现代应用程序所需要的并发级别来说是难于扩展的。","在上述的例子中，route1","在上述的例子中，如果一个","在上面的例子中，action对应的值应该与服务接口的某个方法名称相对应，而消息体中每个","在上面的例子中，如果一个请求的路径为","在上面的例子中，我们在创建","在上面的例子里，响应中会包含：","在下面的例子中处理器会匹配所有","在下面的例子里，我们拒绝掉了所有经过桥接器并且包含","在下面这个例子中会被路径为","在不需要的时候必须被关闭：","在中国越来越受到关注，使用人数也越来越多，但相关的中文文档却寥寥可数，在这样的背景下，vert.x","在以下的例子中，所有路径以","在以前的版本中，只能通过操作指定的","在使用","在使用完服务后，必须释放服务引用，才能清理服务对象和更新服务使用状态。","在保存时会增量编译您的文件，重部署工作会顺利进行。","在决定使用jwt之前，需要重点注意的是jwt并不加密payload，它仅对payload签名。你不应该使用jwt发送任何私密信息，相反你应该发送是不是私密的但要被验证的信息。举个例子，使用jwt发送一个签名过的用户id来表明这个用户已经登录了的做法非常对的。相反发送一个用户的密码的做法是非常非常错误的。","在出现错误的情况下，通知中将包含一个dnsexception，该异常会包含一个说明为何失败的dnsresponsecode。此dnsresponsecode可用于更详细检查原因。","在分块模式下，您还可以将响应的http","在分块模式下，每次调用","在创建","在创建完成后就会开始发射数据。更进一步的信息请查阅","在前面的示例中，代码中使用的是getas方法，参数是你期望获得的对象类型。如果你使用java语言，那么可以直接用get方法，而其他语言中，你必须传递对象类型。","在匹配时会被忽略。","在单次调用中写buffer并结束请求（直接发送）","在另外的发布者上注册订阅者","在可写流上注册另外的订阅者","在同一个上下文环境中（如：同一个","在同一台计算机上运行两个javascript","在后续章节会将更加详细的重载规则和其他可用的配置仓库设置一一展现。","在启动","在启动时","在响应完成后会话会自动回写到存储中。","在域名","在处理大数据结果集时，不建议使用上面提到的api，而是使用数据流（stream","在处理流式数据方面，vert.x","在处理这个错误时，routingcontext","在多个","在多数情况下，vert.x使用被称为","在大部分情况下，我们会希望在不同的","在大部分情况下，我们会希望在不同的客户端实例之间共享数据源。但有时候，却恰恰相反。","在大部分情况下，我们会希望在不同的客户端对象之间共享数据源。但有时候，却恰恰相反。","在客户端","在客户端通过使用","在容器中使用时，您也可以配置公共主机和端口号：","在常规应用中","在应答的消息体中可以包含有用的信息。","在开发时，可以方便在文件更改时实时重新部署应用程序。vertx","在当前路径中","在循环语句中长时间逗留","在您的处理器中，您可以通过","在您的应用中处理认证","在手动处理","在打包成","在排除故障时，开启","在排除故障时，开启jgroups日志，将会给予很大的帮助。在","在撤销时","在文件已满时会暂停，但是当写队列处理完成时，我们需要取消暂停：","在最新的版本中(3.4.0+)，可以通过","在最简单的情况下，如果","在服务器上创建","在服务方法中可用的参数类型和返回值类型是有限制的，这样使得转化为event","在服务消费端，你可以手动获取服务记录和服务引用，也可以使用","在服务消费端，第一步要做的事情就是查找服务记录。你可以查找并获取一条服务记录，也可以获取一批满足条件的记录。如果是获取一条记录，那么将返回第一条满足条件的服务记录。","在服务端启用ssl/tl","在服务端处理","在服务端（被调用端）注册messagecodec。如果运行在单机模式下这就足够了","在服务端，vert.x","在构建工具中添加依赖即可：","在构造(construct)发生时，作为异步方法的最后一个参数的","在某些情况下（例：若请求体很小），您将需要将这个请求体聚合到内存中，以便您可以按照下边的方式进行聚合：","在某些情况下，因为特殊的运行环境，可能无法使用多播。在这种情况下，应该配置其他网络传输，例如在","在某些情况下，因为特殊的运行环境，可能无法使用组播。在这种情况下，应该配置其他网络传输协议，例如在","在某些情况下，因为特殊的运行环境，可能无法使用组播。在这种情况下，应该配置其他网络传输，例如在","在此，通往自由之路的功臣乃","在每一次重新尝试连接的间隔（exponenti","在消费时用同样的方式：","在熔断器中执行的代码","在第一个终端运行：","在第一个终端：","在第三个控制台，您可以启动另一个vert.x的实例：","在第二个","在第二个终端中，让我们使用相同组运行另一个verticle：","在第二个终端：","在第二种写法中，服务对象的释放是通过","在线地址：https://vertxchina.github.io/vertx","在组件","在绝大多数地方使用回调(尽管它也支持rx)。","在编写vert.x","在表中插入新数据时，您也许希望获得数据库的自增长id。jdbc","在被阻塞时就不能做任何事情。如果您阻塞了","在设置认证处理器时可以指定一系列访问资源时需要的权限。","在请求/响应期间随时支持流重置：","在请求uri中的参数将会被预填充","在请求中指定的","在请求的生命周期中，您可以通过路由上下文","在运行单元/集成测试或是运行开发版的应用程序时都经常需要自签名证书。","在这一点上，您可能会问自己：如何让多台服务器在同一主机和端口上侦听？尝试部署一个以上的实例时真的不会遇到端口冲突吗？","在这个例子中，rout","在这个例子中，第一件事是创建了一个","在这个例子里，如果任意一个","在这之后，浏览器会重新发送这个请求，并将用户名和密码以","在这种情况下这个","在这种情况下，vert.x","在这种情况下，vert.x不是","在这种情况下，如果服务器可以同时提供","在这种情况下，如果请求中包含了消息头","在这种认证方式下，","在这里处理传入连接","在这里处理请求","在这里，我们在创建","在这里，我们的目标实现了。当写队列准备好接收更多的数据时，drainhandler事件处理器将被调用，它会恢复netsocket的状态，允许读取更多的数据。","在连接打开之前，我们什么也做不了。当它打开后，会回调","在部署的时候都会被分配一个","在配置文件","在配置项中告诉服务器监听指定的主机和端口：","在集群模式下的event","在顺序","在验证的终点上，一旦你通过它的用户名/密码验证了用户的id","在默认情况下，服务事件发送到event","在默认配置中使用","地址","地址(address)。","地址。","地址列表。具体","地址获得配置，可以使用任何支持的格式。","地址配置有难点，请强制使用","地址）","均有异步调用方法，其返回值为","块被写出。","域名不应该存在","基于","基于一个命名的工作线程池（name","基于客户端可接受媒体类型（mime","基于正则表达式的路径匹配","基于正则表达式的路由","基于精确路径的路由","基于请求媒体类型（mime","基于路径前缀的路由","基于通配符的子类型匹配也是支持的：","基于重定向的认证","基本术语","基本概念","基础认证","填充请求体","填充请求头","增强的rx化的","声明。默认情况下，选项会接受一个值，但是您可以使用","声明了消息体的","声明每一个数据存储源就必须要指明存储类型（type）。它可以指定格式（format），默认将使用","处理","处理30x重定向","处理http响应","处理index.html响应","处理row","处理。原文中的动词统一译为","处理中","处理事务的相关命令","处理会话","处理压缩体","处理响应","处理器","处理器。","处理器。这个","处理器会自动处理这个问题。","处理器只是接到通知，确认被发送，这个功能旨在基于","处理器器能够匹配到所有您需要这个功能的请求。","处理器支持","处理器的地址由","处理器直接使用了它读取到的数据进行回写：","处理器类，用于响应由服务代理发送的事件。","处理器通过请求的消息头","处理器需要在会话处理器之前被执行。","处理失败的情况","处理完成之后，请使用","处理对象","处理异常","处理数据报","处理文件上传","处理消息体","处理登录请求","处理结果","处理网络分区","处理请求","处理请求并调用下一个处理器","处理请求消息体","处理跨域资源共享","处理逻辑","处理静态资源","处理静态资源，例如您的登录页","复制了类似的每一个方法，并冠以","复杂一点的例子：","多个event","多播","多播不可用","多播允许多个socket接收相同的数据包，该目标可以通过加入到同一个可发送数据包的多播组来实现。","多路复用","大多数vert.x","大多数流式传输方式会在客户端保存响应的内容并且不会释放派发消息所使用的内存。这些传输方式需要定期执行垃圾回收。max_bytes_stream","大多数用户并不需要配置这些值，除非您发现应用的性能被","大小为q","大部分","大部分verticl","大部分情况下，您希望不同的客户端之间共享一个连接池。","大部分情况下，您都将希望不同的客户端实例（asyncsqlclient）共享一个连接池。","大部分情况下，我们希望在不同的","大部分都是事件驱动的。这意味着当您感兴趣的事情发生时，它会以事件的形式发送给您。","天生就是处理","失败!","失败。","失败回调可以直接设置在","失败处理器和普通的处理器具有完全一样的路由匹配规则。","失败时，系统将选取","失败的","头","头。因此，若您不使用","头。当","头时自动发回","头，其值为可支持的压缩算法，（该值可）支持多种压缩算法。这种情况","头，否则会太迟。若您使用","头，因此您不必先计算大小。","套接字","套接字创建时会发生该事件。","套接字处理器。该处理器用于将服务器端的","套接字处理器会被安装到","套接字，在亚马逊云上使用","如slf4j可见，则优先使用该库","如上所述，用户数据报协议（udp）将数据分组发送给远程对等体，但是以不持续的方式来传送到它们。","如下所示：","如下：","如之前讨论，您不能在","如何定位verticl","如何定位服务（uri、ev","如何通过","如前所述，访问数据源的方式依赖于数据源本身。要创建一个","如前边部分所述，dnsclient","如已在程序中创建","如已知流的大小，可在http协议头中设置","如您坚持使用标准的vert.x","如果","如果future在这里被标记为失败，熔断器将自增失败数","如果json过滤器未设置（为空或null），获取时将获取到所有的服务记录。当使用函数形式时，要获取所有的服务记录，你只需要返回","如果一个请求在响应之前超时，则会给客户端返回一个","如果上述任何一种情况停止了","如果不同的","如果不同的客户端对象使用了相同的","如果不指定前缀，vert.x将根据提供名字后缀来查找对应factory，如：","如果不设置参数索引，则基于声明顺序会自动计算。","如果不需要缓存的消息头，可以通过","如果两个匹配的","如果以上三步全都成功，则同样执行","如果以上任何一步失败，则不会继续执行下一个异步流程，直接执行最终的","如果任何一步失败，将startfuture标记成fail","如果会话在指定的周期内没有被访问，则会超时。","如果你使用vert.x","如果你希望创建自己的认证提供者auth","如果你希望在集群环境中使用你的user对象，则需要保证这个用户对象实现了clusterserializable接口。","如果你想在一般的","如果你想要重写上述行为，则你可以调用sethashstrategy方法设置新的hash策略，并且提供变更过的hash策略及配置信息。","如果你想要重写这些行为，则可以重写sethashstrategy方法去修改hash策略的设置。","如果你用的是","如果使用","如果使用默认的datasourceprovider实现类（c3p0实现），我们要把jdbc","如果可以立即提供结果，它将立即返回，否则您需要提供一个处理器（handler）来接收稍后回调的事件。","如果启用了缓存处理，则","如果在","如果在处理路径以","如果处理器随后调用了","如果尝试发送一个大于最大值的消息体，则会得到一个","如果希望将消息发送到指定的分区，你可以指定分区的标识(identifier)或者设定消息的","如果您不关心执行的顺序，并且不介意阻塞式处理器以并行的方式执行，您可以在调用","如果您不在处理器里结束这个响应，您需要调用","如果您不希望vert.x使用jul记录日志，您可以为其配置另一个日志记录框架，例如log4j或slf4j。","如果您不希望事件继续处理，您可以用参数","如果您不想使用","如果您不想使用默认值，则可以在创建实例时传入","如果您不能够保证这一点，那么就不要使用这个存储。这会导致请求被派发到无法识别这个会话的服务器上。","如果您不这样做，而是手动调用","如果您不需要为隐藏文件提供服务，可以通过","如果您不需要这个行为，可以通过","如果您使用","如果您使用hystrix的异步支持，请注意，对应的回调函数不会在vert.x线程中执行，并且必须在执行前保留对上下文的引用（使用","如果您使用的是","如果您像上面的例子一样启动一个桥接器，并试图发送消息，您会发现您的消息神秘地失踪了。发生了什么？","如果您只关心用户偏好的语言，那么使用","如果您只有单个","如果您喜欢的话，可以直接实现该接口，但是通常直接从抽象类","如果您在","如果您在使用","如果您希望在同一个事务中执行多个操作，就应该使用","如果您希望在回话中存储用户对象，以避免对所有的请求都执行认证过程，您需要使用会话处理器。确保它匹配了对应的路径，并且会在认证处理器之前执行。","如果您希望用户登出，您可以调用上下文的","如果您希望直接操作原生的","如果您想创建一个集群模式的","如果您想要在部署完成时被通知则可以指定一个完成处理器：","如果您想要让一个路由匹配不止一个","如果您想覆盖路由默认的顺序，您可以通过","如果您想让","如果您是java新手，对于命令行感到发怵的话，我们特意为您准备了可视化傻瓜化入门教程，以降低vert.x的入门门槛。但是再怎么傻瓜，也还是需要您具备有基本的java语法知识，我们并不会在此介绍任何关于java的语法知识，尤其是java","如果您是在","如果您没有在","如果您用嵌入方式使用vert.x，可通过以下代码创建实例：","如果您的应用程序没有响应，可能这是一个迹象，表明您在某个地方阻塞了event","如果您的文件在服务器运行过程中可能发生变化，您可以通过","如果您知道消息体的类型是","如果您要访问某些上下文数据里不存在的信息，比如请求的路径、请求参数或者会话等，您需要在模板处理器执行之前将他们添加到上下文数据里，例如：","如果您通过嵌入式的方式使用","如果您需要","如果您需要使用一个上述未列出的提供商，您也可以使用基本的","如果您需要在在桥接器发生事件的时候得到通知，您需要在调用","如果您需要指定返回哪些域，又或者需要指定返回的数据条数，可以使用","如果想关闭这些警告或更改设置，您可以在创建","如果想查阅更详细的信息，或实现自己的日志后端，请参考","如果想注销这个服务，可使用","如果想要替换上边的username和password两个默认字段名，你可以使用下边两个方法：","如果想要的话，你也可以通过正常的jar来使用注解处理器，但是你需要显式地声明注解处理器。比如在","如果想要配置","如果我们已经存在一个数据源，也可以在创建","如果我们已经有了一个网站包含以下的","如果我们的","如果我们读到partition0的第5个offset","如果我们配置的顺序是","如果指定了","如果文档中没有","如果文档没有","如果是","如果有新的结果集，将会重启","如果服务器需要客户端认证，那么当连接时，客户端必须向服务器提供自己的证书。可通过以下几种方式配置客户端：","如果本地","如果机器上上有多个网络接口（也有可能是在运行vpn的情况下），那么jgroups很有可能是使用了错误的网络接口。","如果机器上有多个网络接口（也有可能是在运行","如果没有为请求匹配到任何路由，vert.x","如果没有指定","如果没有提供错误处理器，vert.x","如果用户以第三方应用的方式访问想要的资源，oauth2可以对这些用户进行授权，任何时候可以根据用户想要都有可能启用或禁用它的访问权限。","如果用户没有提供，则返回空。","如果知道服务的类型（jdbc客户端、http客户端），整个过程就可以简化为通过服务类型直接获取服务对象。","如果第一步成功，则发送第一步的消息的返回值到","如果第二步成功，则发送第二部的消息的返回值到","如果系统变量","如果组内的一个消费者挂了，kafka","如果终端1中的实例被杀掉，则它将故障转移到终端2中的实例，而不是具有不同组的终端3中的实例。","如果编写web","如果缺省的配置不适合您，可在创建","如果被插入的文档包含","如果被插入的文档没有包含","如果要了解期望的特定认证提供者auth","如果要使用集群会话存储，您需要确保您的","如果要使用默认的认证实现，认证信息中用了username和password字段进行表述：","如果要创建一个客户端实例，你首先需要一个jdbcclient的实例，要知道如何创建这个实例可按照文档中的内容实施。","如果要创建一个客户端实例，你首先需要一个mongoclient的实例，要知道如何创建这个实例可按照文档中的内容实施。","如果要对用户进行认证可使用provider中的authenticate方法。","如果要指定","如果要覆盖其中任意一个配置文件，可以在","如果要覆盖此配置，可以在","如果要限制请求消息体的大小，可以在创建消息体处理器时使用","如果要验证一个用户是否属于特定角色，则可以使用mongodb认证前缀（mongoauth.role_prefix）法给角色带上前缀表示：","如果要验证一个用户是否属于特定角色，则可以使用前缀法给角色带上前缀表示：","如果要验证一个用户是否拥有特定的许可，则要将许可信息传递到isauthorised中：","如果要验证一个用户是否拥有特定的许可，则需要将许可信息传递到isauthorised中：","如果认证使用了默认的mongodb实现，认证信息中用了username和password字段：","如果认证处理器完成了授权和认证，它会向","如果设置了","如果请求包含请求体，那么该请求体将在请求处理器被调用后的某个时间到达服务器。","如果请求访问虚机主机","如果运行了mi","如果运行在集群模式下，那么需要将shoesizeexceptionmessagecodec注册到当前节点的ev","如果这三个步骤全部成功，则最终的","如果这个","如果这个值得前缀是classpath:，将会在类路径查找那个名字的属性文件。如果这个值的前缀是file:，将在文件系统上指定一个具体的文件。如果这个值得前缀是url:，将会指定一个具体的url来加载这个属性文件。","如果这样做，该","如果选项值被限制为一个固定集合，您可以设置不同的可接受选项：","如果通过","如果通过命令行来使用","如果通过命令行来使用vert.x，jar包vertx","如果部署成功，这个完成处理器的结果中将会包含部署id的字符串。这个部署","如果需要生成不同语言的服务代理代码，你需要添加对应的语言支持依赖，比如","如果需要的话，服务实现的时候也可以返回serviceexception的子类，只要向ev","如果需要覆盖此配置文件，需要在","如果需要返回异步结果，可以提供一个","如果默认的多播配置不能正常运行，通常有以下原因：","如果默认的组播配置不能正常运行，通常有以下原因：","如需使用vert.x","如需要发送请求体，可使用相同的api并在最后加上","妙极！——","始终会使用","始终根据需要进行自动扩容。","子类可以：","子路径用来存储用于管理","子路由","字段插入。并且读取这个字段：","字段来提供资源的不同版本。","字段的值，将会默认的生成","字段，回调方法中可以获得保存后生成的","字段，并且消息中包含了","字段，并且消息的目标地址与","字段，并且消息的目标地址匹配了这个正则表达式，则匹配成功。","字段，文档会被保存。若有，将执行","存储分布式计数器","存储分布式锁","存储后端","存储后端，需要将如下的依赖包加入到依赖配置文件中：","存储过程","存储通过接口","存在，那首先尝试更新（如果需要切换分支就切换分支）。如果更新失败，那配置读取也会失败。","它不会阻塞，但当锁可用时，将","它也会在","它也可使用","它也支持buffer的配置：","它们可以在响应结束之前被多次调用，它们可以通过以下几种方式调用：","它们永远运行在","它们还允许您直接读写。","它会创建一个vert.x","它做了和上文使用","它包含：","它只是一个标准的java密钥存储，与服务器端的密钥存储相同。通过在jsk","它可以让你验证令牌的真实性","它失败的尺寸取决于操作系统等（其他原因），所以按照经验法则就是尝试发送小数据包。","它完全是无状态的","它将输入缓冲区序列转换为已配置的缓冲区序列（固定大小或带分隔符的记录）。","它提供了若干不同的传输方式，并在运行时根据浏览器和网络的兼容性来选择使用哪种传输方式处理。","它是如何工作的","它有一个json结构，可以包含任何你想要的变量和大量的数据","它的增益不是线性的，并取决于要压缩的特定数据","它的键值不区分大小写，这意味着您可以执行以下操作：","它继承了","它还可以打印帮助信息——详细说明命令行工具可用的选项。即使这些功能远离vert.x","安全注意事项","安全的桥接","安全说明。","安装","宋子豪、赵亮","完全一样。","完全限定类名，也可以指定java","完全非阻塞","完成","完成时被调用。","完成时，执行相关代码，并完成下一个","完成时，执行相关代码，并返回","完成时，组合完成。","完成，无论成败。compositefuture.join","完整的细节可以在","官方文档。","官方文档中文翻译","官方文档中文翻译的仓库。","官方文档翻译工作计划","官方网站","定义一个失败处理器，上述的处理器发生错误时会调用这个处理器","定义了使用模板引擎的接口，当渲染模板时会调用","定义了配置项的数据源和语法（默认是","定义命令行接口","定义阶段","定时器","定时器。定时器可以是一次性或周期性的，两者我们都会讨论到。","定时器任务可以通过","实例","实例。","实例。rxhelper.observablefutur","实例。关于此部分的配置可以参考","实例。它像一个普通的map或hash，并且它还允许同一个键支持多个值","实例。当您完成了对消息的处理，您可以用参数","实例。您可以通过","实例。此实例在启动时未部署任何verticle，但它若接收到若集群中的另一个节点死亡，则会在此节点运行之前挂掉的实例。如需要创建一个","实例。由此可以避免为嵌套的多个异步操作定义不同的","实例。这个vert.x","实例。这些实例通过底层的分布式数据结构来协同保持服务集合的同步。","实例。这是一个代表了实际连接的套接字接口，它允许您读取和写入数据、以及执行各种其他操作，如关闭","实例上。","实例不会绑定到特定端口，如果您只想发送数据（如作为客户端）的话，这是没问题的，但更多详细的内容在下一节。","实例中","实例中。","实例中。我们称这个为","实例中。详细说明请参阅","实例中。通过您在网络上将不同的","实例中使用，还可以通过运行在浏览器里的","实例中同时运行的许多","实例中向指定的","实例中或在不同的","实例中有多个应用，并且希望不同的应用使用不同的","实例中的","实例中的不同","实例中的不同应用程序之间或集群中的不同","实例中的所有","实例中设置异常处理器来处理请求时发生的异常：","实例中重新部署。","实例为参数被调用。由于","实例之间共享，所以相关的配置必须在创建","实例之间安全地共享数据。","实例也是readstream和writestream","实例也是一个","实例仍然严格使用单线程，您不需要像编写负载均衡器那样使用任何特殊技巧去编写，以便在多核机器上扩展服务器。","实例作为副本集的名称","实例可使用任意","实例可访问对应的","实例失败或挂掉，则此verticle将自动重新部署到集群中的另一个vert.x","实例实现了","实例将复用相关的资源（如线程、连接等）。使用完","实例将数据泵入请求中。","实例将自动重新部署mi","实例将通过","实例并没有部署好（状态不是","实例并调用请求处理函数，此对象表示服务端","实例必须在同一个集群中。","实例数","实例时也可配置dn","实例时传入了一个","实例时，您可以指示它在部署任何ha部署之前需要一个quorum。该上下文环境中，一个","实例是集群模式的。","实例有一个文件系统对象，您可以使用","实例来使用服务发现模块：","实例来创建一个。","实例来创建认证处理器。auth","实例来说它是单例的。","实例来配置服务器：","实例正在运行两个verticle。","实例现在死了（您可以通过执行kill","实例的","实例的情况，或者您正在使用粘性会话。也就是说您可以配置您的负载均衡器来确保所有请求（来自同一用户的）永远被派发到同一个","实例的数据库名称。默认是","实例的数量。","实例的时候传入了一个","实例监听的端口。默认是","实例组合而成。不同的","实例组成一个集群需要一些时间（也许是几秒钟）。在这段时间内，我们不想去阻塞调用线程，所以我们将结果异步返回给您。","实例给它：","实例绝对不会在","实例维护了n（默认情况下n","实例维护了多个","实例维护的是","实例维护的线程不是守护线程，因此它们会阻止jvm退出。","实例能够共享同一个数据源，而不是单独为每个","实例能够让您读取在websocket","实例设置不同的数据源。","实例运行的地址。默认是","实例通过向","实例都有一个单独的","实例配置好后，您可以解析用户命令行来解析每个选项和参数：","实例配置成集群模式来获取集群模式的event","实例销毁的同时","实例集群在一起，它可以形成一个单一的、分布式的event","实例需要配置：","实例（vertx），则可以通过将","实例）","实例）来返回错误。一个","实例）被调用了多次，那么这些不同的","实例，你可以在这里配置消息传递的相关参数（如","实例，使用任意一个","实例，例如：","实例，则最好始终从该verticle的ev","实例，因为","实例，因为可以有多个具有相同名称的参数。","实例，因此您可以从任何","实例，在其中去处理它。","实例，它可以从","实例，它可以用来写数据到请求体和请求头。","实例，就可以发布服务了。发布的流程如下：","实例，并且已经配置好了host和port参数。","实例，您可以通过","实例，所以假设您已经有另一个已经启动的vert.x","实例，执行以下命令：","实例，无论您是要仅仅发送数据或者收发数据，这都是一样的。","实例，用于指定要连接的","实例，这些选项描述了访问文件的行为。例如：您可使用","实例，这意味着您可以泵送数据到任何","实例：","实时重部署","实现","实现。","实现。同时也支持","实现。由于","实现中（例如","实现了","实现了完整的","实现了这种模式。","实现依赖：io.vertx:vertx","实现拿到订阅者之后，将服务端的请求体泵入其中。其间背压机制将自动运行。","实现的","实现的并发组合不同，compos","实现的，所以配置内容和","实现（参考","实现，已经由","实现，这网络发现实现，需要开启组播。如果组播被禁用，可以采用","实用程序来管理java密钥存储。","实际上不同的","实际写入操作是异步的，它可能在调用返回一段时间后才发生。","实际的匹配过程如下：","实际的服务方法","实际的绑定也是异步的，因此服务器也许并没有在调用","实际的绑定也是异步的，因此服务器在调用了","客户端","客户端。","客户端为执行","客户端也可以轻松地配置为ssl。使用ssl和使用标准套接字具有完全相同的api。","客户端也可配置为信任所有证书：","客户端以及存储我们配置内容的","客户端会发送","客户端参数配置","客户端受信配置","客户端可配置成遵循http","客户端向同一个主机/端口发送很多请求。为避免每次发送请求时重复设主机/端口，您可以为客户端配置默认主机/端口：","客户端启用ssl/tl","客户端启用压缩","客户端和服务端","客户端和服务端。","客户端和服务端可以通过配置来使用","客户端和服务端都支持","客户端在连接","客户端实现。","客户端将不知道如何修复错误。","客户端将会执行最多达16次重定向，该参数亦可在","客户端将会把服务器信息转换成利于理解的","客户端执行","客户端执行一次查询或者发送一个","客户端推送","客户端支持开箱即用的","客户端支持连接池，它允许您重用请求之间的连接。","客户端支持通过http","客户端是很灵活的，您可以通过各种方式发出请求。","客户端的功能，需要先在本地解析","客户端的地址","客户端的最简单方法如下：","客户端的配置","客户端的配置参数一样：","客户端给需要与","客户端证书——client","客户端证书流程","客户端证书类型必须用于且仅用于机密客户端。","客户端请求中指定处理器","客户端还支持连接上的请求管道(pipeline)。","客户端连接","客户端连接使用代理","客户端连接到","客户端针对每个服务器都使用单一连接，同样服务器上的所有流都会复用到对应连接中。","客户端（httpclient）来访问配置仓库（请看下面的代码）。你也可以通过配置","客户端（生产者和消费者）和","客户端（通常是浏览器）之间实现全双工","客户端，因为他们不会通知他们何时离开集群，同时有可能丢失数据，还有可能将集群置于不一致的状态。更多情况请翻阅","客户端，因此需要依赖","客户端，您需要把下面的","客户端，需要添加下列依赖：","密码","密码套件可在netserveroptions或netclientoptions配置项中指定。","密码套件，该密码套件可以配置一套启用的密码：","密码证书——password","密码证书流程","密钥存储。使用jk","密钥库的位置，它只是一个常规的java","对","对tcp连接进行全面的配置。由于","对vert.x","对于","对于一个正在接收响应的客户端连接，如果一段时间内没有动作，则服务端会发出一个","对于一个输入的消息（例如通过客户端","对于一个输出的消息（例如通过服务器端发送给客户端","对于一些基于jwt","对于任意以","对于使用","对于大多数的应用，您应该不希望客户端的","对于客户端：","对于已经认证过的用户，你可以调用principal方法获取用户的凭证信息，获取凭证信息的内容同样取决于底层实现。","对于布尔值，布尔值将被评定为true:on，yes，1，true。","对于每一个","对于没有提供原生的跨域通信支持的浏览器，会使用","对于消费者(consumer)，api以异步的方式订阅消费指定的","对于生产者(producer)，api提供发送信息到指定","对于确定连接往返时间或检查连接有效性很有用：ping","对于第二个例子，处理器需要完成","对于返回值，服务需使用","对于这点，vert.x","对于通过订阅执行一个","对于阻塞型的可调度操作（block","对包进行处理","对应","对应一个","对应发送或发布的对象。消息的头信息可以通过","对应版本：vert.x","对应的","对应的回调函数（resulthandler）","对应的处理器（如果有）会被调用，以此类推。","对数据包进行处理","对此并不关心。","对用单个缓冲区：","对等连接重置","对象","对象(jsonobject)的形式取出。","对象。","对象。你可以通过调用httpendpoint.createrecord创建这样一个服务记录对象。","对象。如果端口监听失败，订阅者将会得到通知。","对象。它不仅包含了","对象。您可以通过","对象。该对象随后可用于撤销处理器、或将处理器用作流式处理。","对象。这也意味着您可以基于上下文里的任何信息来渲染模板，包括请求、响应、会话或者上下文数据。","对象。这是一个","对象。这是一个类似套接字的接口，您可以向使用","对象。这样，您就可以使用","对象。这这是一个","对象上注册一个","对象中。","对象中的所有键值对，则匹配成功。","对象中，有以下这些参数：","对象为参数调用处理器。","对象为基础，你可以创建一个","对象之前在","对象之间共享数据源。但有时候，却恰恰相反。","对象之间，共享一个数据源。","对象也支持","对象以在","对象传入，作为全局配置。","对象作为参数（最多6个，或者传入","对象作为参数，并返回预期类型的​​对象。","对象使用了相同的vert.x","对象共享数据源的情况下，这个数据源对象维护着一个引用计数器。一旦此数据源最后一个引用关闭后，这个数据源也就关闭了。","对象列表（list）的结果集，这样能让","对象变得更加便捷：","对象可以从被不同的线程安全地访问，但在相同的上下文中访问它们时，性能才是最优的。","对象可以被序列化/反序列化为嵌套的json对象。","对象可以轻松地转换为","对象后，我们可以通过","对象和","对象和相同的数据源名称，那么它们将共享数据源。","对象基本上只是一个","对象并填充字段值。如下所示：","对象或使用","对象打开并其传送到http","对象拥有不同的数据源时，可以采用这种方式来创建它的对象。比如它们要与不同的数据源进行交互。","对象提供了存储和读取共享数据的方法。举例来说，它允许您将数据传递到","对象提供了许多操作文件系统的方法。","对象时指定配置项","对象时，不要忘记关掉它（通过","对象来使用重定向处理器。","对象来实例化一个java","对象来实现文件读写。从现在开始，流不再与","对象来执行。通常来说这个","对象来指定配置选项。","对象来描述，通过这个对象可以获得名称、文件名、大小等属性。","对象来表述的。您可以通过它来获取名称、值、域名、路径或","对象来进行上述的配置。","对象来进行配置。","对象来配置参数。考虑这样一种情况，应用程序要运行在一个","对象来配置这个处理器的若干选项。","对象的","对象的一次性回调，请求错误同样会在","对象的几种方式。","对象的函数，这个函数返回一个布尔值（就是一个","对象的可写流对象。","对象的可读流对象，读到的是","对象的同时指定配置项：","对象的字段创建一个json","对象的引用。","对象的时候就直接指定它：","对象的时候指定数据源的名称：","对象的每个部分都包装着属于着这部分的属性。不在这个部分的属性，将会以其他的顶级对象部分展现：","对象直接设置处理器来接收到","对象编码成字符串","对象获取值","对象通过","对象配置来配置代理（包括代理类型、主机名、端口和可选用户名和密码）。","对象间的映射","对象（jsonobject）的形式返回，因此您可以用下边代码读取数据：","对象（jsonobject）进行配置。","对象（参考","对象（比如在","对象（用于传递参数）或参数值。","对象（用于包含额外的重要信息）。为了方便起见，我们可以使用","对象）来描述服务提供者提供的服务，它包含了服务名称、一些元数据和一个描述服务所在位置的位置对象。","对象，且下标为","对象，会在这些","对象，但使用的是相同的数据源。这时","对象，否则在vert.x领域中您做不了太多的事情。它是","对象，如下所示：","对象，如果没有则创建一个新的。您可以检查获取的","对象，它的","对象，必须包含","对象，您可以通过编程的方式来使用它的相关方法为用户授权。","对象，您可直接使用该内置对象，无需重新创建。","对象，您就可以在","对象，提供了增加、设置以及删除头属性操作的入口。http头的某些特定属性允许设置多个值。","对象，然后将引用传进这个方法里。","对象，这个操作符的作用是将","对象，里面需要包含操作需要的所有参数。","对象：","对配置仓库进行配置","对集群中","寻址","导致协议运行的不完整。","将","将buffer写入到一个socket或其他类似位置后，buffer就不可被重用了。","将http","将json映射成pojo","将offset挪到分区末端","将offset挪到分区起始端","将一个","将为每一个","将为每一个发送的","将会匹配所有","将会发生什么？如果两个","将会得到新的结果集，若没有，将会调用结束方法。","将会成功完成。","将会看到具体的计数。同理，也可以将i替换成hashmap等线程不安全对象，不需要使用concurrenthashmap或hashtable，可在verticle内部安全使用。","将会自动关闭这个","将会被作为原生类型（译者注：java.util.uuid）来处理。","将会被订阅，其内容将会被用于请求中。","将会被调用。","将使用","将使用groovy的factori","将使用javascript的factori","将保证用与调用该方法时相同的","将其发回客户端。","将创建一个新连接，否则直接将请求添加到队列中。","将发出通知。","将向","将响应定制成以下类型：","将在运行它之前对","将已经发布的服务记录注销","将所有以","将数据从可读流泵入","将数据刷新到底层存储","将数据回写","将数据放入map","将数组项添加到json数组","将无法得知服务器是否已写入）。","将添加以下头：","将熔断器指标推送到hystrix","将目标版本的","将第一步的服务接口、第二步第三步的实现类以及第四步中的服务描述文件打包成一个jar包，然后将这个jar包放到你应用的","将结果解码为json对象","将结果解码为json对象：","将自动关闭非","将自动发送确认，可设置处理器当收到","将自动计算并设置","将被调用：","将覆盖默认客户端设置：","将规则添加到","将请求顺序委托给其中一个服务器：","将键值对放入","将集群管理器配置成加密的或强制安全的。参考集群管理器的文档获取更多细节。","小而轻，您可以只使用您需要的部分。它可整体嵌入现存应用中。我们并不会强迫您用特定的方式构造您的应用。","尝试对ipaddress进行反向查找，这与解析ptr记录类似，但是允许您只传递ipaddress，而不是有效的ptr查询字符串。","尝试查找给定名称的","尝试查找给定名称的a（ipv4）记录。第一个返回的（记录）将会被使用，因此它的操作方式与操作系统上使用nslookup类似。","尝试解析给定名称的ptr记录，ptr记录将ipaddress映射到名称。","尝试解析给定名称的所有aaaa（ipv6）记录，这与在unix操作系统上使用dig类似。","尝试解析给定名称的所有a（ipv4）记录，这与在unix操作系统上使用dig类似。","尝试解析给定名称的所有cname记录，这与在unix操作系统上使用dig类似。","尝试解析给定名称的所有mx记录，mx记录用于定义哪个邮件服务器接受给定域的电子邮件。","尝试解析给定名称的所有ns记录，ns记录指定哪个dns服务器托管给定域的dns信息。","尝试解析给定名称的所有srv记录，srv记录用于定义服务端口和主机名等额外信息。一些协议需要这个额外信息。","尝试解析给定名称的所有txt记录，txt记录通常用于定义域的额外信息。","就","就不支持。这种情况下，建议使用","就会使计数器加1，访问","就会被调用。","就变成已停止状态了。","就变成已启动状态。","就是失败的。","就能跑起来！","尽力传输","尽力传输(best","尽管vert.x","尽管vert.x自身并不要求使用特定的许可模型（它本身只是使用了不透明的字符串），但mongodb认证中的实现使用了比较熟悉的：用户/角色/许可模型，这样在应用里你可以使用一个或者多个角色，而一个角色也可以拥有一个或者多个许可。","尽管我们已经知道，vert.x","屏蔽多播","属性","属性。","属性一致。","属性中记录了事件的类型，类型分为bind和releas","属性中记录了服务发现实例的id（服务发现实例的名称或节点id）","属性中，包含了服务记录信息","属性为","属性值为","属性包含连接","属性设置为","属性进行配置（默认为","属性链接着。一种简单的遍历所有结果集的方式如下：","属性，配置","属性，配置扫描的频率，扫描的单位是毫秒（ms），默认是","工作原理","工作，如","工厂方法来创建一个已经是失败状态并且包装着","工程中使用","已更名为","已经弃用","带请求体的非分块","带超时的发送","帧","帧。","帧不受流量控制限制","帧之前完成。","帧到远程的连接，要求其停止创建流：客户端将停止发送新请求，并且服务器将停止推送响应。发送","帧到远端：","帧后，连接将等待一段时间（默认为30秒），直到所有当前流关闭和连接关闭。","帧将会在连接关闭之前被发送","帧时发送通知调用处理器：","帧时，vert.x","帧，和关闭主要的区别在于它将只是告诉远程连接停止创建新流，而没有计划关闭连接：","帮助您快速地配置基于","常用的配置参数有下面这些：","并不支持","并不是","并且","并且\"color\"值为\"red\"的记录","并且完成了操作，您可以调用","并且添加一行表示工厂类的完全限定名称：","并且能够读取所选择的命名空间。","并且读取它：","并写入","并写入了","并占用了","并发合并","并在最后发出成功或失败的信号。","并在类路径上使用","并指定它的大小。这使得这个","并支持常用的","并查找会话信息，您不需要自己来实现。","并由其索引标识。例如，在java","并返回包含部署","库","库。它提供了类似","库来和","库来实现","库非常相似，vert.x","库，你的代码需要继承","库，这个库借助字节码增强(bytecod","库，这个配置就是用于指定这个","应用","应用、rest","应用、实时的（服务端推送）web","应用。","应用。应用类型的选择取决于您，而不是","应用中使用","应用中处理","应用中安全调用\"传统\"阻塞api的方法。","应用中记录日志","应用可以使用","应用实例化以及使用；它配置了一系列的配置仓库","应用层协议协商","应用提供了相应的接口。","应用的方式。","应用的时候需要添加","应用的构建模块。","应用的瑞士军刀。","应用程序","应用程序。","应用程序。但是，必须首先部署它所有的依赖。但有些连接池要求必须从","应用程序打包成","应用程序时，这样做是很常见的，因此我们提供了一个名为pump的帮助类，它为您完成所有这些艰苦的工作。您只需要给","应用程序通过","应用程序通过异步的方式，与任何支持","应用程序，强烈建议您直接使用vert.x","应用能够以异步、非阻塞的方式访问","应用进行数据持久化时的最佳选择，因为","应用）扩展到多核服务器上，则需要启动并且管理多个不同的进程。","应用，只需要加入下面的依赖：","应用，我们需要在所有处理器里设置","应用，或任何类型的您所能想到的","应用：","应答消息/发送回复","应该使用自己的客户端实例。","底层所使用的","废弃响应体。","建立连接，并发送/接收消息：","开发人员遵循","开发者可以通过","开启日志","开启服务端监听","开头。","开头的文件）。","开头的消息（例如","开头的请求。","开头的请求会被保护","开头的请求路由到模板处理器上","开头的请求过程中发生错误，会调用这个处理器","开头的请求都会对应到","开头的请求都会调用这个处理器处理，例如：","开头的请求，route会被依次调用。","开头，`content","开始","开始使用","开始的h2c直接连接。","开始，vert.x","异常。幸运的是，vert.x","异常处理","异步","异步rpc","异步协调","异步启动和停止","异步地","异步接口","异步文件访问","异步方法，仅通知调用是否完成，不返回结果","异步方法，包含jsonobject类型的返回结果","异步版本","异步结果支持","引入的新的api","引擎实现可以配置为使用","引擎选项可使用:","引擎选项可使用：","引用：http://vertx.io/docs/vertx","强制使用log4j日志记录","强烈建议在存储密码时使用哈希算法加密过后保存在数据库中，这个哈希值是在创建这一行记录时基于salt值计算的，应用中应该使用强壮的密码算法，在存储密码时绝对不要使用明文。","强烈建议在设置“salt\"值时候使用external选项。no_salt选项仅仅推荐在开发阶段中使用，不仅仅如此，column方式也不推荐，因为它会导致salt和密码都存储在了同一个地方！","归属与发布","当","当getsslengineoptions被设置时，使用该选项","当keystore没有被提供，执行将会回滚到一个不安全的模式同时签名并不会被验证，如果payload被外部的方法签名或加密后的情况下这是非常有用的。","当vert.x启用ha运行时，若一个运行了verticle的vert.x","当vert.x找不到文件系统上的文件时，它尝试从类路径中解析该文件。请注意，类路径的资源路径不以","当一个令牌过期后你需要刷新令牌，oauth2提供了访问令牌类accesstoken，它包含了很多实用的方法可以在令牌过期过后对令牌进行刷新。","当一个处理器抛出异常，或者一个处理器通过了","当一个消息达到您的处理器，该处理器会以","当一个请求到达时，router","当从报文中读取到响应头时，响应处理器就会被调用。如果收到的http","当你不再需要","当你使用令牌访问完成过后想要注销，你可以撤销（revoke）访问令牌和刷新令牌。","当你写好服务接口以后，执行构建操作以生成代码。然后你需要将你的服务“注册”到event","当你在容器或云上部署你的服务时，可能你不能确定公开的ip地址和端口。所以，服务的发布必须通过其他拥有这些信息的实体来进行，这通常是一个桥接对象（bridge）。","当你将一个docker容器与另外一个docker容器链接在一起(link)的时候，docker将会注入一组环境变量。该桥接器将分析这些环境变量，并且针对每个链接(link)，生成一个服务记录。服务记录的类型从service.type.lable属性中推断；如果没有设置，那么服务类型将被设置为unknown。目前暂时只支持","当你的服务发布（expose）以后，你可能想要去调用它。这时，你需要创建一个服务代理，而代理的创建可以利用","当你选择好了服务记录后，你就可以获得到一个servicereference，然后得到服务对象：","当使用","当使用json过滤器，设置status属性为你想要的值（或者","当使用udp时，ip多播是必需的，在一些系统中，多播路由需要被添加到路由表中，否则，缺省路由将被使用，请注意，有些系统并不适用路由表中的ip组播路由，只为单播路由","当使用vert.x的高可用功能时，您可能需要创建一个vert.x的","当使用vert.x运行实例时，还可以选择指定的ha组。ha组表示集群中的逻辑节点组。只有具有相同ha组的节点能执行故障转移。若不指定ha组，则使用默认组__default__。","当使用传统的阻塞式api做以下操作时，调用线程可能会被阻塞：","当使用函数过滤器，将","当使用同一个名字创建了许多","当使用名称部署verticle时，会通过名称来选择一个用于实例化","当使用名称部署一个","当使用完后，释放绑定的服务","当使用搜索域列表时，点数的阈值为1，或从linux上的/etc/resolv.conf加载，也可使用","当使用服务引用的方式，你需要如下方式：","当使用服务描述符来部署一个服务时，任何属性如worker,isolationgroup等不能被在部署时传递的部署参数所覆盖。","当使用这种实现作为认证时，它需要在认证信息里获取username和password：","当使用隔离组时，您需要用","当关闭操作完成后，绑定的处理器将被调用：","当创建datagramsocket时，您可以通过datagramsocketoptions对象来设置多个属性以更改它的功能。这些（属性）列在这儿：","当前只适用于","当前文档翻译对应版本：vert.x","当前的","当前进度","当发送带有应答处理器的消息时，可以在","当发送请求体为","当向响应中写入响应消息头时，cooki","当启用http","当启用管道时，请求可以不等待以前的响应返回而写入到连接。","当启用连接池创建请求时，若存在少于已经为服务器创建的最大连接数，vert.x","当启用高可用方式时，不需要追加","当响应体的某部分（数据）到达时，handler","当响应结束时，vert.x","当响应结果较大时，请使用","当响应被成功接收到之后，相应的回调函数将会被触发。","当回调失败时，观察者的","当回调成功时，观察者的","当在同一个","当在网络上的不同vert.x","当基础认证处理器收到了这些信息，它会使用用户名和密码调用配置的","当多个","当客户端想要申请访问控制之下受保护的资源时，或者其他资源拥有者先前被授权服务器托管时（这种方式超出了本文范畴），客户端仅仅可以使用客户端证书（或者其他表示认证含义的信息）申请访问令牌。","当客户端收到100响应代码则可以发送剩余请求体","当客户端试图注册一个处理器时会发生该事件。","当客户端试图注销一个处理器时会发生该事件。","当客户端连接到","当客户端连接到http","当客户端需要使用连接池并使用超过一个连接时，则可使用sethttp2maxpools","当对服务端创建","当尝试为一个指定名称元素获取a（ipv4）或","当帧到达时，会传入一个websocketframe实例给帧处理器，并调用它，例如：","当建立连接时，客户端和服务器交换初始配置，初始设置由客户端上的","当开发非单页面应用，并依赖客户端来发送","当您使用","当您写入请求时，第一次调用","当您创建会话存储之后，您可以创建一个会话处理器，并添加到","当您在与现有服务器相同的主机和端口上部署另一个服务器实例时，实际上它并不会尝试创建在同一主机/端口上侦听的新服务器实例。","当您希望限制每个连接的多路复用流数量而使用连接池而不是单个连接时，可使用","当您想要在任何时间只在集群一个节点上执行某些操作或访问资源时，这很有用。","当您有很多处理器的情况下，合理的方式是将它们分隔为多个","当您用完锁后，您可以调用","当您编辑资源（如html、css或javascript）时，这种缓存机制可能令人讨厌，因为它仅仅提供文件的第一个版本（因此，若您想重新加载页面，则不会看到您的编辑改变）。要避免此行为，请使用","当您获取了这个","当您获取的数据库连接，其自动提交选项（auto","当您需要更改请求时，可用","当您需要监听一个特定地址和端口时，您可以像下边这样：","当我们创建了处理器之后，我们设置了","当我们希望不同含义的","当我们希望不同含义的客户端对象拥有不同的数据源时，可以采用这种方式来创建它的对象。比如它们要与不同的数据源进行交互。","当我们希望不同含义的客户端对象拥有不同的数据源时，可以采用这种方式来创建它的对象，比如它们要与不同的数据库进行交互。","当我们用这种方式写服务模块的时候，需要写很多重复的模板代码来监听event","当所有当前流已经关闭并且可关闭连接时，shutdownhandl","当接收到","当接收到自定义帧时，不论请求是否暂停，自定义帧处理器都将立即被调用。","当接收者收到消息并且已经被处理时，它可以选择性决定回复该消息，若选择回复则绑定的应答处理器将会被调用。当发送者收到回复消息时，它也可以回复，这个过程可以不断重复。通过这种方式可以允许在两个不同的","当描述一个角色使用通配符*时，说明这个角色拥有所有的权限。","当操作完成时，回调方法将会被执行：","当整个响应体被完全读取或者无响应体的响应头被完全读取时，响应的","当整个请求（包括任何正文）已经被完全读取时，请求中的","当新的","当更新结束时，将执行回调方法处理结果。更新结果包装在","当服务发现实例被关闭的时候，对应的桥接器也一块被关闭了。执行关闭操作的时候，服务发现组件会调用","当服务器准备推送响应时，推送响应处理器会被调用，并会发送响应。","当服务器处理请求时，它可以向客户端推送请求/响应：","当服务器接受","当服务器每次接收到上传请求时，该处理器将被调用一次。","当服务器没有及时回应时，尝试从列表中选择下一个解析器，搜索（数量）的限制由setmaxqueries设置（默认值是4个查询）","当服务提供者准备好可以提供服务时，会发布一条服务记录，在服务停止的时候，会收回这条服务记录。","当查询结束时，将执行回调方法处理结果。查询结果包装在","当桥接器注册后，start","当泵首次创建时，它不会启动，您需要调用","当浏览器发送了携带消息头","当消息体处理器匹配到请求时，所有上传的文件会被自动地写入到上传目录中，默认的该目录为","当消费者需要从","当然你也可以在","当然在内嵌","当然，如果不愿意的话，你也可以不用服务代理类来访问远程服务。被广泛接受的与服务交互的方式就是直接在event","当熔断器决定尝试复位的时候（","当熔断器在熔断状态中，对其调用会立即失败，不会执行实际操作。经过适当的时间（setresettimeout","当熔断器熔断时将调用此处代码","当用户提交登录表单，服务器会处理用户认证。如果成功，则将用户重定向到原始的资源上。","当用户请求一个需要授权的资源，基础认证处理器会返回一个包含","当编写一个vert.x应用时，你可能想将某个功能在某处隔离开来，并对应用的其它部分提供服务。","当订阅时，bodi","当试图将一个客户端消息发布到服务端时会发生该事件。","当试图将一个客户端消息发送到服务端时会发生该事件。","当试图将一个服务器端消息发布到客户端时会发生该事件。","当该功能启用时，会根据客户端请求的消息头","当请求到达时，vert.x","当请求到达时，我们设置了响应的","当请求到达，访问了会话，并且在响应完成向会话存储回写会话时，会话会被标记为被访问的。","当运行集群模式时，需要确保","当运行集群模式时，需要确保vert.x使用正确的网络接口。当通过命令行模式时，可以设置clust","当返回的是","当这种情况发生时，vert.x会检测到并记录下边警告：","当这种情况发生时，它会将消息回复给发送者并且在发送者中调用应答处理器来处理回复的消息。","当连接建立时，处理器将被调用并且传入","当连接成功时，您可以在回调函数中处理得到的","当通过编程模式使用","当部署一个服务时使用service:，选择服务verticle工厂。这个verticle可以通过编程的方式部署,例如:","当部署一个服务时，这个服务工厂首先在classpath中查找这个文件描述符。这个文件描述器就是服务名加.json。","当需要提供文件的一部分，从给定的字节开始，您可以像下边这样做：","待","待撤销证书颁发机构","很像，但它并不是由一个","很多时候我们需要在集群范围内维护一个原子计数器。","很多时候，vert.x","很容易定位此类offset。","很有可能是使用了错误的网络接口。","很类似。","很自然地，messageconsum","循环有点奇怪，我们必须按顺序选择正确的本地化方式","微服务，但我们不强制您必须把应用实现成这样。","必须","必须与","必须为服务器或客户端配置ssl/tls才能正常工作。请参阅ssl/tls章节来获取详细信息。","必须是一个","必须通过","快速序列化和反序列化","您不能在您的","您不能在普通的处理器里执行这些操作，所以我们提供了向","您不需要在处理器执行完毕时调用","您之前也许听说过它，例如","您也可以不设置处理器而使用","您也可以以编程的方式在嵌入vert.x","您也可以使用","您也可以启动裸的vert.x","您也可以和调用write方法一样传","您也可以在","您也可以在处理事件时修改原始的消息内容，例如修改消息体。对于从客户端发送来的消息，您也可以修改消息的消息头，下面是一个例子：","您也可以捕捉通过正则表达式声明的路径参数，下面是一个例子：","您也可以标记您的","您也可以用通配符匹配顶级的类型（top","您也可以通过","您也可以通过直接发送故障状态代码来拒绝该请求：这种情况下，请求体应该被忽略或连接应该被关闭（100","您也许注意到前边的例子里使用了一个流式（fluent）的api。","您亦可使用配置选项来创建客户端：","您亦可在其它vert.x支持的语言中使用vert.x","您亦可通过","您会在读取任何正文","您可以为锁设置一个超时，若在超时时间期间无法获取锁，将会进入失败状态，处理器会去处理对应的异常：","您可以从","您可以从json格式的字符串创建一个json数组：","您可以从通过一个map创建json对象：","您可以传入一个","您可以使用","您可以使用isvalid来检查commandline是否有效。","您可以使用下边命令创建一个bare实例：","您可以使用响应对象回写一个响应到","您可以使用消息体处理器","您可以使用特定的顺序值覆盖默认的顺序。如果您需要确保一个","您可以使用路径或者同时使用路径和方法来转发。注意，基于方法的重定向可能会带来安全问题，例如将一个通常安全的","您可以使用静态资源处理器","您可以像下边代码打开一个","您可以创建自己的主类并在","您可以利用","您可以向","您可以在","您可以在socket上调用","您可以在服务器端设置一个处理器，这个处理器会在每次客户端创建连接时被调用：","您可以在请求方法中指定处理器或通过","您可以实现","您可以对","您可以对认证处理器配置访问资源所需的权限。","您可以将","您可以将系统属性vertx.disablefilecaching设置为true，禁用此（文件）缓存行为。文件缓存的路径默认为.vertx，它可以通过设置系统属性vertx.cachedirbase进行自定义。","您可以执行这段代码，并打开浏览器访问","您可以指定一个","您可以用","您可以用不同的方式来组合上述的路由规则，例如：","您可以用其他语言的前缀来指定verticle的名称进行部署。例如：若verticle是一个编译的groovi","您可以用模板处理器来渲染错误信息，或者使用","您可以直接使用","您可以直接通过","您可以看到，您可以使用cli.create创建一个新的cli。传递的字符串是cli的名称。创建后，您可以设置摘要和描述，摘要的目的是简短（一行），而描述可以包含更多细节。每个选项和参数也使用addargument和addoption方法添加到cli对象上。","您可以设置一个","您可以调用","您可以调用reject","您可以调用其中任意一个","您可以较长时间的持有客户端对象（比如在","您可以通过","您可以通过一个","您可以通过下面的代码获取","您可以通过以下命令以集群模式运行","您可以通过依赖管理器来获取客户端库：","您可以通过在","您可以通过如下方式开启分块模式：","您可以通过实现自己的","您可以通过将一个","您可以通过绑定","您可以通过设置系统属性","您可以通过调用close方法来关闭socket，它将关闭socket并释放所有资源。","您可以通过调用桥接器时传入的","您可以配置","您可使用","您可使用以下方式填充请求头：","您可使用缺省设置创建一个","您可对每个请求单独设置：","您可用以下链式方式向请求uri添加查询参数","您可调用","您可通过","您可通过以下方式创建一个具有默认配置的","您同样可以使用","您同样可以使用编程的方式去注册或注销verticl","您同样可以指定","您同样可以重写","您在此不会找到诸如数据库访问、授权或高层web应用的功能。您可以在vert.x","您在消息处理器中接收到的对象的类型是","您在用完连接后，必须使用","您应该阅读","您必须在响应结束之前调用","您必须通过使用特定的","您提供处理器给vert.x","您有以下几种方式来创建客户端：","您甚至可以不必编译","您的","您的一个选项可以被标记为“帮助”。如果用户命令行启用“帮助”选项，验证将不会失败，但是可以让您有机会检查用户是否需要帮助：","您的应用中的不同部分通过","您的应用处理","您的应用处理器","您的登录页需要","您经常需要为所有以某些路径开始的请求设置","您自己的应用处理器","您要等多久？它取决于您的应用程序和所需的并发数量。","您还可以从异步map中删除条目、清除map、读取它的大小。","您还可以使用","您还可以使用一下方式列出后台启动的vert.x应用程序：","您还可以使用下边方式设置系统属性：","您还可以使用注解定义cli。在类和","您还可以使用泵将文件内容写入到http","您还可以像下面这样，在创建一个客户端实例的时候指定数据源的名称：","您还可以像下面这样，在创建一个客户端的时候指定数据源的名称：","您还可以创建","您还可以在后台启动应用程序：","您还可以在重新部署周期中挂接（hook）构建过程：","您还可以指定一个索引值，通过","您还可以控制","您还可以提供您将传递给","您还可以通过","您还可以通过系统属性vertx.disablefilecpresolving设置为true来禁用整个类路径解析功能。","您还可用","您还需要实现一个","您还需要配置用于处理登录页面的处理器，以及实际处理登录的处理器。我们提供了一个内置的处理器","您需要一个","您需要保证","您需要保证消息体处理器能够匹配到所有您需要这个功能的请求。","您需要在创建模板处理器时提供您需要使用的模板引擎的实例。","您需要在匹配的","您需要在您的项目中添加这些依赖来使用","您需要将表单的属性设置为正确的值。填充这个值唯一的办法是通过上下文来获取键","您需要手工提供所有关于您所使用的提供商的细节，但结果是一样的。","您需要提供一个会话存储对象来创建会话处理器。会话存储用于维持会话数据。","您需要确在您的","您需要设置","您需要通过","想成","想要将数据写入","想要正确地生成服务代理类，服务接口的设计必须遵循一些规则。首先是需要遵循异步模式。如果需要返回结果，对应的方法需要包含一个","想象成字节数组（译者注：类似于","意思是，如果此文档不存在，就保存此文档，此文档存在就更新。","意思是，如果此文档不存在，就保存此文档；此文档存在就更新）或者仅仅只更新，请使用","成为其发现协议，代码如下：","成功!","成功得到结果，则该","成功执行完成，得到的","成功执行（或任一失败），ani","成功放入值","成功的","成功读取值","成功！","成功，它只意味着它可能已经写入了网络堆栈，但不保证它已经到达或者将到达远端。","成功；当所有的","我们不会在会话","我们不会将所有的内容重写成异步方式，所以我们为您提供一种在","我们不知道用户的语言，因此返回这个信息：","我们不需要重定向","我们为","我们也可以使用launcher来替代main类，这也是官方推荐的方式，修改build.gradle如下：","我们也可以使用launcher来替代main类，这也是官方推荐的方式，在pom.xml中加入main.verticle属性，并将该属性值设置为maven","我们会在本手册里讨论所有上述的特性。","我们会每隔一段时间发送一个心跳包，用来避免由于请求时间过长导致连接被代理和负载均衡器关闭。默认的每隔","我们使用shiro提供基于身份认证属性和ldap开箱即用的支持，你也可以使用插件，在任何其他的期望用户名和密码作为凭据的shiro","我们创建了一个","我们前边提过","我们力求做到第一境界即可。信：即译文要准确，不偏离，不遗漏，也不要随意增减意思。","我们只想要60秒之前的消息的offset","我们可以从","我们可以利用","我们可以将这个","我们可以用类似的方法来创建","我们可以较长时间的持有","我们可以通过","我们可以通过一个","我们在","我们将在下一节中介绍如何加入多播组，从而接收数据包。","我们将这种模式称为","我们已经快达到我们的目标，但还没有完全实现。现在","我们有三个节点，这是","我们来假设您希望所有路径为","我们来看一个例子：","我们来看一个简单的例子：某个程序要求，当前线程发送一个请求给网络上另外一个服务器，然后获取到结果之后作出相应的处理。那么此时有一个明显的io操作，就是发送网络请求并等待对方返回结果。因为网络的速度要远远慢于内存处理的速度，所以此时的操作便是非纯粹内存操作，就有可能造成线程的阻塞，那么此时应该将这个操作交给其它线程予以处理，在处理完成之前，释放当前线程，等处理完成之后，再由当前线程执行回调函数。vert.x自带的网络客户端（netclient，httpclient等）已经帮您包装好了这部分逻辑代码，直接使用netclient等客户端，vert.x就会将发送请求并等待返回结果这部分代码交给另外一个线程予以执行，此时这另外一个线程是内核线程，这部分的异步处理由jvm以及操作系统完成，您不需要自己定义一个线程并执行。类似的，数据库的处理同样涉及io操作，所以vert.x自带的jdbc客户端（jdbcclient）会帮您完成这部分的封装，您只需要直接调用jdbcclient的各种api便可完成操作，此时有可能是其它进程中的线程，比如postgresql会使用进程池来建立连接池，但是该线程亦不需要您去创建，vert.x帮您完成了这些操作。类似的，硬盘上的操作，比如文件系统的api，也有可能造成阻塞，所以vert.x的文件系统api提供了非阻塞api，但是值得说明的是，硬盘上的操作，如果只是少量操作，执行时间上也不会明显超长，所以vert.x同时提供了硬盘操作的阻塞和非阻塞两种api。最后我们来看一个纯粹内存操作同时又是阻塞的例子。","我们来看看相关代码：","我们现在想象一个客户端，如下：","我们用","我们用服务记录","我们称之为","我们还可以像下面这样，在创建一个","我们还可以生成固定尺寸的块，如下：","我们需要对","我们首先需要一个","或","或worker","或一个其他通用请求方法，如","或事情更简单","或从输入流读取文件是阻塞的。所以为了避免每次都付出代价，vert.x","或使用fluent的api","或使用绝对路径：","或其他类型的静态资源。","或可以在调用","或可序列化对象。因为这些值需要在集群中进行序列化。","或可称之为不可枚举的。可防止碰撞攻击。","或在调用","或完整的域名","或您可以使用","或您可使用","或者","或者postgresqlclient.createnonshar","或者你甚至可以重定向到一个不同的verticle工厂。例如，这个maven","或者使用编程方式部署您的","或者其它任意支持的类型。","或者可以在创建这个","或者在创建","或者当响应已被完全读取时，您可以使用","或者您发现自己使用相同的客户端向不同主机的主机/端口发送大量请求，则可以在发出请求时简单指定主机/端口：","或者您可以自己读取受信存储到buffer，并将它直接提供：","或者执行密集计算。","或者调用","或者，vert.x","或者，您可以使用setidletimeout设置空闲时间——这个时间内没有使用的任何连接将被关闭，注意，空闲时间以秒为单位，不是毫秒。","或者，您可以编辑位于","或者，您可以自己读取密钥库到一个buffer，并将它直接提供给","或者，您可使用setidletimeout设置空闲时间——在设置的时间内然后没使用的连接将被关闭。请注意空闲超时值以秒为单位而不是毫秒。","截至：2017","所以不要这样做！这是一个警告!","所以您要怎么做？","所以，什么是","所以，如果你的软件运行在","所以，如果你运行在","所以，您发送和接收的数据包都要包含有远程的地址。","所传递的","所使用的授权认证机制。请参考","所有","所有以下路径的请求都会调用这个处理器:","所有工作都在","所有已经加入多播组","所有服务器启动完成","所有流被关闭，连接也关闭","所有的","所有的代码都是在相同event","所有的设置需要一个服务账号：","所有的请求都会调用这个处理器处理","所有的都失败","所有被合并的","所有访问根路径","所有路径为","所有路径以","所有返回的结果，都可以在回调方法中得到。","所有这些对您是透明的，您只需要简单地使用类似","所有这些都可以从","所有这些错误都由dns服务器本身“生成”，您可以从","所有都成功","所监听的地址和端口的","所监听的地址和端口的数据报，同时也可以接收被发送到该多播组的数据报。","所表示的类型来返回相应的结果。","手动提交偏移量","才能正确的挑选出","打包和部署vert.x的独立服务。","打开","打开连接超时的时间，单位毫秒。默认为10000（10","打开选项","执行","执行。","执行一个复杂的计算，占用了可感知的时长","执行一个长时间数据库操作并等待其结果","执行上传处理","执行上面的脚本，将返回一个","执行其他操作","执行其他有用的任务。那您该怎么做？","执行周期性/延迟性操作","执行命令","执行块中接收","执行失败时，得到的","执行失败，则返回一个","执行打包成","执行某些同步的耗时操作","执行某些处理","执行某些操作","执行某些操作...","执行某些阻塞操作","执行查询","执行模型。","执行该测试案例便可得到期望的结果，理解测试代码并不难，留给读者作为练习。","执行请求","执行这种请求最简单的方式是使用加了","扩展","扩展到客户端的","扩展库需要执行一些可调度的操作，例如","扩展的","批量操作","批量操作能执行一组","批量调用语句","批量预编译操作","技术完成的。","把从","把数据从这个流泵到一个","拒绝","拒绝该消息","拥有多个实例化的对象，但是您希望每个","拥有多个实例化的对象，但是我们希望每个","拷贝buffer","拷贝完成","拷贝文件","挂载到另一个","指","指允许同一个","指向这里。","指定offset位置10","指定一个外部文件为自定义配置文件","指定一个计时器id并调用","指定了一个处理器，所有的请求都会调用这个处理器处理。","指定客户端的密钥/证书","指定排序字段。默认为","指定数据源","指定数据源名称","指定服务器信任","指定服务端的密钥/证书","指定的","指定端口和主机名","指定返回哪些域。默认值为","指定返回的数据条数。默认值为","指定集群管理器。","指通过","捕捉路径参数","换句话说，桥接器的行为像是配置了","授权","授权authorisation：用于验证用户是否拥有访问系统的许可。","授权处理器","授权的密码","授权的用户名。默认为","授权码——author","授权码授权类型可以用来获取访问令牌（access","授权码流程","授权码流程主要包含两部分内容：","授权通过权限来保护资源不被未为授权的用户访问。","授权：bearer","排序的语言偏好列表的方法。","接下来的这些配置属性是用来配置一个ldap","接下来讨论","接下来，我们一起来看下创建","接口(数据结构)","接口。","接口。您可以使用泵将数据与其他读取和写入流进行数据泵送。例如，这会将内容复制到另外一个asyncfile：","接口。请注意，这些操作适用于任何实现了readstream和","接口中的","接口中的辅助方法来完成服务对象的查找和获取：","接口创建一个","接口创建一条服务记录","接口创建服务记录","接口定义了操作客户端的api","接口将被选择，而不是正确的接口。","接口就可以了。比如，vert.x还通过实现该接口提供了基于redis的存储后端。","接口或","接口或者第一步定义的接口的类，这个类必须有一个","接口提供了","接口提供了处理http","接口提供了实现类","接口提供的辅助方法直接获取。","接口数量的增长，设置","接口时，你可以通过如下方式获得代理对象：","接口来表示数据库连接（译者注：此接口中包含各种基本的操作方法）。","接口的","接口的java","接口的实现类包括：httpclientresponse,","接口的实现：","接口的对象，包括http","接口的方法来同步地接收事件。","接口的辅助方法来查询和获取服务对象：","接口的辅助方法来获得服务代理。","接口的辅助方法，来查询和获取服务对象：","接口继承了","接口，代码如下：","接口，因此您可以将它套用（pump）到其他的读写流上。","接口，因此您可以将文件和其他流对象配合","接口，因此您可以将请求体读取到任何","接口，将两步合并成一次方法调用。","接口，我们可以在写入之前检查","接口，然后再使用","接口，相应的，任何可控制的读取流对象都实现了","接口，这意味着您可以从任何","接收","接收传入连接的通知","接收到数据时，会以","接收到的是事件流，例如","接收和解析","接收多播数据包","接收数据报包","接收缓冲区大小（so_rcvbuf）。默认为","接收者调用了","接收者：","接收自定义","控制台中显示","推断出来的。如果该属性没有设置，那么服务类型被设置为unknown。目前暂时只支持","推荐命名：com.mycompany.services.clev","推送main.js到客户端","推送响应处理器客户能会接收到失败，如：客户端可能取消推送，因为它已经在缓存中包含了","描述option和argument类是无类型的，这意味着仅读取string值。","描述了处理器能够处理的","描述的方式获得最后插入的","提交表单","提供一个处理器。例如：","提供不止一种","提供了一个内置的叫做","提供了一个处理器","提供了一个开箱即用的处理器","提供了一个开箱即用的处理器来提供静态的","提供了一个服务发现的基础组件，用来发布和发现各种类型的资源，比如服务代理、http端点（endpoint）、数据源（data","提供了一个用于记录","提供了一个超时处理器，可以在处理时间过长时将请求超时。","提供了一种方法，允许您在一个操作中将文件从磁盘或文件系统中读取并提供给http","提供了一种配置","提供了一系列底层的功能用于操作","提供了一系列的配置存储支持和格式支持。更多的种类支持以扩展组件的形式提供，当然你也可以实现自己的扩展组件。","提供了下列功能:","提供了两种开箱即用的会话存储实现，您也可以编写您自己的实现。","提供了原版api的响应式版本，rxsend","提供了四种集群管理器实现：","提供了开箱即用的会话(session)支持。","提供了数个组件，可以使你的应用更具有响应性（reactive）。","提供了每一种模板引擎的配置。","提供了若干开箱即用的处理器来处理认证和授权。","提供了若干开箱即用的实现：","提供商会需要您来提供您的应用的","提供商需要作出少许的修改。为此，vertx","提供服务的对象的性质（服务代理、http","提供流(stream)的方式去获取配置。对应的流是","提供的","提供的一个简单的客户端","提供的一种服务类型，对应的服务对象是","提供网页图标","提供：","提倡使用服务器的单一连接，默认情况下，http","提醒：不要在生产设置中使用，这里生成的密钥非常不安全。","插件机制向jar包中添加服务代理注解处理器的配置。","插入文档","握手中的http","搜索域名","搭配其它工具包，使得编写不安全的应用程序成为可能，因此在开发时需谨慎，尤其是当您将其对公众发布的时候（如在互联网上发布）。","撤销verticl","撤销一个","撤销操作也是异步的，因此若您想要在撤销完成过后收到通知则可以指定另一个完成处理器：","撤销时自动被关闭。","操作","操作也能获得同样的流：","操作到底是","操作字符串的相关命令","操作接收到的消息","操作无序集合的相关命令","操作有序集合的相关命令","操作的结果以下面的方式提供：","操作符）供重组操作使用：","操作系统的hosts文件","操作系统的hosts文件用于对ipaddress执行主机名查找。","操作这里使用了阻塞型的调度器：","操作都将通过","支持","支持http/1.x","支持发布／订阅模式的消息队列。需要注意，一旦一个","支持基于","支持多种存储方式（文件、目录、http、git（扩展）、redis（扩展）、系统属性、环境变量等）","支持多种配置语法（json、properties、yaml（扩展）、hocon（扩展）等）","支持服务端模板渲染，包括以下开箱即用的模板引擎：","支持本地会话和集群会话","支持的一个新功能，可以为单个客户端请求并行发送多个响应。","支持的所有语言都是非常容易创建、读取和解析的，因此它已经成为了vert.x中的通用语(lingua","支持的类型（如","支持的编程语言编写，而且一个简单的应用程序也可以包含多种语言编写的","支持的配置仓库","支持自定义编解码器，从而实现","支持自定义配置处理顺序和配置重载(overloading)","支持请求超时","支持运行时重新配置(runtim","收到了一些数据","收到传入请求的通知","收到的record中有个status字段，用来表示服务的状态：","收到的消息是一个包含如下内容的jsonobject对象：","放在它的","故事从","故障排除","故障的数量","故障转移","故障转移仍然适用，并将使用列表中的下一个服务器。","故障转移（failover）。","数据块，分块传输、分块模式中会用到）","数据对象来配置。","数据库","数据库。","数据库主机地址，默认为","数据库交互的","数据库名称，默认为","数据库密码","数据库密码)","数据库密码，默认不设置。","数据库用户名","数据库用户名，postgresql","数据库端口，postgresql","数据报套接字","数据报套接字（udp）","数据源","数据源可以代表各种类型的数据库，而这些数据库的访问方式一般是不同的，服务记录很难有统一结构。在服务记录中，locat","数据源指的是数据库或数据存储。jdbc数据源通过jdbc驱动访问数据库，jdbc数据源服务对象是是","数据源服务","数据源服务共两个步骤：","数据源服务是专门为","数据源服务是专门为redis提供的服务类型，对应服务对象是","数据源服务需要两步：","数据类型","数组","数组中获取值","数组中获取值。例如：","数组同样可以包含","数组是一个值的序列（值的类型可以是","数组编码成字符串","文件","文件。","文件。如果想在","文件。此配置文件必须是一个","文件。这意味着您可以将图标打包到您的应用的","文件上传","文件中):","文件中)：","文件中）：","文件中）：compil","文件列表。","文件所在的根结点路径","文件描述符文件是一个简单的text文件，内容为有效的json对象。json中至少必须提供main属性，用于指定实际被部署的verticle，例如：","文件系统支持诸如","文件系统访问","文件被移走（startfuture）","文件里）","文件（或","文件（这里是","文件（默认的jul记录时），这是一个标准","文件，但是如果加载","文件，可以通过设置","文件，并且设置","文档","文档。","文档中","文档手册","文档手册中的相关章节。","文档计数","文档，同时您又希望他可以作为","新的服务被导入","方式读取配置","方式返回","方法","方法。","方法。响应体编解码器将响应结果压入","方法。当您在一个","方法。您可以使用","方法。您可以在之后您需要的时间点调用它：","方法。示例代码使用了","方法。这种情况，它和先调用带","方法一样。例如：","方法一样它也会返回一个","方法一样：","方法一次性加载它，并直接将其写入响应。","方法上使用注解来定义：","方法不会更改","方法中。","方法中传入一个","方法中手工去撤销启动时部署的子","方法中设置一个处理器。","方法中读取。","方法中部署其他的","方法中阻塞等待其他的","方法中，传入的是","方法为此提供了一个解决方案。","方法为每一个","方法为每一个路由指定一个","方法为每个服务器配置连接池的最大连接数。","方法为观察者（observer）和事件处理器（handler）做了适配：","方法之后再调用无参","方法也会（在调用时）覆盖默认客户端设置。","方法也是异步的，一段时间过后它会通知处理器并传入结果。","方法从","方法从json","方法从json对象中获取值。例如：","方法从map读取数据。get","方法从上下文中获取任何对象。","方法从响应中查询响应的状态码和状态消息：","方法从响应中获取","方法从文件系统中读取并提供文件：","方法以便读取整个响应体：","方法以函数式的方式直接用","方法以及","方法以进行资源的释放以及移除导入/导出的服务。这个方法必须调用所传递的","方法会立即被调用。","方法会被调用。","方法会被调用）","方法会返回","方法会返回一个","方法会返回客户端上的连接请求：","方法会返回服务器上的请求连接：","方法传入一个","方法传递延迟时间和一个处理器来设置计时器的触发。","方法作用于顺序组合","方法使用jackson的","方法关闭","方法关闭即可，相关的资源会自动释放。","方法关闭它。这将关闭所有内部线程池并关闭其他资源，允许jvm退出。","方法关闭底层的tcp","方法关闭服务端。关闭操作将关闭所有打开的连接并释放所有服务端资源。","方法关闭连接：","方法写入头属性：","方法写入数据到","方法写入数据到socket：","方法写入请求，以下是一个例子：","方法创建","方法创建。它可以在多个","方法创建一个buffer的副本。","方法创建了一个","方法创建到服务器的连接。请指定服务器的端口和主机，以及用于处理","方法创建到远程主机的通道。","方法创建帧，并使用","方法创建的调度器钩子对象。对于","方法去向调用端发送回一个返回值","方法发送","方法发送http表单。","方法发送pojo（plain","方法发送一个缓冲体：","方法发送出去。","方法发送流式数据","方法发送消息时，event","方法发送相应的请求体。","方法只返回匹配到的第一个文档。","方法可以列出当前分配的","方法可以列出消费者下的所有","方法可以创建一个","方法可以创建这样一个实例。","方法可以同时向有序集合中添加多个member。需要注意","方法可以将值放入到json对象里。","方法可以将响应当成","方法可以添加多个","方法可以用来解析","方法可用于非标准方法，在这种情况下，rawmethod","方法可被重复多次调用，这使得配置以及重用","方法向上下文设置任何对象，使用","方法启用压缩，vert.x","方法和","方法和一个用来创建","方法和缓存的请求体执行重定向","方法在","方法在您的处理器中获取到该对象。","方法在每次写入时启用/禁用内容的自动同步。这种情况下，您可以使用","方法均不接收异常处理器做为参数。","方法声明的值进行比较。","方法处理","方法复制一份请求的拷贝：","方法多次：","方法完成成的。","方法完成的。调用这个方法时，需将想要执行的异步操作包装成","方法完成的，对于大文件处理通常更有效，而这个方法对于小文件可能很慢。","方法对到达的每个请求都提供了回调：","方法对此提供了一次性的回调：","方法将","方法将一个对象编码成字符串格式。","方法将会被调用，这样你可以对桥接器进行一些配置。当桥接器配置好了，已经准备导入导出初始的服务时，必须","方法将先将请求头写入到请求报文中。","方法将其写入websocket。","方法将其直接写入响应中并发回到客户端。","方法将其禁用。","方法将其转换成特定的类型","方法将创建一个能周期性发射事件的定时器并返回之。缺省情况下，这些可调度的操作由","方法将发送","方法将响应写入流。","方法将在注册时被调用。","方法将导致新的","方法将导致新的块被写入到报文，这种模式中，无需先设置请求头中的","方法将数据放入map。put方法是异步的，一旦完成它会通知处理器：","方法将文件和","方法将无符号数从","方法将版本设置成","方法将被调用。","方法将被调用，参数就是这个对象；且其后","方法将被调用，这个方法执行完成后","方法将额外的类路径添加到这里。","方法就可以了，它会自动的关闭与","方法并传递参数","方法引用","方法或","方法或者","方法手动刷新os缓存中的数据写入。","方法执行查询操作。","方法执行结束，将会调用回调方法。然后下一个事务也将自动开始。","方法执行重定向","方法执行预编译查询（prepar","方法执行，或者在worker","方法把连接返回给连接池。","方法抛出异常，则会立即跳转到","方法指定","方法指定一个地址去发布即可。","方法指定了","方法指定自定义状态消息。","方法接受多个","方法提供。","方法提供了带有","方法时加上了具有唯一名称的数据源参数。","方法时将","方法时指定主机和端口号，忽略配置项中的配置：","方法时指定主机和端口号，这样就忽略了配置项（中的主机和端口）：","方法时提供","方法时提供一个处理器。","方法时提供一个处理器。例如：","方法时绑定一个","方法时，它会关联一个","方法是异步的，你并不知道关闭操作什么时候完成或失败，这时你需要注册一个处理器(handler)来监听关闭完成的消息。当关闭操作彻底完成以后，注册的","方法是很适合的：","方法显式声明失败","方法显式指定集群管理器。","方法替换的是","方法有一个地方不同：beginningoffset","方法来串起一个带操作结果的或失败的","方法来保存文档。","方法来做这个事。这个版本的方法会以一个","方法来停用一个","方法来关闭","方法来关闭它。","方法来创建一个新的集合：","方法来创建可以在","方法来创建：","方法来删除单个文档。","方法来删除数据。","方法来删除文档","方法来删除文档。","方法来发送消息：","方法来发送该请求（结束请求）。","方法来取消一个周期性计时器。如：","方法来向会话中设置数据，通过","方法来向某个","方法来启动它。","方法来启动它即可。","方法来启用tls：","方法来启用。","方法来处理","方法来定期刷新生成器的种子，在","方法来应答这个消息。","方法来执行","方法来执行任何","方法来执行可调用语句（callabl","方法来执行更新数据库的操作（包括增、删、改）。","方法来执行此操作。当所有请求体被收到时，bodyhandl","方法来执行该操作：","方法来执行预编译更新（prepar","方法来找出真正被接受的","方法来拒绝一个","方法来指定","方法来指定对于一个登录用户，需要具有哪些权限才允许访问这个消息。","方法来指定阻塞式代码的执行以及阻塞式代码执行后处理结果的异步回调。","方法来提供一个您想隔离的类名列表。列表项可以是一个java","方法来插入文档。","方法来撤销部署好的","方法来更改。","方法来更改读取位置对应的偏移量：","方法来更新文档（译者注：建议使用","方法来替换文档","方法来注销处理器。","方法来组织代码最大的价值在于可以","方法来获取一个数据库连接。","方法来获取数据，通过","方法来获取返回的列。","方法来获得事件的类型，通过","方法来获得对应的","方法来获得所有的集合：","方法来获得数据库连接。","方法来获得服务器实际监听的端口：","方法来获得消息原始内容。","方法来获得被包装成了","方法来计算文档数量。","方法来订阅一个或多个","方法来设置。","方法来设置内存缓存的最大数量。通过","方法来设置用于读取数据的处理器。","方法来设置缓存的过期时间。","方法来设置阻塞式处理器。下面是一个例子：","方法来设置需要发送到服务器的raw方法。","方法来设置：","方法来访问会话对象。","方法来读取响应头。该方法返回的对象是","方法来读取实际的表单属性。","方法来进行流量控制：","方法来选择适当的","方法来部署verticle。","方法来配置。","方法来释放它，以便另一个调用者可获得它。","方法来重新启用它。","方法来链式地组合多个异步操作。在介绍这个方法的用途时，我们先考虑一个传统的同步操作和异常处理的方式。假设我们有一个同步的方法","方法来销毁一个会话。这会将这个会话同时从上下文和存储中删除。注意，在删除会话之后，下一次通过浏览器访问并经过会话处理器处理时，会自动创建新的会话。","方法查找文档。","方法查询到的第一条数据。","方法检查响应实际http版本。","方法注册一下。你可以通过第二个参数传递一些可选的配置信息给桥接器。","方法注册一个","方法注册处理器：","方法注销某个消息编解码器。","方法添加/删除命令","方法添加数组项到json数组中：","方法的一个参数，并且同时也必须包含在包装命令的","方法的一段时间之后才会实际开始监听。若您希望在服务器实际监听时收到通知，您可以在调用","方法的参数includeoutofservice设置为tru","方法的参数直接传进去，而不是在相关配置中指定：","方法的合并会等待所有的","方法的合并会等待第一个成功执行的future。compositefuture.ani","方法的响应中的请求体，它为请求体使用了","方法的时候，才会真正地根据","方法的时候，才会真正的根据","方法的返回值也是一个唯一的计时器id，若之后该计时器需要取消则使用该id。传给处理器的参数也是这个唯一的计时器id。","方法的返回值就是","方法目前暂未实现。","方法直接返回一个","方法相同。","方法相比，endoffset","方法类似，但是并不需要","方法绑定","方法绑定的回调函数将会被调用，其中传入的","方法编写头文件：","方法获取","方法获取asyncmap的实例。","方法获取buffer长度，buffer的长度值是buffer中包含的字节的最大索引","方法获取http","方法获取。","方法获取一个","方法获取一个实例：","方法获取一个服务引用或者通过","方法获取它。","方法获取所有匹配到的服务记录。默认情况下，服务查找只会包含状态为up的服务，可以通过如下方式覆盖默认设置：","方法获取指定","方法获取锁。","方法获取：","方法获得。结果集被包装成了一组","方法获得更新的数据条数，并且如果更新操作有生成主键，可以通过","方法获得查询结果的列名","方法获得消息体组成的新流：","方法获得适用的调度器：","方法被关闭过后，对应的","方法裁剪一个buffer。","方法让其他匹配的","方法让客户端持续发送请求体：","方法设置","方法设置。","方法设置一个周期性触发的计时器。第一次触发之前同样会有一段设置的延时时间。","方法设置一个处理器，每次请求体的一小块数据收到时，该处理器都会被调用。以下是一个例子：","方法设置不同状态代码。","方法设置成true。默认值为true。","方法设置文件的只读属性为","方法设置的模板来渲染文件列表。","方法设置自动提交为false。","方法设置超时时间。","方法设置配置项。默认情况下解压缩是被禁用的。","方法设置，此选项定义了发送到服务器的等待响应的最大请求数。这个限制可以确保和同一个服务器的连接分发到客户端的公平性。","方法访问","方法访问。","方法请求分配指定的分区：","方法读取uri中的路径部分。","方法读取请求中的","方法读取请求中的uri路径。","方法读取请求发送者的地址。","方法调用返回后一段时间才会完成部署。","方法运行的某些操作中：","方法返回","方法返回http请求中的参数信息。像","方法返回一个可被订阅的","方法返回客户端发送的实际","方法返回时监听，而是在一段时间过后才监听。","方法返回的名称，要和关联到自定义类型的","方法返回类型","方法返回过后一段时间才会发生。","方法进行封装，并且complete所传递的","方法进行手动提交。手动提交偏移量通常用于确保消息分发的","方法进行配置。","方法进行配置。默认情况下，未启用压缩。","方法追加数据到","方法退出该消费组，从而不再接受到相关消息：","方法通过","方法都会将索引值作为第一个参数","方法都会提供一次回调：","方法都对应","方法配置。","方法配置文件访问权限。","方法配置特定值。","方法配置的。","方法配置该选项接收多个值：","方法配置默认的verticle和命令","方法释放一个服务引用时，都会有事件发送到","方法里指明序列化与反序列化相关的类。","方法里自动完成，它会部署一个","方法隐藏选项，隐藏选项不在用法中列出，但仍可在用户命令行中使用（针对高级用户）。","方法需要传入一个","方法（这里的x指的是将返回的服务对象的类型）等等。可以查看","方法）","方法）。","方法）。它会把你配置的不同的服务导入/导出模块都关掉，并且释放服务引用。","方法，之后调用无参","方法，从这个","方法，以下是一个例子：","方法，但是","方法，但是仅仅返回","方法，但是在推送响应过后依然可以写响应。","方法，其返回的调度器可供","方法，在参数","方法，如果您想做一些耗时的","方法，它将会通过用户空间进行复制，因为若内核将数据直接从磁盘复制到","方法，对于这种情况，我们提供通用请求方法","方法，当vert.x","方法，当任务执行完成时设置下一个计时器。","方法，然后在整个请求体都被读取后，您可以使用","方法，用于获取给定分区末端的偏移量值。与","方法，这儿有个例子：","方法，那么当出现","方法：","方法；在需要回滚时，调用","无关）：","无法连接","无状态的server","无类型的服务","无论是否使用ssl/tls，服务器和客户端的api都是相同的。通过创建客户端/服务器时使用的","无论有没有用到服务代理，都应该用上面这种方式编写服务，因为这样允许服务交互时保持一致性。","无请求体的简单请求","日志、log4j","日志文档","日志来记录，或者也可以配置为","日志的记录是由netty而不是vert.x的日志来执行","日志记录","日志配置","日志，将会给予很大的帮助。在","日期和时间戳","早期版本的","时也适用。","时会被调用。","时作为参数提供的","时使用","时关闭","时和路径一起指定：","时失败","时它会被调用，这个方法执行完成后","时它都会被调用。","时将","时指定","时指定。","时指定正则表达式：","时收到通知：","时的序号，例如第一个","时直接调用","时被调用,","时遇到","时间戳被更新时会发生该事件。","时间类型","时，","时，out","时，停止","时，可以调用方法","时，处理原始响应","时，它们将共享同一个","时，它会将数据写入到","时，它的","时，将进一步去检查","时，应使用","时，您可以传递一个","时，您可以指定您想要部署的","时，此元素将被注册为输入参数","时，流量将通过未加密报文发送，因此若您有要发送的机密数据，而您的vert.x","时，设置了","时，请求失败时调用设置的异常处理器","时，请求将在它成功完成后发送","时，通过编程的方式创建","时，错误的传递也会变得更复杂。","时：","时：建立连接后，客户端将发送","明确配置仓库的顺序对于重载极为重要。对于冲突的键名，后面的配置值将替换掉之前的。举个例子，比如我们有两个配置仓库：","映射为","映射成","是","是verticlefactori","是一个","是一个json对象，包含访问redis数据源的属性（url、端口等）。","是一个与多种日志框架的桥接器。","是一个包含下面数据的","是一个包含了所有依赖项jar的可执行的jar，这意味着您不必在执行jar的机器上预先安装vert.x。它像任何可执行的java","是一个基于bsd协议开源的高性能key","是一个客户端的","是一个工具包，而不是来强迫您以某种方式做事情的框架。这赋予了开发人员以更强大的能力，同时也伴随着更大的责任（译者注：能力越大，责任越大，小蜘蛛他叔叔说的）。","是一个性能提示，并不是逻辑协议约束）：","是一个通用接口，不只是在","是一个通用接口，不只是在此客户端中有用到。","是一个顶级的","是一个高级功能，大部分应用程序不会需要它。由于这些","是一种web技术，可以在","是一系列用于基于","是一组工具集，其特点是在不阻塞内核线程的同时，允许用户以同步的方式接收事件、执行异步操作。","是不同的。当方法被调用时，它会返回一次性的","是临时的，当浏览器关闭时会被删除。","是使用","是分布式事务必须获得的最小票数才能被允许在分布式系统中执行操作的一个参数。","是可以读取或写入的0个或多个字节序列，并且根据需要可以自动扩容、将任意字节写入","是可以配置的，这对于以集群模式运行的","是可选的，并在消息中使用。","是否匹配，如果匹配则对应的处理器会被调用。","是否已满：","是否被删除或者分配。","是否运行在集群模式下，以及它的主机信息和端口。您可使用","是在","是基于","是失败状态的。","是并发的，您必须小心地使用标准的java多线程技术来保持","是强类型语言，并且我们又要避免使用","是您可以避免跨站点的伪造请求。","是成功状态的；当至少一个","是所谓","是流式的吗？","是独立于存储的，这意味着对于给定的存储","是用于","是由","是由用户命令行中存在的","是相同的，特定的api功能也可用于处理","是超轻量级的线程，并不是对应于底层的那种内核线程，它们被阻塞时不会导致内核线程也被阻塞。","是集群中特定组的最小节点数。通常您选择","是非常有用的。event","显式使用jdk","显示vert.x的版本","显著执行时间，那您应该去罚站（译者注：原文此处为","显著执行时间？","普通字符串","暴露。","暴露你的服务","暴露的","更多优点，比如使用","更多传输方式，以及如何配置它们，请咨询","更多传输方式，以及如何配置它们，请咨询jgroups文档。","更多关于quorum（多数派机制）的信息，请参考","更多服务接口的限制会在下面详解。","更多的参数，我们可以在","更多示例","更多详细内容，可以参考文档","更多配置信息请参考","更多：oauth2","更容易。","更改","更新已发布服务记录的状态（下线、服务暂停等等）","更新文档","更新语句（原生sql）传给数据库时，不会经过任何处理。","更简洁的","替代方案是，可以使用","替代，前提是在","替换为","替换文档","最后,","最后我们也可以通过","最后执行。","最后插入的数据id","最后调用端可以检查自定义的异常类型了：","最后，在第三个终端中，使用不同组启动另一个verticle：","最后，如您对响应结果不感兴趣，可用","最后，您可以使用","最大故障次数","最大连接数。默认为","最小心跳频率。默认为","最简单地使用所有默认配置项创建","最简单的使用模板的方式不是直接调用模板引擎，而是使用模板处理器","最简单的发送消息的方式是仅仅指定目的","最简单的注册处理器的方式是使用","最终创建的","有“冷热”(cold/hot)之分。区别在于","有一个服务器启动失败","有一个粗暴简单的判断同步还是异步的方法，就看给出的api或者方法中，是否有回调函数，如果有回调函数，且这个回调函数的参数是asyncresult，则可以判断该api或方法是异步的。","有一些依赖，若部署vert.x","有一段时间没有响应，将会自动记录这种警告。若您在日志中看到类似警告，那么您需要检查您的代码。比如：","有两种方法。","有了","有了这个接口，vert.x会生成所有需要的用于在ev","有些","有些时候您的","有以下方法：","有以下选项：","有关","有关更多信息，请参阅","有关更多详细信息，请查看recordparser类。","有关更多配置详情，请参考","有关详细信息，请参阅","有关详细信息，请参阅api文档。","有几种方式来创建客户端，我们一起来看下。","有可能只需发送","有多种日志框架，可以通过设置系统变量","有很多关于这方面的细节。","有时候","有时候您希望在多个","有时候您想只在特定时间内接收多播组的数据包。","有时候我们并不希望将所有数据一次性全部读入内存，因为文件太大或希望同时处理多个请求，希望每个请求仅使用最小的内存。出于此目的，web","有时您在运行时不知道发送请求的","有时您想要发送一个包含了请求体的请求，或者也许您想要在发送请求之前写入头部到请求中。","有时您需要在请求体中使用json格式，可使用","有更多信息，请参阅","有相同的顺序值，则会按照添加它们的顺序来调用。","有着丰富的","有类型选项和参数","有自己的机制；通过这三个类：io.vertx.core.streams.readstream","服务","服务事件","服务交互的方法。","服务代理介绍","服务代理假定event","服务代理类（servic","服务代理组件","服务代理组件提供的功能其实就是一种","服务代理组件的话，生成的代码会自动帮你处理这些问题。","服务代理组件，你就不必再写这么多的模板代码了，只需要专注服务的实现即可。","服务代理，服务对象是一个代理，它的类型是所代理的接口（其location表现为一个ev","服务使用者从实际被部署的verticle中解耦是很有用的，并且允许服务提供默认的部署参数和配置。","服务发布者和服务消费者都必须通过单独创建自己的","服务发现桥接器","服务发现组件中，我们通过","服务发现组件使用vert.x的分布式数据结构来存储服务记录。所以，集群中所有的成员都可以访问到所有的服务记录，这是服务后端的默认实现。你也可以实现自己的服务记录存储后端，只要实现","服务发现组件实现了面向服务计算中定义的服务交互。此外，在某种程度上，还提供了动态的面向服务计算交互，这样应用程序可以对各种服务的上线、下线作出反应。","服务发现组件提供了一些现成的服务类型，但你也可以添加自己的服务类型。","服务发现组件支持桥接的方式，来从其他服务发现技术中导入和导出服务。","服务发现组件通过实现","服务发现组件通过服务类型的概念来处理这种差异。每种服务类型都需要定义：","服务发现组件除了支持桥接器机制以外，还提供了一些现成的桥接器。","服务发现组件，需要将下列依赖加入到依赖配置中文件：","服务名。","服务名字是一个简单的字符串，可以随用户定义，但是建议用户使用域名反转的方式（如java包的定义），这样避免你类路径中的其他服务同名。例如：","服务名被用于查找json描述符文件，json描述符文件决定实际被部署的verticle，包含部署参数例如是否作为一个worker来运行等等。","服务器","服务器。","服务器与客户端","服务器中获取配置。","服务器中获得配置。","服务器会提供一个简单的页面（在目标域名上）并放置在一个不可见的","服务器信息","服务器准备推送响应","服务器列表轮询","服务器后，就可以使用","服务器响应对象是一个","服务器基本相同的事情，只是这一次换成了","服务器失败时，会尝试重连。所以，如果您连接的","服务器将从其中（算法）选择一个，您可以通过服务器发回的响应中响应头","服务器拒绝查询","服务器接收","服务器推送","服务器推送(server","服务器收到了一个请求","服务器故障","服务器每次收到一个http请求时这个处理器将被调用","服务器没实现","服务器的","服务器的地址和包含我们所配置的节点","服务器的版本必须","服务器的相关命令","服务器的请求处理器，使所有的请求都通过","服务器的默认端口为53，当服务器使用不同的端口时，可以使用冒号分隔符设置该端口：192.168.0.2:40000。","服务器运行在同一个域名下，因此不用担心跨域的问题。这个","服务器需要授权，或者您连接的","服务器，它使用","服务器，暂不涉及","服务器，然后创建了一个","服务器，请注意，您想提供文件和类路径之外访问的位置","服务器，需要配置一些参数。配置参数包装在","服务器：","服务处理器类（servic","服务存储后端","服务对象","服务对象为服务消费者提供了一条获取服务的通道，它有各种实现方式，比如一个代理对象、一个客户端对象、甚至某些类型的服务可能不存在这样一个服务对象。服务对象的表现有赖于服务的类型。","服务就是资源。有很多各种各样的服务，比如功能性的服务组件、数据库、rest","服务引用代表了一个绑定的服务提供者。","服务接口中不允许有重载的服务方法（即方法名相同，参数列表不同）。","服务接口的约束","服务描述符","服务提供者和发布者","服务提供者和消费者，必须创建他们自己的","服务提供者是提供服务的实体，而发布者的职责是发布服务记录，通过该服务记录来描述服务提供者的信息。服务提供者和发布者可以是同一个实体，也可以是不同的实体。","服务搜索的命名空间（默认是default）","服务方法可能会通过向方法的处理器（handler）传递一个失败状态的","服务是一种服务代理，是基于event","服务消费者","服务消费者在servic","服务消费者访问服务的步骤：","服务消费者通过传递一个过滤器来选择服务，有两种形式的过滤器：","服务的标签（label）都被映射为服务记录的元数据","服务的类型是通过tags推断出来的，如果有一个tag和已知的服务类型一样，那么就使用这种服务类型，如果没有匹配的，那么服务导入后将标记为unknown类型。目前暂时只支持http","服务的静态资源。这对于在生产环境中通过","服务端","服务端中的处理器总是在相同的","服务端共享","服务端可以使用证书颁发机构来验证客户端的身份。","服务端可以水平扩展到多个核，并且每个实例保持单线程环境不变。","服务端可以自由地使用自己支持的压缩算法之一进行压缩，也可以在不压缩的情况下将响应体发回。所以这仅仅是","服务端可能不支持","服务端和","服务端和客户端","服务端和客户端可以配置成和网络服务器完全相同的方式使用","服务端和客户端，则在撤销该verticle时，它们将自动关闭。","服务端和客户端，它们将会在verticl","服务端响应","服务端在同一个端口上监听时，vert.x","服务端建立连接。您不必关注浏览器或网络是否真的是","服务端时，它将向服务端发送其初始设置。设置定义服务器如何使用连接、客户端的默认初始设置是由","服务端的一个可能被随意忽略的提示。","服务端的基本概念是很有价值的。","服务端的方式如下：","服务端的最简单方法如下：","服务端的请求处理器（request","服务端请求(server","服务端连接","服务端通常向客户端提供证书，以便验证服务端的身份。","服务端里的","服务端，一种从磁盘中读取并提供文件的方法是将文件作为","服务端，如：","服务端，并设置了一个请求处理器。所有的请求都会调用这个处理器处理。","服务类型","服务类型。","服务要实现","服务记录","服务记录按照如下的步骤进行创建：","服务记录的元数据、甚至位置的格式，都有赖于服务的类型（详见后续章节）。","服务记录的名称就是服务的名称","服务记录的映射","服务请求对象允许您检索","服务调用端（client","服务（例如","服务，这个接口包含的方法遵循异步模式。在底层，服务调用是通过调用端向event","期望","未提供针对","本地会话存储","本地会话存储基于本地的共享","本地共享map","本地共享map仅允许将某些数据类型作为键值和值，这些类型必须是不可变的，或可以像buffer那样复制某些其他类型。在后一种情况中，键/值将被复制，然后再放到map中。","本地化","本地和远程地址","本地的map和分布式集群map","本客户端基于","本文将会建立一个基本的http服务器，并监听8080端口，对于任何发往该服务器以及端口的请求，服务器会返回一个hello","本次计划预计五月下旬完成。","本次计划预计五月中旬完成。","本着开源的精神，贡献先于索取，自愿自发的为社区，为社会贡献，才能为后人造福。","本组件基于如下几个概念：","本节将解释服务发现机制所涉及到的一些概念。","本节将详细介绍一下服务类型，以及如何使用服务发现框架已提供的几种服务类型。","本节讲述的是最基本的获取服务的方法。每种服务类型接口，都提供了快捷的方法，来简化获取服务的步骤。","本身不提供这样的检查，所以这取决于开发者您自身如何实现了。","本配置仓库仅支持","本项目的在线版本部署在","机制去消费消息。","机器禁用多播","机器禁用组播","权限","权限authority：它取决于一些特定的系统实现但对特定的模型不做任何要求；比如：许可/角色permissions/roles模型，可以使事情变得灵活。在一些实现中一个权限可以用来表述一个许可，如：有权限访问所有打印机、或特定打印机。在另外一些实现中则必须支持角色信息，通常使用一些角色信息对权限进行前缀role:命名/标识，如：role:admin。还有一些实现也许会包含更加复杂以及不同的模型来表述权限信息。","权限来列举产品","权限缓存","条目设置为您的main","来为您处理","来了解更多关于两个数据源的知识。","来人工指定会话被访问。","来代替","来使用会话功能是明智的。如果您尝试直接通过","来使用指定的","来使用此格式：","来使用此配置仓库。","来使用此配置仓库：","来使用调用","来做到这一点。","来关闭客户端实例。","来创建","来创建到","来创建认证处理器的例子：","来删除","来包装","来包装一个异步的代码块，例如：","来包装异步代码块","来包装这些配置，然后将其传入到","来启用/禁用，或在指定模式时调用","来启用tls/ssl。","来启用会话功能，并确保它能够在应用逻辑之前执行。","来告诉客户端可以发送请求的剩余部分。","来在磁盘上缓存通过","来处理。","来处理接收的消息：","来处理登录的问题。","来处理请求（如果有）。","来处理，不需要针对每一个异步操作都编写异常处理的逻辑。这对于编写复杂的异步流程时是非常有用的。","来处理：","来复用已经存在的","来复用现有集群：","来完成这个","来定义","来实现。","来实现您的应用是非常必要的。","来实现的。它提供了一系列和服务器端的","来实现，例如：","来实现：","来对","来对应异步回调，例如上文例子中的：","来导入。","来开启自动提交。","来执行映射。关于字段和构造函数的可见性的影响、对象引用的序列化和反序列化的问题等等可参考","来执行这些处理器。","来执行阻塞式行为，例如","来执行，而是由vert.x中的","来指定。例如：","来指定了：","来指定具体的实现，例子：","来指定消息体的最大字节数。这对于规避由于过大的消息体导致的内存溢出的问题很有用。","来指定：","来授权：","来接受发送的结果。这个结果其实就是一些元数据(metadata)，包含消息的","来接收所有的状态）","来描述。","来描述每个服务。","来提交","来提供网页图标。","来提供诸如","来提取文件是低效的。","来支持","来构建经典的服务端","来查找会话，因此您还需要包含一个","来标示一个会话。会话","来检测服务器是否适应这个正文。","来添加","来的数据泵入其中）。","来禁用。","来禁用文件缓存。","来结束这个","来维护任何您希望在处理器之间共享的数据。","来获取","来获取。","来获取更多信息。","来获取给定分区的起始偏移量。这个跟上面的","来获取请求的消息体，限制消息体大小，或者处理文件上传。","来获得。","来获得下一个结果集。如果有，stream","来获得异常对象","来认证用户。如果认证成功则该处理器会尝试用户授权，如果也成功了则允许这个请求路由到后续的处理器里处理。否则，会返回一个","来让您在","来设置。如：","来设置参数","来设置请求头：","来访问上下文数据。","来访问受保护的资源。","来说，会关联一个","来说，它会关闭底层的","来说，它将执行无延迟关闭，goaway","来读取由“run”或“bare”命令创建的vert.x实例","来运行阻塞式代码，您还可以在一个event","来进行匹配，并支持基于通配符的模式匹配。例如","来进行授权，可以","来进行通信。sockj","来通过名称获取","来避免这个问题：","来部署","来部署它。","来部署的服务是很重要的。因为每一次都通过","来配置。","来配置代理类型、主机名、端口、可选的用户名和密码。","来配置匹配规则，指定哪些输入和输出的流量是允许通过的。","来配置：","来验证它是否如预期的一样工作。","构建","构建包含命令的jar。确保包含了spi文件（meta","构建工具使用","构建方法","构造函数中的参数是连接到","构造函数的第二个参数是告诉","枚举类型来代表的）","某个","某些情况下失败处理器会由于使用了不支持的字符集作为状态消息而导致错误。在这种情况下，vert.x","某些情况下，使用异步","某些情况下，您的查询语句可能返回多个结果集","某些时候也被称为","某些时候您可能需要在处理器里执行一些需要阻塞","某些服务记录也可以不带有类型（servicetype.unknown）。通过这种服务记录，是无法获取到服务引用的，但是你可以通过服务记录（record）的location和metadata来创建连接的细节。","查找产品信息","查找各种服务","查找文档","查找服务","查找满足它需求的服务记录","查看帮助。","查询/审问","查询/审问阶段","查询单个文档","查询的结果包装成了","查询语句（原生sql）传给数据库时，不会经过任何修改。","查询超时时间（毫秒），默认为","查询辅助方法","查询部分应该是：","标准安全最佳实践","标准的java","标准的实现。","标示的请求，会使用通过","标记在关闭时或jvm停止时要删除的文件。","标识的命令行参数。选项至少必须有一个长名或一个短名。长名称通常使用","标识符","样例","样式模式（使用","根据","根据你自己的需要，你同样可以使用下边的方法改变mongodb中使用的默认集合（collection）和列（column）名称等信息：","根据您的集群配置，可能需要自定义集群管理器配置（默认为hazelcast）和/或添加集群主机","根据您的集群配置，您可能需要添加cluster","根路径","格式","格式。","格式。格式为：json","格式来发送消息。","格式的字符串创建json对象：","格式的支持。","格式的数据也能够一行行的处理，例如：","格式的消息。","格式的请求并将其映射为对象：","格式的配置","格式编码：","格式错误","框架而不是原生zookeep","桥接","桥接器","桥接器事件","桥接器可以从","桥接器可以从kubernetes（或者","桥接器可以使用","桥接器可以将","桥接器将会在启动(start)的时候导入所有的服务，在停止(stop)的时候移除所有的服务。在运行期间，它将监听","桥接器的使用","桥接器的配置","桥接器的配置项有：","检查一个用户是否拥有特定权限需要使用它的isauhorised方法。","检测到","检测存在以及删除","检索到新的配置","检索最近一次获取的配置内容","概念","概念使用标准单词","模型类似，一个用户可以有0到多个角色，一个角色可以有0到多个权限。","模式","模式。","模式和","模式的信息还可以参考这里","模式的实现。","模式的实现，但它确实有相似之处，特别是在并发、扩展性和部署等方面。","模式的应用。关于更多","模式（反应器模式）。","模式（多反应器模式），区别于单线程的","模式（译者注：reactor","模板中可以通过","模板引擎","模板引擎时，如果不指定模板文件的扩展名，则默认会查找扩展名为","模板引擎的实例：io.vertx.ext.web.templ.freemarkertemplateengine#create()。","模板引擎的实例：io.vertx.ext.web.templ.handlebarstemplateengine#create()。","模板引擎的实例：io.vertx.ext.web.templ.jadetemplateengine#create()。","模板引擎的实例：io.vertx.ext.web.templ.mveltemplateengine#create()。","模板引擎的实例：io.vertx.ext.web.templ.pebbletemplateengine#create()。","模板引擎的实例：io.vertx.ext.web.templ.thymeleaftemplateengine#create()。","模板引擎的实现没有内嵌在","模板引擎：io.vertx:vertx","模板文档。","模板，请参考","欢迎来到vert.x的世界，相信您在接触vert.x的同时，迫不及待想动手试一试，如您在学习计算机其它知识一样，总是从hello","欢迎页","欧洲中部时间","欲了解有关在命令行执行","正则表达式同样也可用于在路由时匹配","正如您在java中可看到的，该verticle的名称要么是java","正常调用","正常运行","此参数用来支持","此参数确定管理数据库连接池的实现类，默认是io.vertx.ext.jdbc.spi.impl.c3p0datasourceprovid","此处","此处会列出常见的关于vert.x","此处可填入超时处理部分代码","此处是公开的，不需要登录","此处需要登录","此外还会加上：kubernetes.uuid,","此外，您可以实现自己的转换器（converter）并指定cli使用此转换器：","此客户端尝试着支持驱动所支持的大多数参数配置。有两种配置方式，一种是连接字符串，另一种是驱动配置选项。","此客户端把配置参数放在","此客户端支持以下这些参数：","此异步","此方式有两个必要的参数：","此方法从连接池中获取一个数据库连接，并返回给回调方法：","此方法可以更新集合（译者注：mongodb","此时post方法不会使用分块传输。","此时响应内容会是：","此时，vert.x实例将启动但不部署模块（尚未）因为目前集群中只有1个节点，而不是3个。","此时，vert.x实例将启动但不部署模块（尚未）因为目前集群中只有2个节点，而不是3个。","此格式支持","此组件底层使用","此组件提供了","此配置仓库不支持","此配置仓库也支持所有的格式。","此配置仓库仅仅从文件中读取配置，支持所有的格式。","此配置仓库会从","此配置仓库会创建一个","此配置仓库会通过给定的","此配置仓库将环境变量中的键值对映射成","此配置仓库将系统属性中的键值对映射成","此配置仓库需要以下几个参数：","此配置仓库需要传入一系列参数：configur","每一个","每一个上传的文件会被自动生成一个文件名，并可以通过","每一个上传的文件通过一个","每一个匹配规则对应一个","每一个服务请求对象和一个服务响应对象绑定，您可以用","每一个被路由的请求对应一个唯一的","每一个被静态资源处理器处理的请求都会返回文件系统的某个目录或","每一行应该要么包含一个用户的用户名、密码和角色，要么包含角色的权限。","每个","每个vert.x","每个命令行界面必须定义将要使用的选项和参数集合。它也需要一个名字。cli","每个操作都提供了阻塞和非阻塞版本，其中非阻塞版本接受一个处理器","每个数据库连接的最大预处理sql缓存数，默认0","每个模块由一人主导翻译，二人主导校对，校对的人反馈给翻译的人修改，或获得同意后直接修改，三人都确认无误后，合并到主分支上。","每个翻译模块归属于翻译者所有，如果需要发布不属于自己翻译的模块，那么需要与翻译者协商获得许可后发布。","每个连接最多可用三个连接，每个连接可连接10个流","每当发布或回收服务时，event","每当有一个服务引用被绑定或者被释放，都会有相应的事件发送到","每当有新连接到达时，websocketstream","每当服务发布或者取消发布，都会有相应的事件发送到","每当通过","每次","每次事件信息包含以下：","每次使用客户端完之后，无需调用client.close();方法关闭客户端，频繁创建销毁客户端会在一定程度上消耗系统资源，降低性能，同时增加开发人员的负担，vert.x提供客户端的目的就在于复用连接以减少资源消耗，提升性能，同时简化代码，减轻开发人员的负担。如您关闭客户端，在下一次使用该客户端的时候，需要重新创建客户端。","每次熔断器状态发生变化时，会在event","每次调用此方法，就相当于在调用","比如创建","比起很多历史遗留的应用系统，vert.x","水平扩展","没什么特别的，您可以使用任何java应用程序。","没有共享访问可变状态，因此您不必担心需要通过同步访问来保护该状态。","没有其他的","没有参数，直接结束响应，发回客户端：","没有可用的处理器来接收消息","没有完成的","没有对","没有找到给定查询的记录","没有放之四海而皆准的策略，缺省的重定向策略可能不能满足您的需要。默认重定向策略可使用自定义实现更改：","没有新的结果集需要处理","注册id。","注册一个用于侦听撤销partition的handl","注册一个用于侦听新分配partition的handl","注册为","注册在该地址上的处理器。这和","注册处理器","注册指标handler","注册服务","注意一定要输出到","注意事项","注意在vert.x","注意服务代理机制依赖于代码生成，所以每次修改服务接口以后都需重新执行构建过程来重新生成代码。","注意服务代理（服务实现和服务接口）都需要用java语言开发。","注意服务发现模块并不需要运行在vert.x","注意要添加对应的集群管理器依赖，详情见集群管理器章节","注意这个factory与vert.x服务代理没有直接关系，而是一个关于部署单个组件的设施。","注意这里的第三和第四个参数","注意，","注意，即使","注意，如果您需要在一个阻塞处理器中处理一个","注意，对于持有令牌的客户端，唯一需要做的是在","注意，所有发生的这些没有线程阻塞。","注意，角色在api里并不是直接可用的，因为这个事实，vertx","注意，这两个处理器应该只能通过","注意：vert.x","注意：分块响应在","注意：压缩可以减少网络流量，单是cpu密集度会更高。","注意：可共享的","注意：对于","注意：我们会尽量将原理讲得通俗易懂，但还是要求读者具备有线程，进程，内存，cpu，操作系统，数据库，算法等专业基础知识。","注意：目前如果连接失效，vert.x将不尝试重新连接。重新连接尝试和时间间隔仅适用于创建初始连接。","注意：类似","注意：若在","注意：请参阅官方","注意：通过系统变量","注解。","注解后，您可以使用以下命令来定义cli并注入值：","注解处理器（annot","注解来注销代理。当此方法被调用时，代理实例被清除。","注解的服务接口会触发生成对应的服务辅助类：","注解的类","注解相结合，用于生成其它vert.x支持的jvm语言对应的服务代理","注解，比如：","注解：","注释","注销处理器","注销服务","泵","泵（pump）的实例有以下几种方法：","流","流中无效。","流和管道","流和管道（泵）","流实现与","流式","流式对象，它可以处理原生","流式的socket","流式请求所需要发送的最小字节数。超过这个值则客户端需要打开一个新的请求。将这个值设置得过小会失去流式的处理能力，使这个流式的传输方式表现得像一个轮训的传输方式一样。默认值是","流方面的信息请查阅","流程的细节、sockj","流重置","流量","流量控制","测试","消息。","消息。由于服务器端配置了期望每隔","消息中的最后一帧标记成","消息会被","消息体处理器也可以用于处理","消息体处理器默认地会合并表单属性到请求的参数里。","消息体的长度限制","消息体（messag","消息写入","消息发送可能会因为其他原因失败，包括：","消息可以由多个帧组成，在这种情况下，第一帧是二进制或文本帧（text","消息在","消息在处理器（handler）中被接收。您可以在某个地址上注册一个处理器来接收消息。","消息大于使用setmaxwebsocketframes","消息头(header)，作为要执行操作的名称","消息头。假设我们要构建一个","消息头中匹配了不止一个","消息头为","消息头匹配","消息头可以包含多个用","消息头并提供了一些识别客户端偏好的语言，以及提供通过","消息头用于表示哪些","消息头的","消息头的值为","消息头的子类型为","消息头的请求：","消息头的部分响应。","消息头的顶级类型为","消息头表示客户端只接受","消息头设置为","消息头里。","消息对象","消息将被发布到一个地址中，发布意味着会将信息传递给","消息将被发送到一个地址中，vert.x将会把消息分发到某个注册在该地址上的处理器。若这个地址上有不止一个注册过的处理器，它将使用","消息授权","消息流","消息消费者的例子：","消息源服务","消息源服务的location是消息所发送的ev","消息源服务，就是通过event","消息源服务，服务对象的类型是一个messageconsumer（其location表现为一个ev","消息然后拿到回应。","消息的","消息的原始内容是一个如下结构的","消息的消费者(consumer)、http","消息类型","消息编解码器","消息编解码器的编码和解码不一定使用同一个类型。例如您可以编写一个编解码器来发送","消息顺序","消息，因此会在服务器端触发","消息，因此我们提供了","消费","消费感兴趣","消费消息源服务","消费组内的消费者可以消费某个","消费者可以通过调用","混合","添加param1（参数1）","添加param3（参数3）","添加一个","添加新的产品","添加消息头","清理工作，您可以使用它。","源代码文件执行运行时编译，这对于快速原型制作和演示很有用。不需要设置","源代码，直接运行它：","源文件，vert.x会为你编译它。","激活该行为。","点对点模式/请求","点对点消息传递模式下，可在消息发送的时候指定一个应答处理器（可选）。","点对点消息模式。","然后创建","然后启动intellij","然后在src/main/java/io/example目录下新增mainverticle.java文件，代码如下：","然后您就可以执行在同一个事务中的操作，在需要提交事务时，调用","然后我们在src/main/java/io/example目录下新建两个java文件，分别是main.java和myfirstverticle.java，代码如下：","然后我们在src/main/java/io/example目录（是的，您需要新建io和example两级文件夹）下新建两个java文件，分别是main.java和myfirstverticle.java，代码如下：","然后用maven的mvn","然后结束了处理。","然后覆盖默认的","然后重新打包后执行，便可再次看到hello","然后，在创建服务发现对象的时候，像下面这样注册桥接器：","然后，将包含该命令的jar放入fat","然后，您可以按下边方式获取转换的值：","然后，通过设置系统变量，确保","熔断器","熔断器可以发布其指标（metric），以供hystrix","熔断器支持以下的故障：","熔断器模式","熔断器用来追踪故障次数，当失败次数达到阈值时触发熔断，并且可选择性提供失败回调。","熔断器的名字","熔断器的新状态","熔断器要旨是保护","熔断器，只需要在依赖中增加以下代码片段：","熔断状态中都会调用失败回调（fallback），或者设置","版本","版本一样。这个","版本为","版本之间发生了变化，请检查变更日志。老版本的客户端仍然兼容，但新版本提供了更多的特性，并且更接近服务端的","版本可通过","版本的","版本的扩展机制不好","版本，http","特点","状态代码,如:200、404","状态代码时，使用","状态代码时，使用相同的","状态代码时，它遵循由","状态响应码为","状态消息,如:ok、not","状态码","状态码会是","状态码时，会执行路由的失败处理。","状态码通知浏览器使用本地的缓存资源。","状态），我们也可以注册","环境","环境中，但我们却不想通过","环境中，参考上述章节，设置正确的网络接口。","环境中，如果","环境变量","环境变量中，还要确保您的","环境变量和系统属性可以直接通过","环境变量，请确保路径下包含所有需要的jar（vertx","环境的应用中","环境里您使用","环境里您需要通过","环境，需要把上面列出的","现在准备请求的一些东西","现在可以通过这种路径访问：/productsapi/products/product1234。","现在将接收组的数据包","现在开启了ha环境，在集群中需要多添加一个vert.x","现在您可以使用","现在我们来看看","现在所有的响应体都读取了","现在让我们专注于如何发送多播报文，发送多播报文与发送普通数据报报文没什么不同。","现在部署其他的一些verticl","理念","甚至可以通过桥接的方式允许在浏览器中运行的客户端javascript在相同的ev","甚至是不同的","生产者","生成","生成keystore文件唯一需要的工具是keytool，运行的时候，你可以指定你需要使用的算法：","生成一个新的keystore文件","生成其他语言的代码","生成服务代理","用flatmap将返回值内的链接作为参数传入lambda，在lambda中将其设置成发送请求，并返回single，在下一步订阅中予以触发","用groovy的factori","用post方法发送文件","用service的factori","用url编码方式提交表单","用于","用于为用户提供认证和授权。vert.x","用于创建服务代理实例的方法","用于将","用于测试和开发目的的自签名证书","用于监听对应的","用于监听执行结果状态：","用于通用错误：1","用以在发生任何异常的时候接收异常信息。","用分块方式编码提交表单","用到了","用客户端发出请求的所有不同方式都支持这两种指定主机/端口的方法。","用户/角色/权限","用户/角色/权限授权","用户凭证","用户对象可以缓存任何权限，之后的调用会检查是否拥有同样的权限执行其操作，这个结果实际上调用了底层提供者provider的方法。","用户是无法直接利用路径访问的。更安全的做法是使用vert.x","用户需要登录，并被授权才能够访问消息。因此，您需要配置一个","用户（默认无权限）","用来确定绑定的网络接口,","用结果集results进行其他操作","用默认值创建一个集群会话存储","由","由vert.x","由一个简单的json对象组成，里面包含访问数据源的各种属性（jdbc","由于","由于docker容器只在启动的时候创建链接，所以这个桥接器只会在启动的时候导入服务记录，然后此后就都不改变了。","由于java不提供对类路径资源的异步方法，所以当类路径资源第一次被访问时，该文件将复制到工作线程中的文件系统。当第二次访问相同资源时，访问的文件直接从（工作线程的）文件系统提供。即使类路径资源发生变化（例如开发系统中），也会提供原始内容。","由于kafka的消费者会组成一个消费组(consum","由于start命令产生一个新的进程，传递给jvm的java选项不会被传播，所以您必须使用java","由于vert.x或应用程序的代码块中没有阻塞，ev","由于vert.x的多语言特性，当你从java、groovy或其他语言中获取服务对象的时候，可能会有差异。","由于会话处理器需要使用","由于它需要在所有异步执行之前处理请求的消息体，因此这个处理器要尽可能早地设置到","由于我们会在不同的处理器里写入响应，因此需要启用分块传输","由于没有阻塞，event","由于远程方应该确认接收者的配置更新，也有可能在回调中接收确认通知：","由多个元素部分构成，你可以使用","由此引入了下面一些vert.x中的重要概念。","由此，我们可以围绕浏览器和服务器构建一个庞大的分布式","登录表单数据","的","的api方法","的api：","的a记录，您需要像下面那样做：","的buffer。代码如下：","的complete方法，来通知调用者关闭操作已经完成。","的http","的jar加到lib目录中。","的jar库。依赖于tcnative的实现它需要openssl安装在您的操作系统中。","的jar文件。首先你需要添加verticl","的listen(...)方法来绑定一个地址并且加入多播组，并加入多播组。","的main","的socket都将收到该报文。","的vert.x","的vert.x实现。","的、开箱即用的错误处理器来渲染错误页面。","的。默认情况下会使用最新发布的压缩版本","的一个代码自动生成版本，就像","的一个关键优点是完全非阻塞(于内核线程而言)","的一个实现。但是","的一个实现，能根据服务id部署一个verticl","的一个新功能，它可以为单个客户端并行发送多个响应。","的一些基本概念。","的一部分关键特性有：","的下标和输入参数的","的下标，并且输出结果集元素的值必须是结果集类型的字符串表示。","的不同","的书的数量，结果包装在回调方法中。","的代码块中。","的代码风格会很怪异，所以我们根据","的会话标示是不能够派发出存储","的会话标示的，因为他们具有不同的种子和状态。","的作用是当","的例子。","的例子可以参见","的例子：","的依赖为","的值。这个键的名称也可以在初始化","的值为","的值会是","的值使其能在","的值，仅仅是读取（只读模式）。","的值：","的公共接口。在这个接口中，仅需要提供一些辅助方法，来简化自定义类型的使用，比如提供","的其他属性。","的具体实现：","的内容写作风格明显和前文不同，而且有些地方描述的很简略（例如","的分区信息。","的前缀，它们都返回","的功能，其底层实现依赖于event","的匹配过程是精确的：","的区别：文中所有","的压缩级别通常允许仅仅保存一些字节大小","的原生支持（first","的参数，设置成了","的发布者和订阅者。","的发布者角色的实现。拿到任意的","的发布者），随后你就可以像从其他任意的","的发行版，并且将安装的","的取值范围由","的名称。","的名称会用于查找实例化","的含义实际上是由应用程序来定义的。这完全取决于消费者如何执行，event","的响应。","的响应拒绝访问。","的回调","的回调从而得到回调通知。","的地址，默认是localhost","的基本","的基本概念","的处理。","的处理器。当连接成功或失败时处理器会被调用。","的处理器，那么这些处理器在","的大多数特性被实现为了处理器（handler），因此您随时可以实现您自己的处理器。我们预计随着时间的推移会有更多的处理器被实现。","的套接字关闭时会发生该事件。","的套接字的","的套接字的空闲事件超过出事设置会发生该事件。","的子类来启动您的应用程序。这个类被设计成易于扩展的。","的安装路径中的","的官方中文文档中，可以找到具体的配置描述。","的官方文档：","的官方网站中，可以找到具体的配置描述。","的官方网站，可以找到具体的配置描述。","的实例。","的实例传入处理器并调用它，表示您现在拥有该锁。","的实例，它提供了添加、设置、删除条目的操作。http","的实现。不过需要确保在","的实现源码","的实现类必须实现","的实现类，因此可以和泵(pump)一起使用。","的实现类，如默认的","的客户端","的客户端。","的客户端库来建立连接。","的对象。","的对象的数量——方法writequeuefull返回true。注意，当写队列被认为已满时，若写（操作）被调用则数据依然会被接收和排队。实际数量取决于流的实现，对于buffer，尺寸代表实际写入的字节数，而并非缓冲区的数量。","的帧的最大值，则vert.x在将其发送到报文之前将其拆分为多个websocket","的常用命令行参数：","的序列化格式也可以作为","的库每隔","的应用中","的应用创建这个处理器。您也可以在创建处理器时通过","的异步版本，如下：","的引用：","的形式。handler","的形式，在构建工具中使用正确的版本","的情况","的情况下），那么","的情况发生。","的所有分区上。","的所有文档数据都存储在集合中。","的所有文档：","的所有者，因此不能在关闭","的扩展。它提供了对","的扩展，并且提供","的扩展，支持从","的持久化和检索。如果设置为","的挂载点上来实现。挂载的","的授权","的授权功能来配置消息的访问授权。同时支持输入和输出。","的授权很有用。例如您的应用提供了一些受保护的","的授权机制时，所使用的","的接口。","的接口为您和","的接口定义为","的控制中心，也是您做几乎一切事情的基础，包括创建客户端和服务器、获取事件总线的引用、设置定时器等等。","的提供商参考了","的操作更简单些。但要注意的是，查询出的结果集中可能会出现重复的列名。若遇到这样的情况，您应该选择使用","的操作，比如调用某个传统的阻塞式","的支持。","的数据并把它桥接到服务器端的","的数据库来说，使用下面的参数后，可以对","的数据库进行交互。","的数量，您亦可自行设置。","的整个生命周期里），可一旦不再使用它后，就应该关闭它。","的整个生命周期里），可一旦不再使用，就应该使用","的整数值，其中","的文件。","的文件上传。","的文档。","的文档获取更多信息。","的方式从","的方式来部署，且在没有权限把","的方式读取（甚至可以支持暂停(pause)和恢复(resume)操作）。","的方式，从不同的","的方法。","的方法替换了以前版本中","的方法，这个","的方法，这样一个语义上的改变是为了与","的日志默认采用","的时候定义。","的时候指定任意的路径：","的服务发现组件中。","的服务，并且动态地导入新加入的服务，移除被删除的服务。","的末端：","的本地地址，通过","的构造函数（译者注：用于将","的核心","的核心概念之一。它是一个维护了零或多个","的根目录中。如果此文件是一个外部文件，则必须将其添加至","的框架","的概念和","的流程。下面的例子用这个处理器实现了保护资源并通过","的流，如果需要，还可以通过","的消息","的消息.","的消息头","的消息并加入消费组","的消费者，可以通过","的特定","的特定分区里接收消息","的特点，灵感来自于","的状态一致性。","的状态被标记成失败），则返回的","的用法。","的的","的的接口约定，其实都是关于","的目的。","的相关信息","的相关命令","的示例：","的神经系统。","的端口，默认的端口是","的第一个元素为","的第二种方法是处理从客户端发送的http升级请求，调用服务器请求对象的","的简单示例。","的算法所影响。","的类型：","的索引进行标识。第一个参数的索引为","的线程来调用您的处理器。","的线程模型完美契合。但是即使这些接口已经存在一段时间，却没有通过","的网站","的行为，以便受益于vert.x","的解析方式作为参数传入","的订阅者角色。","的订阅者）之后，你就可以像处理其他任意的","的订阅：","的记录","的设置","的设计是强大的，非侵入式的，并且是完全可插拔的。vert.x","的详细信息。","的语法来进行交互，这在与","的请求","的请求。例如：","的请求也是匹配的：","的请求会同时匹配两个","的请求会被定位到索引页。默认的该文件为","的请求会调用这个处理器","的请求调用。我们会忽略结尾的","的请求都需要认证控制。为了实现这个，您需要确保您的认证处理器匹配这个路径，并在您的应用处理器之前执行：","的请求，静态处理器会在该路径中查找文件","的读权限。","的调度器，这得益于","的起始位置读取消息时，可以使用","的起始端：","的路径时使用一个","的路由","的转换。虽然大部分数据库都支持","的输入是前一个异步过程的返回值（此处的返回值不是","的运行配置来启动您的应用时，如果您修改了文件，缓存的文件时不会被更新的。","的这些方法使用。比如：","的远程地址（即连接的另一端的地址）。","的连接。","的连接并发送和接收消息：","的连接，则使用setidletimeout","的连接，同时释放所有相关资源。","的连接，同时释放相关资源。","的连接，若您想要在一段空闲时间之后让","的部署例子：","的部署和并发模型机制。您可以用此模型机制来保管您自己的代码组件。","的配置。","的配置信息。查看","的配置内容一致。","的配置和用法请参考","的配置和私钥是不加密的。","的配置文件","的配置需要在所有集群节点中保持一致性。","的错误。","的问题，也可以避免传统的多线程应用经常会遇到的竞态条件和死锁的问题。","的集合会自动被回写到响应里，这样浏览器就可以存储下来。","的集成，可以以","的顺序一致。","的顺序使其可以在","的顺序，可以将","的领域里，很多操作都会接受一个","的默认值为","的默认构造函数（或不定义构造函数），mapfrom","监听服务的上线、下线和状态变更的消息","监听服务的上线与下线","监听服务的使用","监听配置变更","监听随机端口","目前","目前服务发现组件提供了几种默认的服务类型：","目前，mongodb","目录","目录下。","目录下的时候，建议使用","目录中","目录中查找模板文件。这是可以配置的。","目录作为生成的","目录添加到您的","目录，才能被","目录：","目标","直接从磁盘或","直接写入数据","直接通过tcp连接完成。","相互通信，无论它们使用哪一种语言实现，无论它们在同一个","相关的","相关的命令","相反，也可以在收到","相反，在收到新的远程设置时会通知","相反，它内部仅仅维护一个服务器实例。当传入新的连接时，它以轮询的方式将其分发给任意一个连接处理器处理。","相同方式配置https协议。","相应示例来了解如何将应用打包成","相比选项，argument可以：","看下面的例子：","看例子：","看这个例子会更清楚：","知道它是一个groovi","确保","确保所有请求都会经过","确保请求完成后结束","确定翻译内容后，将会把内容分模块，每人根据自己实际的时间情况领取翻译","确认","示例代码：","示范代码中为了解释future的用法简写了代码。","禁止访问","禁用时，vert.x","禁用磁盘文件缓存","种类","秒","秒。","秒之后发出这个","秒内没有从客户端返回时触发","秒发送一个心跳包，可以通过这个设置来控制频率。","秒后自动超时。","秒后调用下一个处理器","秒收到一条","秒该会话没有收到新的请求，则会认为客户端断开了连接，会话过期。","秒钟。","秒）","稍后当vert.x有一个事件要传给您的处理器时，它会","空的。它不会创建一个填满了","空闲连接保留时间，默认0","突然挂掉，这个","站点。以下是构建方法：","章节。","章节了解更多事件总线集群细节），那么通常情况下您将需要使用另一种异步的方式来创建","章节了解更多配置信息。","章节了解类路径的限制或禁用它。","章节来了解详细信息。","端口,","端口。所以，当这个","端口（默认的主机名是","端点(endpoint)，就是一个rest","端点，如果服务带有ssl标签的话，那么服务记录的ssl(https)属性将被设置为true。","第一次写入操作会触发响应头的写入，因此，若您不使用http","第一步，你的应用客户端向用户申请允许访问它们的数据，如果用户审批后，oauth2服务器发送给客户端一个授权码；","第一种方式对应的代码示例如下：","第一种方法是指定包含密钥和证书的java","第一种方法是指定包含证书和私钥的java密钥库位置。可以使用","第一种方法是指定包含证书颁发机构的java受信库的位置。","第一种方法需要在服务端实例上提供一个","第二个参数是您提供给您的提供商的回调","第二步，客户端将这个授权码和客户端密钥放到post请求中发送给授权服务器（author","等","等。","等其他信息。","等其他第三方","等待一个互斥信号或监视器（例如同步的代码块）","等待一个锁","等待部署完成","等接口例子来了解这种设计。","等方法。下面是一个例子：","等概念，只是进程内的逻辑跳转。","等等","等等。","等类型。","等）","等）。","等）将被重用。","答：future对象提供了一种异步结果的包装，用户可使用future类中的sethandler方法来保存回调函数，然后在原先使用该回调函数的地方用completer方法予以填充，这样便可将回调函数从原参数中取出，以减少回调缩进，从而规避回调地狱，来看一个简单的例子：","答：vert.x中提供了各种预设客户端，例如httpclient，jdbcclient，webclient，mongoclient等，一般情况下，建议将客户端与verticle对象绑定，一个verticle对象内保留一个特定客户端的引用，并在start方法中将其实例化，这样vert.x会在执行deployverticle的时候执行start方法，实例化并保存该对象，在verticle生命周期内，不需要频繁创建和关闭同类型的客户端，建议在verticle的生命周期内对于特定领域，只创建一个客户端并复用该客户端，例如：","答：vert.x其实就是建立了一个verticle内部的线程安全机制，让用户可以排除多线程并发冲突的干扰，专注于业务逻辑上的实现，用了vert.x，您就不用操心多线程和并发的问题了。verticle内部代码，除非声明verticle是work","答：verticle对象往往包含有一个或者多个处理器（handler），在java代码中，后者经常是以lambda也就是匿名函数的形式出现，比如：","答：严格说来，不同框架和语言之间的概念无法一一对应，但如果我们不那么严格地去深究细节，vert.x定义的概念可以从其它框架以及语言中找到一些痕迹，以下是vert.x中定义概念跟其它框架和语言定义概念的比较，同一行中的概念可被认为是相似的：","答：严格说来，要认真看代码文档，比如javadoc，来判断方法是异步还是同步的，如果文档中没有明确说明，则默认是同步的，异步api往往出现在io相关的方法中，所谓io一般认为是涉及到硬盘（比如在硬盘上存取文件），网络（通过网络发送一个请求并获取相应结果），其它进程的操作（操作数据库）等，一般纯粹的，本进程内的内存操作并不被认为是涉及io操作，这个时候将方法或api制作成异步的并无实际意义，所以一般非io相关操作都被认为是同步的，同时并不会占用显著执行时间，所以不会阻塞线程。","答：初次接触vert.x的开发人员往往会在异步，显著执行时间，阻塞等概念理解上遇到一定的困难，在此一并做个解释和说明。","答：因为immutable（不可变的）的东西线程安全，可以被多个线程安全地并发访问，线程在使用的时候拷贝一份也不会有并发问题，java里面字符串（string）对象是immutable（不可变）的，所以缺省情况下事件总线（eventbus）上传递的消息是字符串，vert.x也实现了事件总线上消息类型的编解码器，除了字符串以外，还支持少量的其它类型，比如原始数据类型及其包装类，比如字节流（byte[]），比如json对象（jsonobject,","答：用reroute和statichandler：","策略的防火墙。","策略），默认是","简介","简易教程","算法。","算法压缩过的请求体信息。","算法来快速计算元素基数的相关命令","管理","管理集群端的主题订阅清单（这样就可以轻松得知集群中的那些节点订阅了那些","管理，这意味着定时器线程并非","管道意味着在返回一个响应之前，在同一个连接上发送另一个请求，管道不适合所有请求。","类。","类上提供了","类中也提供了相似的方法：","类中使用，可以在","类中所有的字段都是","类代表查询结果。","类似gnu选项（即du","类似java属性（即java","类似posix选项（即tar","类似。","类似于","类似地，对于文件上传vert.x","类似的","类似，关闭","类作为主类时，它使用以下退出代码：","类则不翻译）","类可以创建","类名。我们为log4j（版本1）、log4j","类型","类型。","类型。例如以下处理器可以提供","类型。则它会与通过","类型。在这种情况下，您可以使用","类型为","类型字段的文档以及读取这个字段","类型字段的文档：","类型的原因是因为","类型的参数。","类型的参数放到最后。其中类型r可以是：","类型的参数，其中","类型的参数：","类型的可读流(readstream)。你可以注册相应的处理器(handler)，来获得下面的事件通知：","类型的响应。","类型的响应是客户端可接受的。","类型的字段。对于其他支持","类型的字段。而且在设置为","类型的表单数据，您需要首先使用一个非阻塞的处理器来调用","类型的表单，它会被编码在请求体中，而且在整个请求体被完全读取之前它是不可用的。multipart","类型的请求。","类型请求，那么它们将不会显示在此处的参数中。","类型追加一个","类型（请参考：http://docs.mongodb.org/manual/reference/mongodb","类型），例如：","类型）：","类型，例如：[null,","类型，则可以为每一个","类型，则（系统）会自动计算一组选项。","类型，这使得返回任意类型变得比较困难。避免使用","类实例。sync.streamadaptor","类或者各种服务类型类提供的快捷方法来创建服务记录。","类提供了","类提供了一个","类提供了相关的","类提供了这个功能。这里有些例子：","类提供了追加各种不同类型数据的追加写入方法。","类是一对完美的匹配：都提供了一个对象流。","类来扩展命令集（仅限于java）：","类来描述选项和参数：","类用来描述","类用来描述json对象。","类的对象，但是当消息发送给处理器后解码成","类的文档。","类而不是java","类被转化为","类，只需要将","类，它会做一些包装（你将获得一个","类，并重载start()方法和stop()方法(stop","类，您可以使用语言前缀groovy:，因此vert.x","类，这个辅助类提供了用于","类：","精确匹配，则匹配成功。","系统变量来实现。","系统变量来达到目的","系统属性","系统属性配置该位置。如，若当前工作目录不可写（例如在不可变容器上下文环境中），请使用以下命令启动应用程序：","系统配置","索引为0","索引为1","级别和","线程。verticl","线程。取而代之是使用","线程。默认情况下，我们会根据机器上可用的核数量来设置","线程上。所以在该","线程上。稍后的章节我们会讨论更多。","线程上执行。这意味着如果您在多核的服务器上运行，并且只部署了一个实例，那么您的服务器上最多只能使用一个核。","线程上执行的。","线程中。对于运行内联的阻塞代码的","线程中同步执行生成随机数的过程。","线程中被调用。","线程中，如单元测试或纯java的","线程中：客户端处理器将被不同的vert.x","线程和上下文调用，这样的上下文会根据需要创建。对于生产环境，不推荐这样使用。","线程安全","线程来处理请求。","线程来执行，而不是通过","线程池的线程上。","线程池：","线程的","线程等待作为连接的最长等待时间。默认为","线程（或","线程）。一个","线程），但一个","线程，因此（这些操作）并不是在","线程，并在这个","组件也提供rx风格的api。","组件介绍","组件源码","组件示例","组件，需要在构建描述符中添加如下依赖：","组件，需要添加以下依赖：","组合路由规则","组合风格在这里是相当有用的：","组播不可用","组播未正常开启","组播被禁用","经验法则是：当有效的回调执行时，通知客户端跳转到受保护的资源上。","绑定到某个服务（它所获取到的","绑定的处理器会被调用一次：","结合起来发送请求的头信息。","结尾的","结尾的某些文件系统操作），vert.x中的所有api都不会阻塞调用线程。","结尾的请求路由到模板处理器上","结束一个请求时，若请求头尚未被写入，会导致它们被写入，并且请求被标记成完成的。","结束响应","结束处理器","结束请求","结构。它具有字符串的键，值可以是任意一种json","结构的","结语","给","给客户端：","绝对uri","统一的错误处理","继承更简单。","维护了一系列处理器，对应了一个虚构的","维护任务进行循环检查连接的时间间隔（译者注：维护任务会定时检查连接的状态，直到连接池剩下最小连接数）。默认为","维护模式下的服务或已经从","维护集群范围中的主题订阅者列表（所以我们可知道哪些节点对哪个event","缓存","缓存有过期时间，在这个时间之后，会重新访问磁盘检查文件并更新缓存。","编写","编写支持","编写的","编码形式上传的的文件。","编码成字符串格式。","编码格式，默认为","编码的字符串，将这个字符串作为","编码的形式包含在请求的","编码过的表单，表单属性会被编码在url中，如同普通查询参数一样。","编程形式调用","编程方式部署verticl","编程比直接使用同步","编程配置","编译java源代码并进行部署","缺省情况下，提交表单的请求头中的","缺省状况下，响应以缓冲形式提供，并不提供任何形式的解码。","缺省状况下，客户端将会依照30x状态码自动重定向，您可使用","网络活动可以被记录下来，用于调试：","网页图标处理器","群集的所有者，所以不要关闭","翻译三个境界：信，达，雅。","翻译人员在领取翻译任务后尽可能在自己评估的时间内完成，校对人员校对任务同理，如无法完成则告知大家，多次无理由延期的，自动退出翻译小组。","翻译协作","翻译成了反应器模式）。","翻译计划","翻译：ranger","翻译：赵亮，校对：ranger","考虑这样一种情况：您在部署","考虑这样一种情况：我们在部署","而","而不是","而不是jdk实现（来支持ssl）。","而不需要管服务记录的内容。","而是指定了","而非","耦合，它们可以和任意类型的对象一起工作。","背景","能够从","能够在","能够自动检测使用","脚本的相关命令","自动关闭","自动发现及网络传输配置","自动提交","自动故障转移","自动检测并使用出","自动生成了适应不同语言代码风格的","自定义的服务类型","自定义配置","自带现成的序列化与反序列化机制，可以处理","自带的序列化与反序列化机制","自签名证书也适用于其他基于tcp的协议，如https：","自身实现了","自身，所以它可以链式地调用:","至少一个","至少一个失败","至少一个成功","至此，大功告成，欢迎来到vert.x的世界。","节点不在授信的网络上，请勿使用。","节点中以使用","节点之间创建集群模式下的","节点信息","节点列表（只有一个）以及如何对接收到的消息进行解析以得到","节点列表（只有一个）和消息确认模式。消息","节点发现和分组","节点的标志符（如果运行在单节点模式是","若mi","若vert.x无法初始化：11","若websocket","若主verticle不能被部署：15","若使用setfactory嵌入了vert.x实例，也可以用编程方式指定度量工厂。","若使用了","若前缀后缀都没指定，vert.x将假定这个名字是一个java","若响应体通过","若客户端不想收到推送请求，它可重置流：","若客户端不支持http","若客户端将","若客户端没有设置trustall，则必须配置客户端受信存储，并且受信客户端应该包含服务器的证书。","若已经有一个","若当","若您不想使用默认配置，可以在创建时通过传入一个","若您不想用默认值，可以在创建服务器时传递一个","若您不指定状态信息，将会使用默认的状态码响应。","若您不需要关心您调用","若您仅需要写单个字符串或","若您使用匹配符来匹配消息","若您只是想将文件上传到服务器的某个磁盘，可以使用","若您只需要将单个字符串或","若您在","若您在启动应用程序时看到以下信息：","若您在命令行中使用vert.x并要使用集群，则应确保vert.x安装的lib目录包含您的集群管理器jar。","若您在调用listen(...)之前已经绑定了datagramsocket，您可以通过调用localaddress来查找套接字的本地地址（即udp","若您在调用其中一个","若您在集群模式下的","若您希望在完成注册后收到通知，您可以在","若您希望在服务器实际监听时收到通知，您可以向","若您总是希望某个类使用将特定的编解码器，那么您可以为这个类注册默认编解码器。这样您就不需要在每次发送的时候使用","若您想写入请求头，则您必须在写入任何请求体之前这样做来设置请求头。","若您想可设置默认端口","若您想将一个","若您想要从偏移量开始发送文件直到尾部，则不需要提供长度信息，这种情况下，您可以执行以下操作：","若您想要决定是否手动发送持续响应，那么此属性可设置成false（默认值），然后您可以通过检查头信息并且调用","若您想要加载的类和资源不存在于主类路径（main","若您想要在","若您想要在连接创建完时收到通知，则需要设置一个","若您想要将","若您想要接收数据包，则您需要调用","若您想要读取","若您想要配置客户端选项，可按以下方式创建：","若您拥有的锁没有其他调用者，集群上的任何地方都可以获得该锁。","若您正在编写一个web","若您用编程的方式创建","若您的一个选项是","若您的应用关心丢失的消息，您应该编写具有幂等性的处理器，并且您的发送者可以在恢复后重试。","若您的日志显示一堆：","若您知道响应体不是很大，并想在处理之前在内存中聚合所有响应体数据，那么您可以自己聚合：","若您需要在收到请求时收到通知，则需要设置一个","若您需要这样的保证，您可在tcp之上建立一些握手逻辑。","若想显示vert.x的版本，只需执行：","若我们使用的是","若我们现在关闭或杀死其中一个节点，那么这些模块将在其他节点上自动撤销，因为不再满足","若打开的文件已经存在，则可以使用","若无法预知响应内容类型，您依旧可以在获取结果之后，用","若没有设置任何处理器时，任何被推送的流将被客户端自动重置流（错误代码","若生成的进程无法启动、发现或停止：12，该错误代码一般由start和stop命令使用","若系统配置不符合系统要求（如找不到","若终端3中的实例被杀掉，因为这个组中没有其他vert.x实例，则它不会故障转移。","若要使用","若要向响应添加尾部，则直接添加到","若要启用","若要启用ha模式，在启动","若要启用管道，必须调用setpipelining方法，默认管道是禁止的。","若要启用解压缩功能则您要在创建服务器时调用","若要启用高可用方式运行一个","若要在集群模式下保证安全性，您","若要接收特定多播组的数据包，您需要通过调用","若要接收自定义帧(frame)，您可以在请求中使用","若要获取","若解析器在getquerytimeout毫秒内没有收到正确答案（默认为5秒），dns查询被视为失败。","若设置为","若设置监听端口为0，服务器将随机寻找一个没有使用的端口来监听。","若请求在设定时间内没返回任何数据，则一个超时异常将会传递给响应处理代码。","若请求在超时期限内未返回任何数据，则异常将会被传给异常处理器（若提供），并且请求将会被关闭。","若进程顺利结束，或抛出未捕获的错误：0","若选项值包含空白，请不要忘记在“”（双引号）之间包装值。","若需要执行其他数据库操作，例如您可以使用","若需要调整","获取","获取event","获取map的过程是异步的，返回结果可以传给您指定的处理器中。以下是一个例子：","获取到了集群模式下的","获取到的","获取同样的请求","获取响应","获取失败，可能是集群管理器出现了问题","获取完整列表。","获取数据库连接","获取整个集合。","获取新配置时发生错误","获取最后一步的结果。","获取最终匹配到的","获取服务引用","获取服务引用的时候，可以传递一个jsonobject对象来配置服务对象，可以包括用来配置服务对象的各种参数。某些服务类型不需要额外的配置，有些需要（比如数据库对象）：","获取的这个连接，是接口","获取的连接，是接口","获取请求的消息体","获取连接失败","获取配置发生错误","获取，`bar`","获得","获得一个连接","获得一次性的事件","获得一次性的异步操作结果","获得下面的数据类型：","获得响应","获得消息","获得锁","虚拟主机","虚拟机本身附带的api是不可能的，因此vert.x提供了它自己的完全异步解析dns的api。","虚机主机处理器","虚机主机处理器会验证请求的主机名。如果匹配成功，则转发这个请求到注册的处理器上。否则，继续在原先的处理器链中执行。","表单","表单。","表单提交","表单的属性，您应该告诉","表单还可以包含文件上传。","表单里指定。为了解决这个问题，这个令牌的值也会通过表单属性来检查。这只会发生在请求中不存在这个消息头，并且表单中包含同名属性时。例如：","表单，并对请求设置","表示使用了tls的应用层协议协商(alpn)协议来协商的","表示可用的最大压缩比但比较慢的算法。","表示在tcp层上使用明文形式的","表示在响应完成后连接将被关闭。","表示客户端会接受","表示客户端会无偏好地接受","表示支持","表示更低的压缩比但是最快的算法，9","表示要监视的文件集，这个集合可使用","表示返回的结果，跳过的数据行数。默认值为","被","被作为当前","被创建时","被创建时，它会被分派给一个","被卸载(undeploy)的时候，相关的","被实例化多次，如运行以下命令：","被我们称为","被撤销时这个计时器会被自动关闭。","被撤销的时候会自动被注销。","被消费。在这种情况下，一个","被称为子路由（sub","被设置到了仅占用一个字节的特定位置：","被设置时，使用该选项","被设计来调用阻塞式代码，它不会阻塞任何","裁剪buffer","裁剪得到的buffer是基于原始buffer的一个新的buffer。它不会拷贝实际的数据。使用","裸","要","要为","要使用","要使用asyncfile进行随机访问写，请使用","要使用asyncfile进行随机访问读，请使用","要使用udp，您首先要创建一个","要使用vert.x","要使用事务，首先要用","要使用此组件，需要添加下列依赖：","要使用该服务发现桥接器，需要将如下的依赖包加入到依赖配置文件中：","要使用该模型，您需要将您的代码组织成一系列的","要使用这个项目，将下面的依赖添加到构建描述符里的dependencies部分。","要做ipaddress","要发布一个event","要发布一个http","要发送多个帧组成的消息，请使用","要发送这样的帧，您可以使用","要发送这样的帧，您可以在响应中使用","要取消一个已发布的服务，可以用如下方式：","要启用压缩，可以使用","要启用实时重新部署，请将","要告诉服务器当前客户端支持哪种压缩，则它（请求头）将包含一个","要告诉服务器监听传入的请求，您可以使用其中一个","要告诉服务端监听传入的请求，您可以使用其中一个","要在","要处理","要实现服务代理（译者注：即生成服务代理类），还需要加入以下依赖：","要将您的verticle全部部署在这个fat","要屏蔽来自特定地址的多播，您可以在","要想了解更多","要想自定义桥接器，你可以通过实现","要指定一个ha组，您可以在运行该verticle时使用","要接收文件，您可以告诉","要接收自定义帧，您可以在请求中使用","要接收请求体，您可在请求中调用","要更具挑战，特别是当你有好几个操作要按顺序完成时。同时，使用异步","要查找","要查找vertx.io的所有aaaa记录，您通常会执行以下操作：","要查找vertx.io的所有a记录，您通常会执行以下操作：","要查找vertx.io的所有cname记录，您通常会执行以下操作：","要查找vertx.io的所有srv记录，您通常会执行以下操作：","要查找您常用执行的vertx.io的所有mx记录：","要查询单个文档，您可以使用","要求分配到特定的topic以及partit","要解决上面的问题，您可以这么做：","要解决上面的问题，我们可以这么做：","要解析ip地址10.0.0.1的ptr记录，您将使用1.0.0.10.in","要解析vertx.io的所有ns记录，您可以使用下边几行：","要解析vertx.io的所有txt记录，您可以使用下边几行：","要调用（消费）event","要调试应用程序，请将运行配置创建为远程应用程序，并使用","要连接到","要验证一个用户是否有一个特定的权限，只需要简单的将权限传入到isauthorised像接下来这样做：","要验证一个用户是否有一个特定的角色，你需要在参数前面加上角色前缀。","覆盖param1（参数1）同时新增param2（参数2）","覆盖param2（参数2）","规范中定义了可用的","规范的生态来看，使用其他的","规范，一个客户端可以设置请求头","规范，使用","角色模型","解决方法：查看","解析","解析不会失败，您可以做：","解析会一直在代理服务器上执行。为了实现","解析后，您可以从解析方法返回的commandline对象中读取选项和参数的值：","解析总是在代理服务器上完成解析，为了实现","解析用户命令行","解析阶段","解释运行","触发一个计时器","警告：","警告：multi","警告：大多数浏览器不支持","警告：执行","警告：此组件处于技术预览阶段，因此在之后版本中api可能还会发生一些变更。","警告：确保您检查了生产系统的文件名，以避免恶意客户将文件上传到文件系统中的任意位置。有关详细信息，参阅","警告：缺省状况下，响应会被完全缓冲读入内存，请用","警告：若您要直接使用","警告：谨慎使用此功能，类加载器可能会导致您的应用难于调试，变得一团乱麻（can","警告：这种方式仅对响应结果为缓冲体有效。","警告：随后的重定向会缓存请求体。","计数操作、asyncmap的","计算机本质上是计算的机器，任何一个指令的执行，都需要一定的时间予以完成，这个时间可能长可能短，而这些指令的执行，都会分配给一个具体的线程，并在线程中执行完成。在vert.x中，黄金原则是不阻塞eventloop线程，而eventloop顾名思义，是一个事件的循环，可以认为是一个在vert.x生命周期内，不停轮询事件是否发生，并将发生的事件交给handler予以处理的无限调度循环线程。那么为了不停地检查事件是否发生，该线程需要在短时间内完成一个调度循环。如果eventloop在完成一个调度循环的时间过长，就有可能导致新发生的事件得不到及时的处理，进而导致单次事件响应时间过长，影响客户体验。","计算重定向uri","订阅单个主题","订阅多个topic","订阅绑定端口的事件","订阅者（例如来自","认证","认证/授权","认证authentication：用于验证用户的标识和身份。","认证处理器","认证处理器来处理登录和授权。例如：","让异步代码的执行顺序和代码的编写顺序看起来一致，并在任何一步抛出异常时直接退出到最后一个","让我们举个例子，我们要从readstream中读取数据，然后将数据写入writestream。","让我们先看看服务代理并了解一下为什么它们有用。假设有一个数据库服务暴露在event","让我们改变","让我们看一个","让我们看一些json过滤器的例子","让我们看看使用异步方法的几个例子：","让我们通过研究一些样例来了解相关","让服务器监听配置项指定的主机和端口：","记录","记录客户端网络活动","记录服务端网络活动","记录网络活动","记录解析器","记录解析器将生成下结果：","记录解析器（record","记录，您需要像下面那样做：","许可","许多情况下，您只需要发送一个包含了单个最终帧的","设置","设置。","设置一个接收消息的回调函数","设置一个推送处理器来感知服务器推送的任何资源","设置为","设置为只匹配指定的","设置为指定ip地址。","设置为指定ip地址，同时确保","设置了一个接收数据的处理器","设置了下限，则有效值可以更低。","设置了下面两项配置：","设置了会话的过期时间为","设置了每一个","设置响应头","设置基础认证处理器","设置将用作客户端默认配置。","设置方式，请不要使用。","设置是否复用","设置是否失败回调","设置有内部缓存。默认缓存大小为","设置消息头","设置状态码和消息","设置的w","设置的值，此时，模块将自动部署在所有实例上。","设置相关的hazlcast配置，在这里省略掉，不再赘述","设置相关配置项","设置相应的配置。","设置请求uri将会自动清除已有的查询参数","设置配置项启用压缩。","设置阻塞式处理器的能力。","设置集群管理器","设置），熔断器决定是否恢复状态，此时进入半开启状态（half","访问","访问。","访问。否则可能会引起由流量嗅探引起的会话劫持。","访问令牌对象","访问文件","访问文件系统","访问：","证书会以非加密的形式在","证书颁发机构可通过多种方式为服务端配置。","识别","译者注：jade","译者注：rpc通信通常情况下有三种语义：at","译者注：vert.x","译者注：在","译者注：如要得到更优美、格式化的字符串，可以使用","译者注：实际在","译者注：此处也可以参考","译者注：每个","译者注：这里给个示例：","译者注：通常情况下，这是正常的，无需担心，如果您打开浏览器，按快捷键不停滴刷新页面，就能看到该severe日志。","译者：虞浪，易世伟校对：钟子期，易世伟","该","该命令集是可扩展的，请参考","该处理器","该处理器会将从接收到请求到写入响应的消息头之间的毫秒数写入到响应的","该处理器会返回渲染的结果，并默认设置","该存储将会话保存在内存中，并只在当前实例中有效。","该存储将会话保存在分布式","该方法也可使用一个处理器来调用，这个处理器在","该方法的参数有：","该方法的输入参数是一个","该目录必须是可写的。","该配置可通过core","详情请参阅","详细文档请参考","详细说明请参阅","详细请参阅","语义，以确保消息没有被消费前不会执行提交。","语句","语句。","语句（list","语句，例如：","语法。","语言——若有需要可以切换到语言特定部分（手册中）。","语言，而","请求","请求/响应模型的具有各种帧的一个帧协议，该协议允许发送和接收其他类型的帧。","请求/响应模型的包含各种帧的一种帧协议，该协议允许发送和接收其他类型的帧。","请求uri","请求、http","请求。","请求。它还将接受以","请求。当请求的头信息被完全读取时会调用该请求处理器。","请求。若要执行","请求中传输。因此，使用","请求中传递的uri通常是相对的，若您想要读取请求中和相对uri对应的绝对uri，可调用","请求中传递的实际uri，它总是一个相对的uri。","请求中包含消息头","请求中的主机名。","请求中的请求头部信息。","请求主机","请求以及从","请求体中读取数据","请求体中，如下所示：","请求体很大并填满了内存，任何时候它依旧会工作：","请求体被完全读取，所以直接读取表单属性","请求体，这个在请求体比较大需要流式发送到服务器，或预先不知道大小时很常用。","请求体，除非返回的请求使用了","请求例子：","请求则返回伪头中的:authority的值。","请求参数","请求参数在请求uri的","请求参数的处理","请求可以通过多种方式结束。无参简单结束请求的方式如：","请求可能会成为","请求和响应之间传递。因此通过","请求和响应做细微粒度控制时，您应当使用","请求和响应和","请求和响应泵","请求和浏览器会话之间的关系，并提供了可以设置会话范围的信息的能力，例如一个购物篮。","请求失败时被调用：","请求头部","请求头，除非您已经设置了一些头（包括","请求对象实现了","请求并尝试升级到","请求异常处理器","请求或者直接建立","请求方法","请求日志","请求时，如果对应的资源在该日期之后没有修改过，则会返回一个","请求时，这个","请求时，这个消息头没办法在","请求查询","请求泵入可写流","请求添加一个","请求版本","请求的","请求的准备工作，您必须调用其中一个","请求的响应里加一个独一无二的令牌作为","请求的处理器","请求的超时时间。","请求的路径为","请求的路径来调用模板引擎。","请求设置成分块模式。","请求超时","请求路径","请求返回请求头中的","请求这样的需求，利用","请求都会调用这个","请求都会调用这个处理器","请求需要提供","请求，tls必须禁用，客户端将执行","请求，tls必须被禁用，服务器将升级到","请求，你必须调用","请求，则必须调用","请求，并在单个方法调用中发送它，而且允许您提供一个处理器，当http","请求，并查找首个匹配该请求的","请求，很明显的是每一个请求处理时间不可以超过0.1毫秒，所以您不能阻塞任何过多（大于0.1毫秒）的时间。","请求，必须使用应用层协议协商(alpn)启用tls：","请求，这种情况通常如http","请注意上述代码直接使用了","请注意仅仅只有匹配的类会被隔离，其他任意类会被当前类加载器加载。","请注意这仅适用于某些操作系统和内核版本，所以请检查操作系统文档看是它是否支持。","请注意，netty会寻找slf4","请注意，列表将包含按照它们优先级排序的mxrecord，这意味着列表中优先级低的mx记录会第一个优先出现在列表中。","请注意，列表将包含按照它们优先级排序的srvrecord，这意味着优先级低的记录会第一个优先出现在列表中。","请注意，应用程序必须能够访问","请注意，当前版本还处于预览版，请慎重在生产环境中使用","请注意，您可以传入","请注意，提供的log4j","请注意，自定义","请注意，输出结果集的","请注意，这些指标量是由","请注意，这些请求参数是从请求的","请注意，这是在http","请注意：","请注意：jdk需要支持java代码的快速编译。","请注意：jdk需要支持java代码的运行时编译（on","请注意：vert.x","请注意：vert.x中绝大多数涉及io操作除非有明确说明，例如以sync后缀命名的方法，否则均是异步的，另外在vert.x中，eventbus的相关操作也被认为是涉及io操作。","请注意：worker","请注意：一般情况下，用了vert.x的verticle之后，原则上synchronized，lock，volatile，static对象，java.util.concurrent,","请注意：上面提到的各类参数的默认值，都是","请注意：删除一个集合将会删除集合中所有的文档！","请注意：即使一个","请注意：只有当第二个vert.x","请注意：大部分应用将只会需要一个vert.x实例，但如果您有需要也可创建多个vert.x实例，如：隔离的事件总线或不同组的客户端和服务器。","请注意：如果使用了字符串连接的方式，此客户端将会忽略所有配置选项。","请注意：当前版本并不支持分块文件编码（multipart","请注意：当加载io.vertx.core.impl.fileresolver类时，这些系统属性将被评估一次，因此，在加载此类之前应该设置这些属性，或者在启动它时作为jvm系统属性来设置。","请注意：您不需要在一个","请注意：有时可能需要使用jvm内置解析器。可以在启动的时候加上jvm系统属性","请注意：本文大部分内容专用于","请注意：此功能仅适用于","请注意：此功能仅适用于http/2协议。","请注意：输入输出参数的下标必须匹配","请注意：这个配置信息在","请注意：通过","请注意：重新打包之前，您可能需要清除之前编译后留下的文件，用mvn","请记住","请记住pem的配置和私钥是不加密的。","请记住这个计时器将会定期触发。如果您的定时任务会花费大量的时间，则您的计时器事件可能会连续执行甚至发生更坏的情况：重叠。这种情况，您应考虑使用","请访问","请阅读","读取user","读取帧","读取帧，您可以使用framehandl","读取文件","读取请求体","读取配置的","读取配置的超时时间，单位是毫秒，默认为","读文件","调度器支持","调用","调用http","调用一些需要耗费显著执行时间返回结果的阻塞式api","调用下一个匹配的","调用下一个处理器","调用了","调用处理器的参数是一个","调用失败","调用完毕","调用对应处理器。","调用成功","调用端代理类（client","调用这个处理器。","调用这个处理器的参数是一个","资源。您可以非常容易地编写静态的","资源拥有者密码证书授权类型比较适合于这样一种情况：当资源拥有者和客户端之间有可信任的关系时使用，如设备操作系统、或高特权应用。授权服务器应该在很特殊的情况时启用这种授权类型，并且仅仅当其他应用都不可见时允许使用这种类型。","资源记录不应该存在","超时","超时处理器","超时时间","跟其它maven项目一样，我们首先定义了项目的groupid，artifactid以及版本号，随后我们定义了两个属性，分别是：vertx.version，也就是vert.x的版本号，此处我们使用最新的vert.x版本，也就是3.4.1；以及main.class，也就是我们要使用的包含有main函数的主类。之后我们引入了两个maven插件，分别是maven","跨域请求伪造","跨域资源共享（cors，cross","跨站点请求伪造","路径。","路径下。","路径下挂载某些处理器","路径下的vertx","路径下的资源","路径中添加","路径作为命名空间，在默认的","路径开头的请求，都会在执行","路径的","路径部分应该是：","路径里面。","路径（path）。此节点的数据格式可以是","路由","路由。原文的最后几部分关于","路由或强制使用","路由顺序","路由（基于方法(1)、路径等）","转发","转发。此处有别于","转变为","转换为","转换为数据实体类）以及一个","转换到","软件通常通过创建不支持组播的虚拟网络接口来进行工作。在","辅以","输入参数集（params），jsonarray","达到了","达成离线增强(offlin","过滤器是一个json对象。对象中的每个条目，将会用来过滤服务记录。服务记录必须满足所有的条目要求。这些条目可以使用","运行","运行20个ruby语言的work","运行javascript的verticl","运行ruby的verticl","运行vert.x实例，您可以在命令行中指定","运行一个rubi","运行应用时，默认会执行","运行指定类路径的预编译好的10个java","运行时抛出异常","运行环境里。","运行阻塞式代码","运行，如果","近似于普通的","返回值是一个唯一的计时器id，该id可用于之后取消该计时器，这个计时器id会传入给处理器。","返回多个结果集","返回此服务实例的引用（this）并标注","返回的","返回的请求必须是未发送的，这样原始请求处理器才会被发送而且客户端之后才能发送请求。大多数原始请求设置将会传播（拷贝）到新请求中：","返回类型必须是以下其中之一：","还将提供堆栈跟踪，以精确定位发生阻塞的位置。","还应提供受信存储的密码：","还应提供密钥存储的密码：","还提供了一个根据时间戳(timestamp)来定位","还提供了其他命令：","还是下面需要提到的","还有一种方式来覆盖默认的配置文件，那就是利用系统配置","这两个快捷方法。","这两种","这个","这个api是流式的，因此这个方法可以被链式地调用。","这个auth提供者的实现是使用apach","这个headers是一个","这个uri是在","这个例子不会耗尽内存，但如果写入队列已满，我们最终会丢失数据。我们真正想要做的是在写入队列已满时暂停读取","这个例子做的第一件事是创建了一个","这个值会返回","这个值可以是event","这个元素{0}是创建实际的查找时替换成用户的id。这个设置是强制的。","这个功能不能用于生产环境","这个功能对于跨多核扩展时很有用。例如，您有一个实现了web服务器的verticle需要部署在多核的机器上，您可以部署多个实例来利用所有的核。","这个参数用于禁用某些传输方式。可能的值包括","这个地址。这个地址可以通过servicediscoveryoptions配置。","这个处理器会向所有的","这个处理器会在您的应用上绑定回调的","这个处理器会通过","这个处理器将会每隔一秒被调用一次","这个处理器是","这个处理器能够处理范围请求。当客户端请求静态资源时，该处理器会添加一个范围单位的说明到响应的消息头","这个存储适用于您只有一个","这个存储适用于您没有使用粘性会话的情况。比如您的负载均衡器会将来自同一个浏览器的不同请求转发到不同的服务器上。","这个实现当前假定了在基本的验证中使用了用户名和密码。","这个属性文件应该遵从下面的结构：","这个库为可读流、可写流都提供了实现，这两者分别扮演了","这个库也可以通过","这个库提供了","这个数学题并不难，将留给读者作为练习。","这个方法完成的，因此在这种情况下你是不需要持有一个服务引用的。","这个方法的参数有：","这个方法的第一个参数是一个json对象，它包含了认证用的信息，实际上这些信息取决于特定的实现；对于简单基于用户名/密码username/password的认证包含了如下信息：","这个方法的行为现在非常接近于","这个方法返回一个","这个方法，一步就完成服务查找和服务获取：","这个服务正在监听","这个桥接器使用的是","这个桥接器可以连接","这个模型不能说是严格的","这个模型是可选的，如果您不想这样做，vert.x","这个正则表达式可以匹配路径类似于","这个消息将会传递给所有在地址","这个策略将会处理接收到的原始","这个组件包含了一个开箱即用的jwt实现。","这个路由器的调用规则和上面的例子一样","这个过程既可以在","这个配置会以","这个配置精确地定义了消息可以被发送到哪些地址。如果您需要通过精确的地址来控制消息的话，使用这个选项。","这个配置通过正则表达式来定义消息可以被发送到哪些地址。如果您需要通过正则表达式来控制消息的话，使用这个选项。如果指定了","这个配置通过消息的接口来控制消息是否可以发送。这个配置中定义的每一个字段必须在消息中存在，并且值一致。这个配置只能用于","这些属性来简化这个过程。","这些帧被立即发送，并且不受流程控制的影响——当这样的帧被发送到那里时，可以在其他的","这些方法还必须加上","这些方法；它们会在内部被自动转换成","这些是最基本的，下面我们来看一下更多的细节：","这些是通过","这些资源都可以称为服务。服务就是一个可以被发现和访问的功能，可以通过它的类型、元数据和位置来进行描述。所以，服务可以是一个数据库、一个服务代理、一个http应用，以及任何你能想到的可描述、可发现、可交互的资源。它不一定是vert.x实体，它可以是任何组件。在vert.x","这些阻塞做法包括：","这会匹配所有路径以","这会将所有以","这使它用少量的内核线程就可以处理大量的并发(例如，处理很多的连接、消息之类)，具有优异的可扩展性。","这使得它们对于托管vert.x","这儿是一个非常简单的","这儿有一个例子，它回应了任何","这儿有一个例子：","这儿有一个部署不同类型","这儿有一些写入请求体的","这儿有一些创建","这儿有三种不同类型的","这允许http","这允许使用块方式写入http","这允许它同时处理支持http","这允许您在应用的不同部分设置不同的失败处理器。","这允许您部署用任何使用vert.x支持的语言编写的verticle实例。","这可以被您自己实现的处理器处理，或者被我们提供的专用错误处理器（failurehandler）处理。","这可以通过几种方式完成：","这可以通过向上文所述的匹配规则中加入额外的字段来指定该匹配需要哪些权限。","这和更加详细的例子完全一样。","这在开发时会导致一个问题，例如当您通过","这实际上是在发送响应体的最后一个（数据）块。","这将创建一个分布式的","这将阻止从10.0.0.2发送的数据包","这就是服务代理（servic","这意味着","这意味着你可以只用java编写你的服务一次，就可以在其他语言中以一种习惯的api风格进行服务调用，而不必管服务是在本地还是在ev","这意味着在响应发送回客户端之前，您可以将响应体自动压缩。","这意味着客户端正在重置http连接，而不是关闭它。此消息还可能表示您没有读取完整的有效负荷（连接在读取完全之前被切断）。","这意味着您可以通过向这个地址发送","这意味着您的","这意味着您的类路径中有slf4j","这意味着我们可以保证您的","这意味着每个数据包都可以发送到不同的远程对等体。","这意味着这个","这时任何请求受保护的资源你应该传入这个字符串到http头授权部分，像这样：","这时，可以调用","这时，可以调用mysqlclient.createnonshar","这是一个使用apach","这是一个例子，认证会由另一个","这是一个例子：","这是一个常见的情况，vert.x为您提供了一个","这是一个针对maven的配置示例：","这是专家级别的技巧。","这是为了保证","这是因为方法不能阻塞，并且如果服务是远程的，不可能立即返回结果而不阻塞。","这是因为让不同的","这是因为请求体可能非常大（如文件上传），并且我们不会在内容发送给您之前将其全部缓冲存储在内存中，这可能会导致服务器耗尽可用内存。","这是服务器处理请求并回复","这是示例：","这是贯穿","这是通过指定类型创建shiro","这是针对","这是随机访问写的示例：","这有个例子：","这有点类似","这样做可以得到和上边相同的结果","这样您就可以接收到被发送至","这样的","这样的链式调用会让您的代码更为简洁。当然，如果您不喜欢流式风格，我们不强制您用这种方式书写代码。如果您更倾向于用以下方式编码，您可以忽略它：","这样，uuid","这样，您将能够接收到被发送到","这样，我们可以确保在vert.x应用程序不同线程之间","这次使用默认端口80和指定的主机名","这种","这种处理器不处理需要在","这种情况下，您可以先监听他们，之后再取消监听。","这种方法主要缺点是alpn的实现版本依赖于jvm的版本。为了解决这个问题，可以使用","这种桥接器不需要任何进一步的配置。","这种类型对于客户端要获取资源拥有者证书是合适的。","这种类型对于客户端要获取资源拥有者证书（用户名和密码，通常使用交互式表单）是合适的。它用于从已经存在的直接使用认证模式的如basic或digest的客户端向oauth2认证方式迁移的时候，它会将证书直接转换成oauth2中的访问令牌。","这种配置仓库非常像","这表示","这适用于您在同一个","这适用于您在集群中有多个应用，并且希望不同的应用使用不同的","这部分内容阐述了如何在您的应用中配置","这里。","这里例子中，有三个操作被串起来了：","这里抛出一个","这里故意将请求处理为失败状态","这里是一个对用户授权的例子：","这里是一个派发令牌的例子：","这里是一个简单的例子，使用了一个重定向认证处理器并使用默认的重定向","这里是一个简单的基于用户名/密码username/password认证用户的代码实现：","这里有一些示例，展示了","这里有个例子，从其他的","这里有个例子，从某个其他的","这里的","这里的lambda/匿名函数/req","这里的代码可以成功或者失败","这里的想法是允许服务器在发送大量数据之前授权、接收/拒绝请求，若请求不能被接收，则发送大量数据信息会浪费带宽，并将服务器绑定在读取即将丢弃的无用数据中。","进入项目根目录","进制的字符串来保存","进程能够在您的服务器上扩展，与","进行一些相关的配置，具体可以参考","进行交互。主要用于运行","进行交互，包括保存，获取，搜索和删除文档。","进行方法调用","进行消费，同时加入到某个消费组（consum","进行编码，并将结果写入到报文中。","进行自动类型转换。","进行迭代的例子：","进行配置。如果将","进行配置。默认情况下，在单节点时它的值是localhost，在集群模式时是节点的id。","远程地址","连接","连接。","连接上或失败时，websocketstream","连接不会被客户端自动关闭，若要关闭它们，可以调用","连接也可以直接建立，如连接可以使用前文提到的方式创建，当","连接事件、生命周期、设置的api。","连接代理","连接关闭","连接关闭/goaway","连接关闭时","连接到服务端，并提供回调函数。","连接前缀，并期望从服务端接收相同的连接偏好。","连接发送和接收消息，因此可以通过","连接在关闭响应之前会发送","连接地址","连接字符串，指的是创建客户端的字符串，例如：mongodb://localhost:27017","连接建立后可随时更改设置：","连接情况的参数","连接时，vert.x","连接时，它会向客户端发送其初始设置。定义客户端如何使用连接，服务器的默认初始设置为：","连接池中最大等待连接数。默认为","连接池初始连接数，默认3","连接池启动后，维护任务第一次启动的时间。默认为","连接池最大连接数","连接池最大连接数。默认为","连接池最大连接数，默认15","连接池最小连接数","连接池最小连接数。默认为","连接池的连接最大存活时间。默认为","连接池的连接最大空闲时间。默认为","连接用于多个请求。当您向同一台服务器发送多个请求时，可以更加有效使用连接。","连接的复用限制是在客户端上设置限制单个连接的流数量，如果服务器使用","连接被注册为订阅者时，此连接将不能再执行其他命令，直到这个连接使用取消订阅者的命令。","连接配置","连续","追加上","追加到buffer","退出","适配","选择其中一个。","选择绑定并配置。","选项","选项传递给","选项可以标记为必填项，在用户命令行中未设置必填选项在解析阶段会引发异常：","选项来简单部署更多的服务器实例：","选项确定应用程序的主类启动器。它通常是一个","选项设置为","通信时十分方便。","通常您希望使用","通常您需要像上边例子一样重写","通常情况下，infinispanclustermanag","通常情况下，zookeeperclustermanag","通常情况下，您需要以异步方式来获取dns信息。","通常情况下，服务接口中会包含一个","通常情况下，集群管理器的相关配置是由打包的jar中的默认配置文件","通常情况，alpn会对","通常表示java中的类","通常都会让您从数据库连接中得到最后一个插入的","通常，您想发出没有请求体的http","通知","通知何时关闭所有流，连接尚未关闭。","通过","通过event","通过一个挂载点挂载到主","通过上述两项系统配置，jgroup","通过代码的方式启用集群模式","通过内置的处理器","通过原始的","通过可插拔的集群管理器（cluster","通过命令行使用","通过命令行启用集群模式","通过基于","通过实现","通过开箱即用的方式提供了一个简单便捷的、可扩展的、类似","通过指定的","通过服务对象来访问服务","通过桥接器（bridge），你可以从其他服务发现组件中导入和导出服务，比如docker，kubernetes，consul等。每种类型的桥接器，决定了服务如何导入和导出，并且不一定都是双向的。","通过正则表达式捕捉路径参数","通过注销操作可以取消对","通过消息与服务交互。","通过源文件运行10个java","通过继承","通过编码的形式，设置集群管理器实现，例子：","通过覆盖","通过这个事件，可以监听服务的使用和服务的映射。","通过这个存储，您的会话可以被集群中的任何节点访问。","通过静态方法","那么会匹配上面的","那么参数将包含以下内容：","那么如何获取它的实例呢？","那样通过它来读写数据。它实现了","部分。","部分之后，例如uri是：","部分的手册。","部署","部署javascript的verticl","部署ruby的verticl","部署verticl","部署一个","部署一个groovy的verticl","部署一个javascript的verticl","部署一个ruby的verticl","部署一个已经打包成jar的verticle，这个jar需要在类路径中","部署一个已经编译好的java的verticle，类的根路径是当前目录","部署和撤销","部署和运行的代码块。默认情况一个","部署器即可。","部署失败","部署完成，这样做会破坏","部署成一个","部署成功","都不存在）。需要注意","都会匹配","都会匹配。","都会在","都会自动进行扩容，所以不可能在使用","都包含：pattern（匹配模式），即用于选取文件的ant风格的匹配模式。此匹配模式使用相对路径确定配置文件位置。format（格式）作为可选的参数（每一个","都可以使用不同的格式，但是在一个","都将被转换成字符串。","都应该成功。","都必须遵守连接另一端的发送设置。","都成功完成，该方法将返回一个","都执行失败，则该","都是事件驱动的，当有事件时","都是非阻塞式的并且不会阻塞","都绑定到同一个端口，您将收到一个","都要与服务方法中的某个","配套的","配置","配置jul日志记录","配置jvm虚拟机选项。","配置tls协议版本","配置。","配置一个处理器用于颁发令牌（或依靠第三方）","配置仓库","配置仓库仅支持通过给定的","配置仓库组件是对","配置仓库，您需要添加以下依赖：","配置使用","配置内容","配置参数","配置回调处理器来接收","配置密码套件","配置对应行为。","配置所需的权限","配置授权处理器来过滤请求","配置文件。具体配置如下：","配置文件。在对应的官方可以网站可以详细的配置攻略。","配置文件最终会以","配置文件，在","配置方式，但是不同的是，file","配置日志记录时，您也应该关心配置netty日志记录。","配置服务端和客户端以使用ssl/tl","配置格式","配置格式组件是对","配置格式，您需要添加以下依赖：","配置的数据结构","配置索引页","配置缓存","配置网络服务器以使用","配置跟目录","配置连接重试","配置选项，使用时可根据实际情况选择。","配置集群监视器监控","配置需要的权限","配置项。","配置项来启用","配置项设为","配置，或者通过","配置，确保","配置：","采用","采用字典树来存储数据，便可以以","里","里。","里。在","里。这对以优化网络协议和最小化带宽消耗为目的实现的编解码器是很有用的。","里包含了正确的单位以及起始、终止位置，则客户端将收到包含了的","里您可以使用","里来通知客户端它支持范围请求。如果后续请求的消息头","里注册一个","里的","里的文件。文件的根目录是可以配置的，默认为","里运行的代码和","里运行那个一般的","里重启","里，observ","里，例如：","里，您需要配置您的项目来访问它们。vert.x","重定向处理器","重定向策略如下：","重定向认证处理器","重定向认证处理器用于当未登录的用户尝试访问受保护的资源时将他们重定向到登录页上。","重定向：当客户端接收到","重新分配给组内其他消费者，或者新加入一个消费者去消费对应的","重新获取时，他们将重新部署。通过这样做您可以防止网络分区，也就是脑裂（split","重新部署功能还支持以下设置：","重新部署过程如下执行。首先，您的应用程序作为后台应用程序启动（使用start命令）。当发现文件更改时，该进程将停止并重新启动该应用、这样可避免泄露。","重用","重用请求","重组为对象。这个方法创建了一个","重置状态超时","重要提示：","重要提示：一系列的","重要提示：分布式数据结构的行为取决于您使用的集群管理器，网络分区面临的备份（复制）和行为由集群管理器和它的配置来定义。请参阅集群管理器文档以及底层框架手册。","重要提示：请注意，干净地关闭vert.x实例不会导致故障转移发生，例如：ctrl","重要提醒","重试策略","重载的方法","重载规则","链接处理的。","锁获取失败","错误","错误。","错误代码会发送，您也可以发送另外一个错误代码：","错误处理","错误时间戳","错误的时候，vert.x","错误码","错误配置的ipv6","错误页面处理器","键","问：vert.x","问：vert.x中future该如何正确使用，怎样规避回调地狱？","问：vert.x中各种client该如何正确使用，用完是否需要关闭？","问：verticle对象和处理器（handler）是什么关系？vert.x如何保证verticle内部线程安全？","问：为什么verticle之间传递的消息要求是immutable（不可变）的？","问：什么是显著执行时间？什么是异步？如何正确理解文档中说的不要阻塞eventloop？","问：怎样正确理解vert.x机制？","问：我之前有过spring，akka，node.js或go的经验，请问vert.x的概念有我熟悉的吗？","问：我刚拿到一个第三方类库（lib/jars），怎么判断这个类库中的方法是异步还是同步的？有没有简单粗暴的方法可以一眼看出来？","阻塞式处理器和普通处理器的区别是","阻塞版本的方法名为","附带的","限制消息体大小","限定类全名，如","除了run和version以外，vertx命令行和","除了上文所提到的一系列现成的格式支持以外，vert.x","除了上文所提到的一系列现成的配置仓库支持以外，vert.x","除了取消监听一个多播地址以外，也可以做到屏蔽指定发送者地址的多播。","除了很少的特例（如以","除此之外，udp不像tcp的使用那样安全，这也就意味着不能保证发送的数据包一定会被对应的接收端（endpoint）接收。","除此之外，你可以设置","除此之外，您还可设置一个处理器，它在每次接收到","除此之外，您还要设置一个handler，每接收到一个","除非您拿到","随","随后修改build.gradle为：","随后在pom.xml中加入相关的依赖和插件，如下所示：","随后在src/test/java/io/example目录下新增myfirstverticletest.java文件：","随后打开浏览器，在浏览器的地址栏中输入：http://localhost:8080/","随后点开ide右边的gradle窗口","随机访问写","随机访问写buffer","随机访问读","随着","隐藏文件","隔离“受保护的”调用。你可以这样执行它：","隔离组","集合","集合。","集合中某一个作者的所有文档：","集合中的一个文档：","集合，实际的结果集可以通过","集成起来很自然：它使得无论什么时候，只要我们能使用流和异步结果，就能使用","集群","集群。","集群上消费或者发送消息。","集群中共享访问。","集群中某个运行实例的地址","集群中某个运行实例监听的端口","集群之间的错误（如超时）。比如：","集群会自动把","集群会话存储","集群使用","集群关闭。同时需要禁用","集群启动，后于","集群器并不处理节点之间的通信，在","集群模式","集群模式下。在单机模式下，服务记录存储于本地，并且可以通过","集群模式下，你需要向集群中每个节点的event","集群模式实例，调用","集群模式的","集群的","集群的相关信息。所有的路径中，只有跟路径可以自定义配置。","集群监视器访问每个集群服务器的频率。默认为","集群管理器","集群管理器不处理event","集群管理器包含一下几个功能：","集群管理器包含以下几个功能：","集群管理器实现","集群管理器实现。","集群管理器必须实现clustermanager接口，vert.x在运行时使用java的服务加载器（servic","集群管理器的介绍见","集群管理的可插拔性，也可轻易切换至其它的集群管理器。","集群能够正常运行在","集群范围异步map","集群范围异步map(clust","集群范围计时器","集群范围锁","集群范围锁具有异步api，它和大多数等待锁释放的阻塞调用线程的api锁不相同。","集群范围锁（lock）允许您在集群中获取独占锁","集群通讯交互时，将采用","集群配置，可以参考文档","集群（分片／复制）的一组地址和端口","需要","需要从类路径中读取文件（嵌入在","需要提醒的是，在一个集群中，只需要有一个节点注册了服务桥接器，集群中所有成员就都能使用了。","需要有一个名为","需要注意的是，你只能在","需要注意的是，需要通过如下配置来自定义","需要注意，hikari","需要的重定向握手，但可以提供令牌(11)。","需要读取的文件列表（模式）","需要读取的文件列表（模式）（等同于目录配置仓库的配置方式）","静态文件服务，包括缓存逻辑以及目录监听","静态方法","静态方法用来创建服务代理实例，但这不是必须的：","静态方法里来创建","静态资源处理器可以用于列举目录的文件。默认情况下该功能是关闭的。可以通过","静态资源服务","非常灵活，它支持在","非常适合编写","非必填选项可以具有默认值，如果用户没有在命令行中设置该选项，即将使用该值：","非必需)。","非标准的","非标准的http","非法密钥","非法签名","非阻塞","非阻塞性的特性产生了异步的","页面上找到。","项目中以正常方式添加","项目中提供了若干开箱即用的","项目使用vert.x，则只需将集群管理器jar作为项目依赖添加。","项目的命名空间，默认是","顺序合并","顺序执行（一个接一个）。","预处理sql语句最小缓存数，默认","预编译或者调用语句将会根据参数列表，来重复使用","预编译更新","预编译查询","额外可以配置的有：","额外的配置仓库","额外的配置格式","首先去jetbrain官方网站：www.jetbrains.com","首先新建一个maven项目，一个基本的maven项目目录结构如下所示：","首先来看些基本概念和理论。","首先通过","首先，您需要将hystrix添加到你的依赖中。详细信息请参阅hystrix页面。然后，您需要使用","首先，添加","首先，默认情况下，vert.x","驱动","驱动jar包放在编译路径下。","驱动包加到","驱动包含在里面。如果我们的","驱动包在","驱动参数说明","驱动大部分配置项","驱动的默认值。请参考驱动文档来获取最新信息。","驱动类名","驱动选择服务器的最大时间，单位毫秒","驱动配置的具体选项","驱动，这样的就不能作为","验证","高可用/故障转移","高可用ha实现同样支持","高可用和故障转移","高可用性","黄金法则。","黄金法则：不要阻塞event","默认为","默认主机名是","默认主机名是0.0.0.0，它表示：监听所有可用地址；默认端口号是80。","默认会在","默认使用共享的数据源","默认使用共享的连接池","默认使用混合模式，阻塞式地刷新种子，非阻塞式地生成随机数(7)。prng","默认允许任何基本/简单类型、string","默认写操作级别是","默认情况下","默认情况下在一个","默认情况下，dns服务器选择使用第一个，其余的服务器用于故障转移。","默认情况下，hazelcastclustermanag","默认情况下，http","默认情况下，jvm","默认情况下，tls配置将使用以下协议版本：sslv2hello、tlsv1、tlsv1.1","默认情况下，tls配置将使用运行vert.x的jvm","默认情况下，vert.x","默认情况下，vert.x不会记录任何指标。相反，它为其他人提供了一个spi，可以将其添加到类路径中。spi是一项高级功能，允许实施者从vert.x捕获事件以收集指标。有关详细信息，请参阅","默认情况下，多个连接尝试是被禁用的。","默认情况下，如果","默认情况下，它会执行","默认情况下，它将使用环境中系统dns服务器地址的列表，若该列表无法检索，将使用google的公共dns服务器","默认情况下，客户端禁用主机验证。要启用主机验证，请在客户端上设置使用的算法（目前仅支持https和ldaps）：","默认情况下，解析器将使用环境中的系统dns搜索域，或者，可提供明确的显示搜索域列表：","默认情况压缩被禁用。","默认情况最大的重定向数为","默认情况，发送","默认情况，当vert.x部署verticle时它会调用当前类加载器来加载类，而不会创建一个新的。大多数情况下，这是最简单、最清晰和最干净。","默认是","默认是不分块的，当处于分块模式，每次调用任意一个","默认的","默认的会拒绝所有的消息。您需要告诉桥接器哪些消息是可以通过的。（例外情况是，所有的回复消息都是可以通过的）。","默认的情况下，实践将会查找这些别名，然而并不是所有的算法都需要存在。作为一个好的实践hs256应该存在：","默认的情况下，这个实现将会在类路径里查找一个名为vertx","默认的没有消息体大小限制。","默认的角色前缀是role:。你可以设置setroleprefix改变默认的。","默认的路由的匹配顺序与添加到","默认的阻塞式代码会在","默认的，rout","默认的，为了让浏览器有效地缓存文件，静态处理器会设置缓存消息头。","默认的，处理器会为隐藏文件提供服务（文件名以","默认的，如果不配置权限，那么只要登录了就可以访问资源。否则，用户不仅需要登录，而且需要具有所需的权限。","默认的，如果您的文件永远不会发生变化，则缓存内容会永远有效。","默认的，所有资源都以","默认的，模板处理器会在","默认的，请求会通过","默认监听","默认禁用组播。google一下启用组播。","默认配置下，config","默认采用","！warn","（","（1s）","（5s）","（open，closed，half_open）","（record","（包含一个","（可选）创建一个继承了","（在您的","（扩展包）（译者注：vert.x的扩展包是vert.x的子项目集合，类似web、web","）","）方法来标记启动完成或失败了。","，mysql","，例如：","，其使用","，则设置此参数为","，只需要在工程依赖中加上相应的","，因为由它决定更新的方式。","，在亚马逊云上使用","，如果相应的","，它也是","，它可使您避免用传统方式编写代码：如果成功则完成","，它同样也实现了","，对应的服务代理类命名为","，将代表系统在与","，将会在集合的文档中，以","，并且","，您也可以使用对应的","，意味着永远不超时（译者注：这是客户端的超时时间。如果一个","，意味着返回所有域。","，我们也能将","，或者","，执行某些处理","，此处省略配置代码","，此文件必须在","，然后可以用实现自","，甚至直接使用默认配置。","，那得首先把这个一般的","：","：提供了verticle的一些配置，config_file是包含描述verticle配置的json对象的文本文件的名称，该参数是可选的。","：搜索verticle和它使用的其他任何资源的路径，默认为.（当前目录）。若您的verticle引用了其他脚本、类或其他资源（例如jar文件），请确保这些脚本、其他资源存在此路径上。该路径可以包含由以下内容分隔的多个路径条目：:（冒号）或;（分号）——这取决于操作系统。每个路径条目可以是包含脚本的目录的绝对路径或相对路径，也可以是jar或zip文件的绝对或相对文件名。一个示例路径可能是","：要实例化的verticle实例的数目，每个verticle实例都是严格单线程（运行）的，以便在可用的核上扩展应用程序，您可能需要部署多个实例。若省略，则部署单个实例。","：认证"],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"介绍","keywords":"","body":"Vert.x 官方文档中文翻译\n这是针对 Vert.x 官方文档中文翻译的仓库。\n当前文档翻译对应版本：Vert.x 3.4.1。\n在线地址：https://vertxchina.github.io/vertx-translation-chinese\n背景\n随着 Vert.x 在中国越来越受到关注，使用人数也越来越多，但相关的中文文档却寥寥可数，在这样的背景下，Vert.x 中国用户组发动社区内的志愿者翻译 Vert.x 官方文档。\n目标\n翻译三个境界：信，达，雅。\n我们力求做到第一境界即可。信：即译文要准确，不偏离，不遗漏，也不要随意增减意思。\n理念\n本着开源的精神，贡献先于索取，自愿自发的为社区，为社会贡献，才能为后人造福。\n协作\nGitHub 协作\n使用本仓库进行翻译工作的协作。git 主要分为两个分支，master 为主版本分支，主要进行里程碑式的发布；dev 为开发分支，日常的提交都在 dev 分支上边。基本两个分支足够使用，但可以根据每个人的喜好创建个人分支，不做约束。\n翻译协作\n\n确定翻译内容后，将会把内容分模块，每人根据自己实际的时间情况领取翻译 \n每个模块由一人主导翻译，二人主导校对，校对的人反馈给翻译的人修改，或获得同意后直接修改，三人都确认无误后，合并到主分支上。 \n翻译人员在领取翻译任务后尽可能在自己评估的时间内完成，校对人员校对任务同理，如无法完成则告知大家，多次无理由延期的，自动退出翻译小组。\n\n翻译计划\n具体见翻译计划文档。\n构建方法\n本项目的在线版本部署在 Github Pages 上。使用 master 分支的 docs 目录作为生成的 gitbook 站点。以下是构建方法：\n安装 nodejs 和 npm\nhttps://nodejs.org/en/download/\n安装 gitbook 命令行工具\nsudo npm install gitbook-cli -g\n构建 gitbook\n进入项目根目录\ngitbook buil ./ docs\n\n注意一定要输出到 docs 目录，才能被 git pages 识别\n\n归属与发布\nVert.x中国用户社区默认获得所有翻译内容的发布权。 \n每个翻译模块归属于翻译者所有，如果需要发布不属于自己翻译的模块，那么需要与翻译者协商获得许可后发布。\n"},"start/Start.html":{"url":"start/Start.html","title":"开始使用","keywords":"","body":"Start\nHello World\n欢迎来到Vert.x的世界，相信您在接触Vert.x的同时，迫不及待想动手试一试，如您在学习计算机其它知识一样，总是从Hello World开始，下面我们将引导您制作一个最基本简单的Hello World例子，但在此之前，我们需要您具备有以下基础知识：\n\nJava基础知识，您不需要了解Java EE或者是Java ME的知识，但是需要您对Java有所了解，在此文档中，我们不会介绍任何关于Java SE又称Core Java的知识点。请注意：Vert.x 3以上版本需要Java 8以上版本方能运行；\n\nMaven相关知识，您需要知道什么Maven是做什么用的，以及如何使用Maven；\n\n互联网的基础知识，知道什么是网络协议，尤其是TCP，HTTP协议。\n\n\n本文将会建立一个基本的HTTP服务器，并监听8080端口，对于任何发往该服务器以及端口的请求，服务器会返回一个Hello World字符串。\n首先新建一个Maven项目，一个基本的Maven项目目录结构如下所示：\n├── pom.xml\n├── src\n│ ├── main\n│ │ ├── java\n│ │ └── resources\n│ └── test\n│ └── java\n随后在pom.xml中加入相关的依赖和插件，如下所示：\n\n\n 4.0.0\n\n io.example\n vertx-example\n 1.0-SNAPSHOT\n\n \n 3.4.1\n io.example.Main\n \n\n \n \n io.vertx\n vertx-core\n ${vertx.version}\n \n \n\n \n \n \n maven-compiler-plugin\n 3.3\n \n 1.8\n 1.8\n \n \n\n \n org.apache.maven.plugins\n maven-shade-plugin\n 2.4.2\n \n \n package\n \n shade\n \n \n \n \n \n ${main.class}\n \n \n \n \n ${project.build.directory}/${project.artifactId}-${project.version}-prod.jar\n \n \n \n \n \n \n\n\n跟其它Maven项目一样，我们首先定义了项目的GroupId，ArtifactId以及版本号，随后我们定义了两个属性，分别是：vertx.version，也就是Vert.x的版本号，此处我们使用最新的Vert.x版本，也就是3.4.1；以及main.class，也就是我们要使用的包含有main函数的主类。之后我们引入了两个Maven插件，分别是maven-compiler-plugin和maven-shade-plugin，前者用来将.java的源文件编译成.class的字节码文件，后者可将编译后的.class字节码文件打包成可执行的jar文件，俗称fat-jar。\n然后我们在src/main/java/io/example目录下新建两个java文件，分别是Main.java和MyFirstVerticle.java，代码如下：\nMain.java\npackage io.example;\n\nimport io.vertx.core.Vertx;\n\n/**\n * Created by chengen on 26/04/2017.\n */\npublic class Main {\n public static void main(String[] args){\n Vertx vertx = Vertx.vertx();\n\n vertx.deployVerticle(MyFirstVerticle.class.getName());\n }\n}\n\nMyFirstVerticle.java\npackage io.example;\n\nimport io.vertx.core.AbstractVerticle;\n\n/**\n * Created by chengen on 26/04/2017.\n */\npublic class MyFirstVerticle extends AbstractVerticle {\n public void start() {\n vertx.createHttpServer().requestHandler(req -> {\n req.response()\n .putHeader(\"content-type\", \"text/plain\")\n .end(\"Hello World!\");\n }).listen(8080);\n }\n}\n\n然后用Maven的mvn package命令打包，随后在src的同级目录下会出现target目录，进入之后，会出现vert-example-1.0-SNAPSHOT.jar和vert-example-1.0-SNAPSHOT-prod.jar两个jar文件，后者是可执行文件，在有图形界面的操作系统中，您可双击执行，或者用以下命令：java -jar vert-example-1.0-SNAPSHOT-prod.jar执行。\n随后打开浏览器，在浏览器的地址栏中输入：http://localhost:8080/ 便可看到熟悉的Hello World!啦。\n启动器\n我们也可以使用Launcher来替代Main类，这也是官方推荐的方式，在pom.xml中加入main.verticle属性，并将该属性值设置为maven-shade-plugin插件的manifestEntries的Main-Verticle对应的值，最后修改main.class为io.vertx.core.Launcher，修改后的pom.xml如下：\n\n\n 4.0.0\n\n io.example\n vertx-example\n 1.0-SNAPSHOT\n\n \n 3.4.1\n io.vertx.core.Launcher\n io.example.MainVerticle\n \n\n \n \n io.vertx\n vertx-core\n ${vertx.version}\n \n \n\n \n \n \n maven-compiler-plugin\n 3.3\n \n 1.8\n 1.8\n \n \n\n \n org.apache.maven.plugins\n maven-shade-plugin\n 2.4.2\n \n \n package\n \n shade\n \n \n \n \n \n ${main.class}\n ${main.verticle}\n \n \n \n \n ${project.build.directory}/${project.artifactId}-${project.version}-prod.jar\n \n \n \n \n \n \n\n\n然后在src/main/java/io/example目录下新增MainVerticle.java文件，代码如下：\npackage io.example;\n\nimport io.vertx.core.AbstractVerticle;\n\n/**\n * Created by chengen on 26/04/2017.\n */\npublic class MainVerticle extends AbstractVerticle {\n public void start() {\n vertx.deployVerticle(MyFirstVerticle.class.getName());\n }\n}\n\n然后重新打包后执行，便可再次看到Hello World!。\n\n请注意：重新打包之前，您可能需要清除之前编译后留下的文件，用mvn clean package命令打包。\n\n测试\n下面我们将会介绍测试部分，首先引入两个新的测试依赖，修改后的pom.xml如下：\n\n\n 4.0.0\n\n io.example\n vertx-example\n 1.0-SNAPSHOT\n\n \n 3.4.1\n io.vertx.core.Launcher\n io.example.MainVerticle\n \n\n \n \n io.vertx\n vertx-core\n ${vertx.version}\n \n\n \n io.vertx\n vertx-unit\n ${vertx.version}\n test\n \n\n \n junit\n junit\n 4.12\n test\n \n \n\n \n \n \n maven-compiler-plugin\n 3.3\n \n 1.8\n 1.8\n \n \n\n \n org.apache.maven.plugins\n maven-shade-plugin\n 2.4.2\n \n \n package\n \n shade\n \n \n \n \n \n ${main.class}\n ${main.verticle}\n \n \n \n \n ${project.build.directory}/${project.artifactId}-${project.version}-prod.jar\n \n \n \n \n \n \n\n\n随后在src/test/java/io/example目录下新增MyFirstVerticleTest.java文件：\npackage io.example;\n\nimport io.vertx.core.Vertx;\nimport io.vertx.ext.unit.Async;\nimport io.vertx.ext.unit.TestContext;\nimport io.vertx.ext.unit.junit.VertxUnitRunner;\nimport org.junit.After;\nimport org.junit.Before;\nimport org.junit.Test;\nimport org.junit.runner.RunWith;\n\n/**\n * Created by chengen on 26/04/2017.\n */\n@RunWith(VertxUnitRunner.class)\npublic class MyFirstVerticleTest {\n\n private Vertx vertx;\n\n @Before\n public void setUp(TestContext context) {\n vertx = Vertx.vertx();\n vertx.deployVerticle(MyFirstVerticle.class.getName(), context.asyncAssertSuccess());\n }\n\n @After\n public void tearDown(TestContext context) {\n vertx.close(context.asyncAssertSuccess());\n }\n\n @Test\n public void testApplication(TestContext context) {\n final Async async = context.async();\n\n vertx.createHttpClient().getNow(8080, \"localhost\", \"/\", response -> {\n response.handler(body -> {\n context.assertTrue(body.toString().contains(\"Hello\"));\n async.complete();\n });\n });\n }\n}\n\n执行该测试案例便可得到期望的结果，理解测试代码并不难，留给读者作为练习。\n至此，大功告成，欢迎来到Vert.x的世界。\n"},"start/SimpleStart.html":{"url":"start/SimpleStart.html","title":"简易教程","keywords":"","body":"SimpleStart\nHello World\nStay Hungry. Stay Foolish. 如果您是Java新手，对于命令行感到发怵的话，我们特意为您准备了可视化傻瓜化入门教程，以降低Vert.x的入门门槛。但是再怎么傻瓜，也还是需要您具备有基本的Java语法知识，我们并不会在此介绍任何关于Java的语法知识，尤其是Java 1.8版本的基础知识，因为Vert.x 3以上版本要求Java 8以上版本方可运行，且大量应用了1.8加入的新语法糖，比如匿名函数Lambda。\n本文将会建立一个基本的HTTP服务器，并监听8080端口，对于任何发往该服务器以及端口的请求，服务器会返回一个Hello World字符串。与Start部分不同的是：\n\nSimpleStart将会使用IDE，也就是集成开发环境来简化开发流程；\n\nSimpleStart将会使用Gradle，而非Maven来简化相关设置。\n\n\n首先去JetBrain官方网站：www.jetbrains.com 免费下载集成开发环境（IDE）IntelliJ IDEA，有两个版本，社区版（Community）和终极版（Ultimate），后者需要付费使用，相比起前者而言，多了很多Java EE的支持，幸运的是，我们不需要使用这些貌似很牛逼其实无用的功能，用社区版就好了。下载后安装。\n然后启动IntelliJ IDEA，选择创建新项目->Gradle项目->next->填入GroupId（也就是你所在组织的名字，例如io.example）和ArtifactID（也就是项目的名字，例如VertxExample）->next->勾选Use auto-import（自动引入）以及Create directories for empty content roots automatically（为空内容建立文件夹结构）->next ...-> finish，随后会建立以下文件结构，跟Maven文件夹结构几乎一样：\n├── src\n│ ├── main\n│ │ ├── java\n│ │ └── resources\n│ └── test\n│ └── java\n├── build.gradle\n├── settings.gradle\n随后修改build.gradle为：\ngroup 'io.example'//对应刚刚向导中输入的 GroupId，ArtifactId在settings.gradle中\nversion '1.0-SNAPSHOT'\n\napply plugin: 'java'\n\nsourceCompatibility = 1.8\ntargetCompatibility = 1.8//新增\n\nrepositories {\n mavenCentral()\n}\n\ndependencies {\n compile 'io.vertx:vertx-core:3.4.1'//新增 vert.x core的依赖\n testCompile group: 'junit', name: 'junit', version: '4.12'\n}\n\n//以下部分新增\njar {\n manifest {\n attributes \"Main-Class\": \"io.example.Main\"//指定Main函数所在的类\n }\n\n from {\n configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }\n }\n}\n\n然后我们在src/main/java/io/example目录（是的，您需要新建io和example两级文件夹）下新建两个java文件，分别是Main.java和MyFirstVerticle.java，代码如下：\nMain.java\npackage io.example;\n\nimport io.vertx.core.Vertx;\n\n/**\n * Created by chengen on 26/04/2017.\n */\npublic class Main {\n public static void main(String[] args){\n Vertx vertx = Vertx.vertx();\n\n vertx.deployVerticle(MyFirstVerticle.class.getName());\n }\n}\n\nMyFirstVerticle.java\npackage io.example;\n\nimport io.vertx.core.AbstractVerticle;\n\n/**\n * Created by chengen on 26/04/2017.\n */\npublic class MyFirstVerticle extends AbstractVerticle {\n public void start() {\n vertx.createHttpServer().requestHandler(req -> {\n req.response()\n .putHeader(\"content-type\", \"text/plain\")\n .end(\"Hello World!\");\n }).listen(8080);\n }\n}\n\n随后点开IDE右边的Gradle窗口->Tasks->build->jar，双击执行，便可在build/libs文件夹下生成可执行的jar文件，我生成的是VertxExample-1.0-SNAPSHOT.jar，在有图形界面的操作系统中，您可双击执行，或者用以下命令：java -jar VertxExample-1.0-SNAPSHOT.jar执行。\n随后打开浏览器，在浏览器的地址栏中输入：http://localhost:8080/ 便可看到熟悉的Hello World!啦。\n启动器\n我们也可以使用Launcher来替代Main类，这也是官方推荐的方式，修改build.gradle如下：\ngroup 'io.example'\nversion '1.0-SNAPSHOT'\n\napply plugin: 'java'\n\nsourceCompatibility = 1.8\ntargetCompatibility = 1.8\n\nrepositories {\n mavenCentral()\n}\n\ndependencies {\n compile 'io.vertx:vertx-core:3.4.1'\n testCompile group: 'junit', name: 'junit', version: '4.12'\n}\n\njar {\n manifest {\n attributes \"Main-Class\": \"io.vertx.core.Launcher\",//改为Launcher\n \"Main-Verticle\": \"io.example.MainVerticle\"//新增Main Verticle属性，对应MainVerticle类\n }\n\n from {\n configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }\n }\n}\n\n然后在src/main/java/io/example目录下新增MainVerticle.java文件，代码如下：\npackage io.example;\n\nimport io.vertx.core.AbstractVerticle;\n\n/**\n * Created by chengen on 26/04/2017.\n */\npublic class MainVerticle extends AbstractVerticle {\n public void start() {\n vertx.deployVerticle(MyFirstVerticle.class.getName());\n }\n}\n\n然后重新打包后执行，便可再次看到Hello World!。\n至此，大功告成，欢迎来到Vert.x的世界。\n一点知识\njar文件本质上就是一个zip文件，可以用打开zip的压缩工具解压，读者可自行解压拆开jar包，看看相关依赖的文件是否在里面。比如例子中的代码除了生成io.example.MyFirstVerticle.class和io.example.MainVerticle.class文件以外，还同时将依赖的io.vertx.core中的内容压入jar包。\n"},"start/FAQ.html":{"url":"start/FAQ.html","title":"FAQ","keywords":"","body":"FAQ\n此处会列出常见的关于Vert.x 各个组件的常见问题以及相应的注意事项和解决方案。\n问：怎样正确理解Vert.x机制？\n答：Vert.x其实就是建立了一个Verticle内部的线程安全机制，让用户可以排除多线程并发冲突的干扰，专注于业务逻辑上的实现，用了Vert.x，您就不用操心多线程和并发的问题了。Verticle内部代码，除非声明Verticle是Worker Verticle，否则Verticle内部环境全部都是线程安全的，不会出现多个线程同时访问同一个Verticle内部代码的情况。\n\n请注意：一般情况下，用了Vert.x的Verticle之后，原则上synchronized，Lock，volatile，static对象，java.util.concurrent, HashTable, Vector, Thread, Runnable, Callable, Executor, Task, ExecutorService等这些并发和线程相关的东西就不再需要使用了，可以由Verticle全面接管，如果您不得不在Vert.x代码中使用上诉内容，则多少暗示着您的设计或者使用Vert.x的姿势出现了问题，建议再斟酌商榷一下。\n\n问：Verticle对象和处理器（Handler）是什么关系？Vert.x如何保证Verticle内部线程安全？\n答：Verticle对象往往包含有一个或者多个处理器（Handler），在Java代码中，后者经常是以Lambda也就是匿名函数的形式出现，比如：\nvertx.createHttpServer().requestHandler(req->{\n //blablabla \n}).listen(8080);\n\n这里的Lambda/匿名函数/req->{//blablabla}就是一个处理器（Handler），在随后的例子中，我们用1stHandler以及2ndHandler来指代具体的匿名函数，让代码更加清晰明了，放在Verticle中类似：\npublic class MyVerticle extends AbstractVerticle {\n public void start() throws Exception {\n vertx.createHttpServer().requestHandler(1stHandler).listen(8080);\n vertx.createHttpServer().requestHandler(2ndHandler).listen(8081);\n }\n}\n\nJava中，Lambda本身也是一个对象，是一个@FunctionalInterface的对象，Verticle对象中包含了一个或者多个处理器（Handler）对象，比如上述例子中MyVerticle中就包含有两个handler。在Vert.x中，完成Verticle的部署之后，真正调用处理逻辑的入口往往是处理器（Handler），Vert.x保证同一个普通Verticle（也就是EventLoop Verticle，非Worker Verticle）内部的所有处理器（Handler）都只会由同一个EventLoop线程调用，由此保证Verticle内部的线程安全。所以我们可以放心地在Verticle内部声明各种线程不安全的属性变量，并在handler中分享他们，比如：\npublic class MyVerticle extends AbstractVerticle {\n int i = 0;//属性变量\n\n public void start() throws Exception {\n vertx.createHttpServer().requestHandler(req->{\n i++;\n req.response().end();//要关闭请求，否则连接很快会被占满\n }).listen(8080);\n\n vertx.createHttpServer().requestHandler(req->{\n System.out.println(i);\n req.response().end(“”+i);\n }).listen(8081);\n }\n}\n\n访问 http://localhost:8080 就会使计数器加1，访问 http://localhost:8081 将会看到具体的计数。同理，也可以将i替换成HashMap等线程不安全对象，不需要使用ConcurrentHashMap或HashTable，可在Verticle内部安全使用。\nVert.x的Handler内部是atomic/原子操作，Verticle内部是thread safe/线程安全的，Verticle之间传递的数据是immutable/不可改变的。\n一个vert.x实例/进程内有多个Eventloop和Worker线程，每个线程会部署多个Verticle对象并对应执行Verticle内的Handler，每个Verticle内有多个Handler，普通Verticle会跟Eventloop绑定，而Worker Verticle对象则会被Worker线程所共享，会依次顺序访问，但不会并发同时访问，如果声明为Multiple Threaded Worker Verticle则没有此限制，需要开发者手工处理并发冲突，我们并不推荐这类操作。\n问：什么是显著执行时间？什么是异步？如何正确理解文档中说的不要阻塞Eventloop？\n答：初次接触Vert.x的开发人员往往会在异步，显著执行时间，阻塞等概念理解上遇到一定的困难，在此一并做个解释和说明。\n注意：我们会尽量将原理讲得通俗易懂，但还是要求读者具备有线程，进程，内存，CPU，操作系统，数据库，算法等专业基础知识。\n计算机本质上是计算的机器，任何一个指令的执行，都需要一定的时间予以完成，这个时间可能长可能短，而这些指令的执行，都会分配给一个具体的线程，并在线程中执行完成。在Vert.x中，黄金原则是不阻塞Eventloop线程，而Eventloop顾名思义，是一个事件的循环，可以认为是一个在Vert.x生命周期内，不停轮询事件是否发生，并将发生的事件交给Handler予以处理的无限调度循环线程。那么为了不停地检查事件是否发生，该线程需要在短时间内完成一个调度循环。如果Eventloop在完成一个调度循环的时间过长，就有可能导致新发生的事件得不到及时的处理，进而导致单次事件响应时间过长，影响客户体验。\n为了在短时间内完成调度循环，就需要用户正确估算出，哪些程序代码会相对长时间地占用Eventloop线程的执行时间，然后将该部分代码的执行交由其它线程去处理。值得注意的是，这里所说的其它线程，可能是内核线程，也就是操作系统的线程，也有可能是用户线程，用户线程中包括了其它应用程序的线程，也就是其它进程中的线程，或者是我们用户自定义的线程。\n一个简单粗暴的判断标准：任何涉及到IO操作的代码，都可以认为是可能造成阻塞的代码，纯粹内存操作的代码，只要执行时间没有明显超长（例如执行循环几万次的处理便可认为是执行时间超长），都可以认为是非阻塞代码。\n我们来看一个简单的例子：某个程序要求，当前线程发送一个请求给网络上另外一个服务器，然后获取到结果之后作出相应的处理。那么此时有一个明显的IO操作，就是发送网络请求并等待对方返回结果。因为网络的速度要远远慢于内存处理的速度，所以此时的操作便是非纯粹内存操作，就有可能造成线程的阻塞，那么此时应该将这个操作交给其它线程予以处理，在处理完成之前，释放当前线程，等处理完成之后，再由当前线程执行回调函数。Vert.x自带的网络客户端（NetClient，HttpClient等）已经帮您包装好了这部分逻辑代码，直接使用NetClient等客户端，Vert.x就会将发送请求并等待返回结果这部分代码交给另外一个线程予以执行，此时这另外一个线程是内核线程，这部分的异步处理由JVM以及操作系统完成，您不需要自己定义一个线程并执行。类似的，数据库的处理同样涉及IO操作，所以Vert.x自带的JDBC客户端（JDBCClient）会帮您完成这部分的封装，您只需要直接调用JDBCClient的各种API便可完成操作，此时有可能是其它进程中的线程，比如PostgresQL会使用进程池来建立连接池，但是该线程亦不需要您去创建，Vert.x帮您完成了这些操作。类似的，硬盘上的操作，比如文件系统的API，也有可能造成阻塞，所以Vert.x的文件系统API提供了非阻塞API，但是值得说明的是，硬盘上的操作，如果只是少量操作，执行时间上也不会明显超长，所以Vert.x同时提供了硬盘操作的阻塞和非阻塞两种API。最后我们来看一个纯粹内存操作同时又是阻塞的例子。\n假设我们拿到两个数万个节点的链表（LinkedList），要求删除两个链表的交集，那么在没有任何算法优化的前提下，该操作的时间复杂度是O(n^2)，又因为内存中该链表节点数庞大，多达数万个节点，所以如果在Eventloop中执行该操作，将有可能使得执行时间超长，此时需要将这部分代码交由其它线程予以执行，Vert.x提供了除了Eventloop线程池以外的线程池，名曰Worker线程池。此时就需要用户自行将该部分代码包装成Worker线程执行的代码，并交给Worker线程予以执行，执行完成之后再由Eventloop线程执行回调函数处理其结果。注意：Vert.x中将代码交给Worker线程执行的方式有两种，一种是通过executeBlocking函数包装，另外一种是写入Worker Verticle中。\n问：为什么Verticle之间传递的消息要求是immutable（不可变）的？\n答：因为immutable（不可变的）的东西线程安全，可以被多个线程安全地并发访问，线程在使用的时候拷贝一份也不会有并发问题，Java里面字符串（String）对象是immutable（不可变）的，所以缺省情况下事件总线（eventbus）上传递的消息是字符串，vert.x也实现了事件总线上消息类型的编解码器，除了字符串以外，还支持少量的其它类型，比如原始数据类型及其包装类，比如字节流（byte[]），比如Json对象（JsonObject, JsonArray）还有Buffer，这些对象在传递过程中是不可变的。\nVert.x线程模型保证Verticle内部代码线程安全，同时要求在Verticle之间传递的消息是不可变的，通过此方法保证Verticle之间传递的消息也是线程安全的，从而进一步保证Vert.x内部整体是线程安全的，从而将开发人员从繁琐的，容易错的各种多线程并发问题中解脱出来。\n问：我刚拿到一个第三方类库（lib/jars），怎么判断这个类库中的方法是异步还是同步的？有没有简单粗暴的方法可以一眼看出来？\n答：严格说来，要认真看代码文档，比如JavaDoc，来判断方法是异步还是同步的，如果文档中没有明确说明，则默认是同步的，异步API往往出现在IO相关的方法中，所谓IO一般认为是涉及到硬盘（比如在硬盘上存取文件），网络（通过网络发送一个请求并获取相应结果），其它进程的操作（操作数据库）等，一般纯粹的，本进程内的内存操作并不被认为是涉及IO操作，这个时候将方法或API制作成异步的并无实际意义，所以一般非IO相关操作都被认为是同步的，同时并不会占用显著执行时间，所以不会阻塞线程。\n\n请注意：Vert.x中绝大多数涉及IO操作除非有明确说明，例如以Sync后缀命名的方法，否则均是异步的，另外在Vert.x中，EventBus的相关操作也被认为是涉及IO操作。\n\n有一个粗暴简单的判断同步还是异步的方法，就看给出的API或者方法中，是否有回调函数，如果有回调函数，且这个回调函数的参数是AsyncResult，则可以判断该API或方法是异步的。\n问：Vert.x中各种Client该如何正确使用，用完是否需要关闭？\n答：Vert.x中提供了各种预设客户端，例如HttpClient，JDBCClient，WebClient，MongoClient等，一般情况下，建议将客户端与Verticle对象绑定，一个Verticle对象内保留一个特定客户端的引用，并在start方法中将其实例化，这样Vert.x会在执行deployVerticle的时候执行start方法，实例化并保存该对象，在Verticle生命周期内，不需要频繁创建和关闭同类型的客户端，建议在Verticle的生命周期内对于特定领域，只创建一个客户端并复用该客户端，例如：\nimport io.vertx.core.AbstractVerticle;\nimport io.vertx.core.http.HttpClient;\nimport io.vertx.core.json.JsonObject;\nimport io.vertx.ext.jdbc.JDBCClient;\nimport io.vertx.ext.web.client.WebClient;\n\n/**\n * Created by chengen on 21/04/2017.\n */\npublic class TheVerticle extends AbstractVerticle{\n //将客户端对象与Verticle对象绑定，这里选取了三种不同的客户端作为示范\n HttpClient httpClient;\n WebClient webClient;\n JDBCClient jdbcClient;\n\n public void start(){\n //创建客户端\n httpClient = vertx.createHttpClient();\n\n webClient = WebClient.wrap(httpClient);\n\n JsonObject config = new JsonObject()\n .put(\"jdbcUrl\", \"...\")\n .put(\"maximumPoolSize\", 30)\n .put(\"username\", \"db user name\")\n .put(\"password\", \"***\")\n .put(\"provider_class\", \"...\");\n\n jdbcClient = JDBCClient.createShared(vertx, config);\n\n //using clients \n }\n}\n\n每次使用客户端完之后，无需调用client.close();方法关闭客户端，频繁创建销毁客户端会在一定程度上消耗系统资源，降低性能，同时增加开发人员的负担，Vert.x提供客户端的目的就在于复用连接以减少资源消耗，提升性能，同时简化代码，减轻开发人员的负担。如您关闭客户端，在下一次使用该客户端的时候，需要重新创建客户端。\n问：Vert.x中Future该如何正确使用，怎样规避回调地狱？\n答：Future对象提供了一种异步结果的包装，用户可使用Future类中的setHandler方法来保存回调函数，然后在原先使用该回调函数的地方用completer方法予以填充，这样便可将回调函数从原参数中取出，以减少回调缩进，从而规避回调地狱，来看一个简单的例子：\n//未使用future时，回调函数嵌在send方法内部，以匿名函数的形式作为send的参数\nvertx.eventBus().send(\"address\",\"message\", asyncResult->{\n System.out.println(asyncResult.result().body()); \n});\n\n以上是未使用future时的代码，以下是使用future改造后的代码：\nFuture> future = Future.future();\n//将回调函数存入future中，从而实现代码的扁平化\nfuture.setHandler(asyncResult -> {\n System.out.println(asyncResult.result().body());\n});\n//使用future之后，用completer方法填充参数\nvertx.eventBus().send(\"address\",\"message\", future.completer());\n\n一个复杂一点的例子：\n//以下程序先向address1发送一个message，然后等address1回复之后，将address1的回复消息发送给address2，最后将address2的回复打印到控制台上\nvertx.eventBus().send(\"address1\",\"message\", asyncResult->{\n vertx.eventBus().send(\"address2\", asyncResult.result().body(), asyncResult2->{\n System.out.println(asyncResult2.result().body());\n });\n});\n\n可以看到此时为了保证顺序结构，产生了两层缩进，回调金字塔开始形成，多次缩进之后便会出现所谓的回调地狱，这便是异步开发中为了保证顺序所可能会遇到的问题，那么我们可以通过以下方式解决代码过多缩进的问题：\nFuture> future1 = Future.future();\nFuture> future2 = Future.future();\n\nfuture1.setHandler(asyncResult -> {\n vertx.eventBus().send(\"address2\", asyncResult.result().body(), future2);\n});\n\nfuture2.setHandler(asyncResult-> {\n System.out.println(asyncResult.result().body());\n});\n\nvertx.eventBus().send(\"address1\",\"message\", future1);\n\n可以看到，使用了future之后，原先的两层缩进被抽取出来，变成了最多单层的缩进，从而使得代码可读性更强，更加美观。\n值得注意的是，示范代码可能会抛出NullPointerException，因为当操作失败时，asyncResult.result()方法返回值为null，此时调用.body()方法会抛出空指针异常，在生产环境中正确写法应该是：\nif(asyncResult.succeeded()){\n System.out.println(asyncResult.result().body());\n}else if(asyncResult.failed()){\n System.out.println(asyncResult.cause());\n}else{\n System.out.println(\"Why am I here?\");\n}\n示范代码中为了解释future的用法简写了代码。\n使用 Future 来包装异步代码块 (3.4.0+)\n早期版本的 Future，针对每一个异步的过程，需要在代码中声明中间变量 future 来对应异步回调，例如上文例子中的：\nFuture> future1 = Future.future();\nFuture> future2 = Future.future();\n\n在最新的版本中(3.4.0+)，可以通过 Future.future 方法以函数式的方式直接用 Future 来包装一个异步的代码块，例如：\nFuture.>future((future) ->\n vertx.eventBus().send(\"address1\", \"someMessage\", future)\n);\n\n该方法的输入参数是一个 Function，该 Function 会以一个新的 Future 实例为参数被调用。由于 Future 自身实现了 Handler，因此你可以将它直接作为回调的 Handler 传入到异步方法里。该方法的返回值是提供给异步调用使用的 Future 实例。由此可以避免为嵌套的多个异步操作定义不同的 Future 变量，使代码更为简洁。\n以下两种写法是等效的：\nvertx.eventBus().send(\"address\",\"message\", future.completer());\n//或\nvertx.eventBus().send(\"address\",\"message\", future);\n\n复杂一点的例子：\nfuture.compose(message ->\n Future.>future(f ->\n vertx.eventBus().send(\"address\", message.body(), f)\n )\n);\n//以上和以下两种写法是等效的\nfuture.compose(message ->{\n Future> f = Future.future();\n vertx.eventBus().send(\"address\",message.body(),f.completer());\n return f;\n});\n\n使用组合来实现链式调用 (3.4.0+)\nFuture 接口提供了 compose 方法来链式地组合多个异步操作。在介绍这个方法的用途时，我们先考虑一个传统的同步操作和异常处理的方式。假设我们有一个同步的方法 send 会抛出一些异常（注意，以下代码只是同步代码的示例，和 vert.x 无关）：\ntry {\n String msg1 = send('address1', 'message');\n String msg2 = send('address2', msg1);\n String msg3 = send('address3', msg2);\n //deal with result\n} catch (Exception e) {\n //deal with exception\n}\n\n在这个例子里，如果任意一个 send 方法抛出异常，则会立即跳转到 catch 的代码块中。\n下面我们将这个 send 方法通过 compose 替换为 vert.x 的异步版本，如下：\nFuture.>future(f ->\n vertx.eventBus().send(\"address1\", \"message\", f)\n).compose((msg) ->\n Future.>future(f ->\n vertx.eventBus().send(\"address2\", msg.body(), f)\n )\n).compose((msg) ->\n Future.>future(f ->\n vertx.eventBus().send(\"address3\", msg.body(), f)\n )\n).setHandler((res) -> {\n if (res.failed()) {\n //deal with exception\n return;\n }\n //deal with the result\n});\n\n每一个 compose 方法需要传入一个 Function，Function 的输入是前一个异步过程的返回值（此处的返回值不是 AsyncResult，而是具体的返回内容），需要返回一个新的需要链接的 Future。 该 Function方法当且仅当前一个异步流程执行成功时才会被调用。\n上述的例子描述了这样一个流程：\n\n首先通过 eventbus 发送消息 message 到 address1\n如果第一步成功，则发送第一步的消息的返回值到 address2\n如果第二步成功，则发送第二部的消息的返回值到 address3\n如果以上任何一步失败，则不会继续执行下一个异步流程，直接执行最终的 Handler ，并且 res.successed() 为 false，可以通过 res.cause() 来获得异常对象\n如果以上三步全都成功，则同样执行 Handler，res.successed() 为 true，可以通过 res.result() 获取最后一步的结果。\n\n通过 compose 方法来组织代码最大的价值在于可以 让异步代码的执行顺序和代码的编写顺序看起来一致，并在任何一步抛出异常时直接退出到最后一个 handler 来处理，不需要针对每一个异步操作都编写异常处理的逻辑。这对于编写复杂的异步流程时是非常有用的。\nFuture.compose 这个方法的行为现在非常接近于 JDK1.8 提供的 CompletableFuture.thenCompose()，也很接近于 EcmaScript6 的 Promise API 的的接口约定，其实都是关于 Promise 模式的应用。关于更多 Promise 模式的信息还可以参考这里 https://en.wikipedia.org/wiki/Futures_and_promises\n问：Vert.x Web中如何将根路径对应到某个特定的html文件？\n答：用reroute和staticHandler：\nrouter.route(\"/\").handler(ctx->ctx.reroute(\"/static/index.html\"));\n\n问：我之前有过Spring，Akka，Node.js或Go的经验，请问Vert.x的概念有我熟悉的吗？\n答：严格说来，不同框架和语言之间的概念无法一一对应，但如果我们不那么严格地去深究细节，Vert.x定义的概念可以从其它框架以及语言中找到一些痕迹，以下是Vert.x中定义概念跟其它框架和语言定义概念的比较，同一行中的概念可被认为是相似的：\n\n\n\nVert.x\nAkka\nSpring\nEJB\nNode.js\nGo\n\n\n\n\nStandard Verticle\n-\n-\n-\nReactor\n-\n\n\nWorker Verticle\n-\n-\nStateless Session Bean\n-\n-\n\n\nMultiple ThreadedWorker Verticle\n-\nBean(Singleton)\n-\n-\n-\n\n\nHandler\nActor\n-\n-\n-\nGoroutine\n\n\n\n"},"core/Core.html":{"url":"core/Core.html","title":"Core","keywords":"","body":"Vert.x Core 文档手册\n中英对照表\n\nClient：客户端\nServer：服务器\nPrimitive：基本（描述类型）\nWriting：编写（有些地方译为开发）\nFluent：流式的\nReactor：反应器，Multi-Reactor即多反应器\nOptions：配置项，作为参数时候翻译成选项\nContext：上下文环境\nUndeploy：撤销（反部署，对应部署）\nUnregister：注销（反注册，对应注册）\nDestroyed：销毁\nHandler/Handle：处理器/处理，有些特定处理器未翻译，如Completion Handler等。\nBlock：阻塞\nOut of Box：标准环境（开箱即用）\nTimer：计时器\nEvent Loop Pool：事件轮询线程池，大部分地方未翻译\nWorker Pool：工作者线程池，大部分地方未翻译\nSender：发送者\nConsumer：消费者\nReceiver/Recipient：接收者\nEntry：条目（一条key=value的键值对）\nMap：动词翻译成 “映射”，名词为数据结构未翻译\nLogging：动词翻译成 “记录”，名词翻译成日志器\nTrust Store：受信存储\nFrame：帧\nEvent Bus：事件总线\nBuffer：缓冲区（一些地方使用的 Vert.x 中的 Buffer 类则不翻译）\nChunk：块（HTTP 数据块，分块传输、分块模式中会用到）\nPump：泵（平滑流式数据读入内存的机制，防止一次性将大量数据读入内存导致内存溢出）\nHeader：请求/响应头\nBody：请求/响应体（有些地方翻译成请求/响应正文）\nPipe：管道\nRound-Robin：轮询\nApplication-Layer Protocol Negotiation：ALPN，应用层协议协商\nWire：报文\nFlush：刷新（指将缓冲区中已有的数据一次性压入，用这种方式清空缓冲区，传统上翻译成刷新）\nCipher Suite：密码套件\nDatagram：数据报\nSocket：套接字（有些地方未翻译，直接用的 Socket）\nMulticast：多播（组播）\nConcurrent Composition：并发合并\nHigh Availability：高可用性\nMultiplexing：多路复用\nFail-Over：故障转移\nHops：跳数（一台路由器/主机到另外一台路由器/主机所经过的路由器的数量，经过路由转发次数越多，跳数越大）\nLauncher：启动器\n\n\n请注意：Vert.x 和 Vertx 的区别：文中所有 Vert.x 概念使用标准单词 Vert.x，而 Vertx 通常表示Java中的类 io.vertx.core.Vertx。\n\n组件介绍\nVert.x 的核心 Java API 被我们称为 Vert.x Core。\nVert.x Core 提供了下列功能:\n\n编写 TCP 客户端和服务端\n编写支持 WebSocket 的 HTTP 客户端和服务端\n事件总线\n共享数据 —— 本地的Map和分布式集群Map\n周期性、延迟性动作\n部署和撤销 Verticle 实例\n数据报套接字\nDNS客户端\n文件系统访问\n高可用性\n集群\n\nVert.x Core中的功能相当底层 —— 您在此不会找到诸如数据库访问、授权或高层Web应用的功能。您可以在Vert.x ext （扩展包）（译者注：Vert.x的扩展包是Vert.x的子项目集合，类似Web、Web Client、Data Access等）中找到这些功能。\nVert.x Core 小而轻，您可以只使用您需要的部分。它可整体嵌入现存应用中。我们并不会强迫您用特定的方式构造您的应用。\n您亦可在其它Vert.x支持的语言中使用Vert.x Core。很酷的是：我们并不强迫您在书写诸如 JavaScript 或 Ruby 时直接调用 Java API，毕竟不同的语言有不同的代码风格，若强行让 Ruby 开发人员遵循 Java 的代码风格会很怪异，所以我们根据 Java API 自动生成了适应不同语言代码风格的 API。\n如果您在使用 Maven 或 Gradle（译者注：两种常用的项目构建工具），将以下依赖项添加到您的项目描述文件的 dependencies 节点中以使用 Vert.x Core 的API：\n\nMaven（您的 pom.xml 中）\n\n\n io.vertx\n vertx-core\n 3.4.1\n\n\n\nGradle（您的 build.gradle 中）\n\ndependencies {\n compile 'io.vertx:vertx-core:3.4.1'\n}\n\n接下来讨论 Vert.x Core 中不同的概念和特性。\n故事从 Vert.x 开始\n\n请注意：本文大部分内容专用于 Java 语言——若有需要可以切换到语言特定部分（手册中）。\n\n除非您拿到 Vertx 对象，否则在Vert.x领域中您做不了太多的事情。它是 Vert.x 的控制中心，也是您做几乎一切事情的基础，包括创建客户端和服务器、获取事件总线的引用、设置定时器等等。\n那么如何获取它的实例呢？\n如果您用嵌入方式使用Vert.x，可通过以下代码创建实例：\nVertx vertx = Vertx.vertx();\n\n如果您使用 Verticle，在 Verticle 中会有一个内置的 vertx 对象，您可直接使用该内置对象，无需重新创建。\n\n请注意：大部分应用将只会需要一个Vert.x实例，但如果您有需要也可创建多个Vert.x实例，如：隔离的事件总线或不同组的客户端和服务器。\n\n创建 Vertx 对象时指定配置项\n如果缺省的配置不适合您，可在创建 Vertx 对象的同时指定配置项：\nVertx vertx = Vertx.vertx(new VertxOptions().setWorkerPoolSize(40));\n\nVertxOptions对象有很多配置，包括集群、高可用、池大小等。在Javadoc中描述了所有配置的细节。\n创建集群模式的 Vert.x 对象\n如果您想创建一个集群模式的 Vertx 对象（参考 Event Bus 章节了解更多事件总线集群细节），那么通常情况下您将需要使用另一种异步的方式来创建 Vertx 对象。\n这是因为让不同的 Vert.x 实例组成一个集群需要一些时间（也许是几秒钟）。在这段时间内，我们不想去阻塞调用线程，所以我们将结果异步返回给您。\n\n译者注：这里给个示例：\n// 注意要添加对应的集群管理器依赖，详情见集群管理器章节\nVertxOptions options = new VertxOptions();\nVertx.clusteredVertx(options, res -> {\n if (res.succeeded()) {\n Vertx vertx = res.result(); // 获取到了集群模式下的 Vertx 对象\n // 做一些其他的事情\n } else {\n // 获取失败，可能是集群管理器出现了问题\n }\n});\n\n\n是流式的吗？\n您也许注意到前边的例子里使用了一个流式（Fluent）的API。\n一个流式的API表示将多个方法的调用链在一起。例如：\nrequest.response().putHeader(\"Content-Type\", \"text/plain\").write(\"some text\").end();\n\n这是贯穿 Vert.x API 中的一个通用模式，所以请适应这种代码风格。\n这样的链式调用会让您的代码更为简洁。当然，如果您不喜欢流式风格，我们不强制您用这种方式书写代码。如果您更倾向于用以下方式编码，您可以忽略它：\nHttpServerResponse response = request.response();\nresponse.putHeader(\"Content-Type\", \"text/plain\");\nresponse.write(\"some text\");\nresponse.end();\n\nDon’t call us, we’ll call you\nVert.x 的 API 大部分都是事件驱动的。这意味着当您感兴趣的事情发生时，它会以事件的形式发送给您。\n以下是一些事件的例子：\n\n触发一个计时器\nSocket 收到了一些数据\n从磁盘中读取了一些数据\n发生了一个异常\nHTTP 服务器收到了一个请求\n\n您提供处理器给Vert.x API来处理事件。例如每隔一秒发送一个事件的计时器：\nvertx.setPeriodic(1000, id -> {\n // This handler will get called every second\n // 这个处理器将会每隔一秒被调用一次\n System.out.println(\"timer fired!\");\n});\n\n又或者收到一个HTTP请求：\nserver.requestHandler(request -> {\n // This handler will be called every time an HTTP request is received at the server\n // 服务器每次收到一个HTTP请求时这个处理器将被调用\n request.response().end(\"hello world!\");\n});\n\n稍后当Vert.x有一个事件要传给您的处理器时，它会 异步地 调用这个处理器。\n由此引入了下面一些Vert.x中的重要概念。\n不要阻塞我！\n除了很少的特例（如以 \"Sync\" 结尾的某些文件系统操作），Vert.x中的所有API都不会阻塞调用线程。\n如果可以立即提供结果，它将立即返回，否则您需要提供一个处理器（Handler）来接收稍后回调的事件。\n因为Vert.x API不会阻塞线程，所以通过Vert.x您可以只使用少量的线程来处理大量的并发。\n当使用传统的阻塞式API做以下操作时，调用线程可能会被阻塞：\n\n从 Socket 中读取数据\n写数据到磁盘\n发送消息给接收者并等待回复\n其他很多情况\n\n在上述所有情况下，当您的线程在等待处理结果时它不能做任何事，此时这些线程并无实际用处。这意味着如果您使用阻塞式API处理大量并发，您需要大量线程来防止应用程序逐步停止运转。所需的内存（例如它们的栈）和上下文切换都是线程的开销。这意味着，阻塞式的方式对于现代应用程序所需要的并发级别来说是难于扩展的。\nReactor 模式和 Multi-Reactor 模式\n我们前边提过 Vert.x 的 API 都是事件驱动的，当有事件时 Vert.x 会将事件传给处理器来处理。\n在多数情况下，Vert.x使用被称为 Event Loop 的线程来调用您的处理器。\n由于Vert.x或应用程序的代码块中没有阻塞，Event Loop 可以在事件到达时快速地分发到不同的处理器中。\n由于没有阻塞，Event Loop 可在短时间内分发大量的事件。例如，一个单独的 Event Loop 可以非常迅速地处理数千个 HTTP 请求。\n我们称之为 Reactor 模式（译者注：Reactor Pattern 翻译成了反应器模式）。\n您之前也许听说过它，例如 Node.js 实现了这种模式。\n在一个标准的反应器实现中，有 一个独立的 Event Loop 会循环执行，处理所有到达的事件并传递给处理器处理。\n单一线程的问题在于它在任意时刻只能运行在一个核上。如果您希望单线程反应器应用（如您的 Node.js 应用）扩展到多核服务器上，则需要启动并且管理多个不同的进程。\nVert.x的工作方式有所不同。每个 Vertx 实例维护的是 多个Event Loop 线程。默认情况下，我们会根据机器上可用的核数量来设置 Event Loop 的数量，您亦可自行设置。\n这意味着 Vertx 进程能够在您的服务器上扩展，与 Node.js 不同。\n我们将这种模式称为 Multi-Reactor 模式（多反应器模式），区别于单线程的 Reactor 模式（反应器模式）。\n\n请注意：即使一个 Vertx 实例维护了多个 Event Loop，任何一个特定的处理器永远不会被并发执行。大部分情况下（除了 Worker Verticle 以外）它们总是在同一个 Event Loop 线程中被调用。\n\n黄金法则：不要阻塞Event Loop\n尽管我们已经知道，Vert.x 的 API 都是非阻塞式的并且不会阻塞 Event Loop，但是这并不能帮您避免在您自己的处理器中阻塞 Event Loop 的情况发生。\n如果这样做，该 Event Loop 在被阻塞时就不能做任何事情。如果您阻塞了 Vertx 实例中的所有 Event Loop，那么您的应用就会完全停止！\n所以不要这样做！这是一个警告!\n这些阻塞做法包括：\n\nThead.sleep()\n等待一个锁\n等待一个互斥信号或监视器（例如同步的代码块）\n执行一个长时间数据库操作并等待其结果\n执行一个复杂的计算，占用了可感知的时长\n在循环语句中长时间逗留\n\n如果上述任何一种情况停止了 Event Loop 并占用了 显著执行时间，那您应该去罚站（译者注：原文此处为 Naughy Step，英国父母会在家里选择一个角落作为小孩罚站或静坐的地方，被称为 naughty corner 或 naughty step），等待下一步的指示。\n所以，什么是 显著执行时间？\n您要等多久？它取决于您的应用程序和所需的并发数量。\n如果您只有单个 Event Loop，而且您希望每秒处理10000个 HTTP 请求，很明显的是每一个请求处理时间不可以超过0.1毫秒，所以您不能阻塞任何过多（大于0.1毫秒）的时间。\n这个数学题并不难，将留给读者作为练习。\n如果您的应用程序没有响应，可能这是一个迹象，表明您在某个地方阻塞了Event Loop。为了帮助您诊断类似问题，若 Vert.x 检测到 Event Loop 有一段时间没有响应，将会自动记录这种警告。若您在日志中看到类似警告，那么您需要检查您的代码。比如：\nThread vertx-eventloop-thread-3 has been blocked for 20458 ms\nVert.x 还将提供堆栈跟踪，以精确定位发生阻塞的位置。\n如果想关闭这些警告或更改设置，您可以在创建 Vertx 对象之前在 VertxOptions 中完成此操作。\n运行阻塞式代码\n在一个完美的世界中，不存在战争和饥饿，所有的API都将使用异步方式编写，兔兔和小羊羔将会在阳光明媚的绿色草地上手牵手地跳舞。\n但是……真实世界并非如此（您最近看新闻了吧？）\n事实是，很多，也非所有的库，特别是在JVM生态系统中有很多同步API，这些API中许多方法都是阻塞式的。一个很好的例子就是 JDBC API，它本质上是同步的，无论多么努力地去尝试，Vert.x都不能像魔法小精灵撒尘变法一样将它转换成异步API。\n我们不会将所有的内容重写成异步方式，所以我们为您提供一种在 Vert.x 应用中安全调用\"传统\"阻塞API的方法。\n如之前讨论，您不能在 Event Loop 中直接调用阻塞式操作，因为这样做会阻止 Event Loop 执行其他有用的任务。那您该怎么做？\n可以通过调用 executeBlocking 方法来指定阻塞式代码的执行以及阻塞式代码执行后处理结果的异步回调。\nvertx.executeBlocking(future -> {\n // 调用一些需要耗费显著执行时间返回结果的阻塞式API\n String result = someAPI.blockingMethod(\"hello\");\n future.complete(result);\n}, res -> {\n System.out.println(\"The result is: \" + res.result());\n});\n\n默认情况下，如果 executeBlocking 在同一个上下文环境中（如：同一个 Verticle 实例）被调用了多次，那么这些不同的 executeBlocking 代码块会 顺序执行（一个接一个）。\n若您不需要关心您调用 executeBlocking 的顺序，可以将 ordered 参数的值设为 false。这样任何 executeBlocking 都会在 Worker Pool 中并行执行。\n另外一种运行阻塞式代码的方法是使用 Worker Verticle。\n一个 Worker Verticle 始终会使用 Worker Pool 中的某个线程来执行。\n默认的阻塞式代码会在 Vert.x 的 Worker Pool 中执行，通过 setWorkerPoolSize 配置。\n可以为不同的用途创建不同的池：\nWorkerExecutor executor = vertx.createSharedWorkerExecutor(\"my-worker-pool\");\nexecutor.executeBlocking(future -> {\n // 调用一些需要耗费显著执行时间返回结果的阻塞式API\n String result = someAPI.blockingMethod(\"hello\");\n future.complete(result);\n}, res -> {\n System.out.println(\"The result is: \" + res.result());\n});\n\nWorker Executor 在不需要的时候必须被关闭：\nexecutor.close();\n\n当使用同一个名字创建了许多 worker 时，它们将共享同一个 pool。当所有的 worker executor 调用了 close 方法被关闭过后，对应的 worker pool 会被销毁。\n如果 Worker Executor 在 Verticle 中创建，那么 Verticle 实例销毁的同时 Vert.x 将会自动关闭这个 Worker Executor。\nWorker Executor 可以在创建的时候配置：\nint poolSize = 10;\n\n// 2分钟\nlong maxExecuteTime = 120000;\n\nWorkerExecutor executor = vertx.createSharedWorkerExecutor(\"my-worker-pool\", poolSize, maxExecuteTime);\n\n\n请注意：这个配置信息在 worker pool 创建的时候设置。\n\n异步协调\nVert.x 中的 Future 可以用来协调多个异步操作的结果。它支持并发组合（并行执行多个异步调用）和顺序组合（依次执行异步调用）。\n\n译者注：Vert.x 中的 Future 即异步开发模式中的 Future/Promise 模式的实现。\n\n并发合并\nCompositeFuture.all 方法接受多个 Future 对象作为参数（最多6个，或者传入 List）。当所有的 Future 都成功完成，该方法将返回一个 成功的 Future；当任一个 Future 执行失败，则返回一个 失败的 Future：\nFuture httpServerFuture = Future.future();\nhttpServer.listen(httpServerFuture.completer());\n\nFuture netServerFuture = Future.future();\nnetServer.listen(netServerFuture.completer());\n\nCompositeFuture.all(httpServerFuture, netServerFuture).setHandler(ar -> {\n if (ar.succeeded()) {\n // 所有服务器启动完成\n } else {\n // 有一个服务器启动失败\n }\n});\n\n所有被合并的 Future 中的操作同时运行。当组合的处理操作完成时，该方法返回的 Future 上绑定的处理器（Handler）会被调用。当一个操作失败（其中的某一个 Future 的状态被标记成失败），则返回的 Future 会被标记为失败。当所有的操作都成功时，返回的 Future 将会成功完成。\n您可以传入一个 Future 列表（可能为空）：\nCompositeFuture.all(Arrays.asList(future1, future2, future3));\n\n不同于 all 方法的合并会等待所有的 Future 成功执行（或任一失败），any 方法的合并会等待第一个成功执行的Future。CompositeFuture.any 方法接受多个 Future 作为参数（最多6个，或传入 List）。当任意一个 Future 成功得到结果，则该 Future 成功；当所有的 Future 都执行失败，则该 Future 失败。\nCompositeFuture.any(future1, future2).setHandler(ar -> {\n if (ar.succeeded()) {\n // 至少一个成功\n } else {\n // 所有的都失败\n }\n});\n\n它也可使用 Future 列表传参：\nCompositeFuture.any(Arrays.asList(f1, f2, f3));\n\njoin 方法的合并会等待所有的 Future 完成，无论成败。CompositeFuture.join 方法接受多个 Future 作为参数（最多6个），并将结果归并成一个 Future 。当全部 Future 成功执行完成，得到的 Future 是成功状态的；当至少一个 Future 执行失败时，得到的 Future 是失败状态的。\nCompositeFuture.join(future1, future2, future3).setHandler(ar -> {\n if (ar.succeeded()) {\n // 所有都成功\n } else {\n // 至少一个失败\n }\n});\n\n它也可使用 Future 列表传参：\nCompositeFuture.join(Arrays.asList(future1, future2, future3));\n\n顺序合并\n和 all 以及 any 实现的并发组合不同，compose 方法作用于顺序组合 Future。\nFileSystem fs = vertx.fileSystem();\nFuture startFuture = Future.future();\n\nFuture fut1 = Future.future();\nfs.createFile(\"/foo\", fut1.completer());\n\nfut1.compose(v -> {\n // fut1中文件创建完成后执行\n Future fut2 = Future.future();\n fs.writeFile(\"/foo\", Buffer.buffer(), fut2.completer());\n return fut2;\n}).compose(v -> {\n // fut2文件写入完成后执行\n fs.move(\"/foo\", \"/bar\", startFuture.completer());\n},\n // 如果任何一步失败，将startFuture标记成failed\n startFuture);\n\n这里例子中，有三个操作被串起来了：\n\n一个文件被创建（fut1）\n一些东西被写入到文件（fut2）\n文件被移走（startFuture）\n\n如果这三个步骤全部成功，则最终的 Future（startFuture）会是成功的；其中任何一步失败，则最终 Future 就是失败的。\n例子中使用了：\n\ncompose(mapper)：当前 Future 完成时，执行相关代码，并返回 Future。当返回的 Future 完成时，组合完成。\ncompose(handler, next)：当前 Future 完成时，执行相关代码，并完成下一个 Future 的处理。\n\n对于第二个例子，处理器需要完成 next future，以此来汇报处理成功或者失败。\n您可以使用 completer 方法来串起一个带操作结果的或失败的 Future ，它可使您避免用传统方式编写代码：如果成功则完成 Future，否则就标记为失败。（译者注：3.4.0 以后不需要再使用 completer 方法）\nVerticle\nVert.x 通过开箱即用的方式提供了一个简单便捷的、可扩展的、类似 Actor Model 的部署和并发模型机制。您可以用此模型机制来保管您自己的代码组件。\n这个模型是可选的，如果您不想这样做，Vert.x 不会强迫您用这种方式创建您的应用程序。\n这个模型不能说是严格的 Actor 模式的实现，但它确实有相似之处，特别是在并发、扩展性和部署等方面。\n要使用该模型，您需要将您的代码组织成一系列的 Verticle。\nVerticle 是由 Vert.x 部署和运行的代码块。默认情况一个 Vert.x 实例维护了N（默认情况下N = CPU核数 x 2）个 Event Loop 线程。Verticle 实例可使用任意 Vert.x 支持的编程语言编写，而且一个简单的应用程序也可以包含多种语言编写的 Verticle。\n您可以将 Verticle 想成 Actor Model 中的 Actor。\n一个应用程序通常是由在同一个 Vert.x 实例中同时运行的许多 Verticle 实例组合而成。不同的 Verticle 实例通过向 Event Bus 上发送消息来相互通信。\n编写 Verticle\nVerticle 的实现类必须实现 Verticle 接口。\n如果您喜欢的话，可以直接实现该接口，但是通常直接从抽象类 AbstractVerticle 继承更简单。\n这儿有一个例子：\npublic class MyVerticle extends AbstractVerticle {\n\n // Called when verticle is deployed\n // Verticle部署时调用\n public void start() {\n }\n\n // Optional - called when verticle is undeployed\n // 可选 - Verticle撤销时调用\n public void stop() {\n }\n\n}\n\n通常您需要像上边例子一样重写 start 方法。\n当 Vert.x 部署 Verticle 时，它的 start 方法将被调用，这个方法执行完成后 Verticle 就变成已启动状态。\n您同样可以重写 stop 方法，当Vert.x 撤销一个 Verticle 时它会被调用，这个方法执行完成后 Verticle 就变成已停止状态了。\nVerticle 异步启动和停止\n有些时候您的 Verticle 启动会耗费一些时间，您想要在这个过程做一些事，并且您做的这些事并不想等到Verticle部署完成过后再发生。如：您想在 start 方法中部署其他的 Verticle。\n您不能在您的 start 方法中阻塞等待其他的 Verticle 部署完成，这样做会破坏 黄金法则。\n所以您要怎么做？\n您可以实现 异步版本 的 start 方法来做这个事。这个版本的方法会以一个 Future 作参数被调用。方法执行完时，Verticle 实例并没有部署好（状态不是 deployed）。稍后，您完成了所有您需要做的事（如：启动其他Verticle），您就可以调用 Future 的 complete（或 fail ）方法来标记启动完成或失败了。\n这儿有一个例子：\npublic class MyVerticle extends AbstractVerticle {\n\n public void start(Future startFuture) {\n // 现在部署其他的一些verticle\n vertx.deployVerticle(\"com.foo.OtherVerticle\", res -> {\n if (res.succeeded()) {\n startFuture.complete();\n } else {\n startFuture.fail(res.cause());\n }\n });\n }\n}\n\n同样的，这儿也有一个异步版本的 stop 方法，如果您想做一些耗时的 Verticle 清理工作，您可以使用它。\npublic class MyVerticle extends AbstractVerticle {\n\n public void start() {\n // 做一些事\n }\n\n public void stop(Future stopFuture) {\n obj.doSomethingThatTakesTime(res -> {\n if (res.succeeded()) {\n stopFuture.complete();\n } else {\n stopFuture.fail();\n }\n });\n }\n}\n\n\n请注意：您不需要在一个 Verticle 的 stop 方法中手工去撤销启动时部署的子 Verticle，当父 Verticle 在撤销时 Vert.x 会自动撤销任何子 Verticle。\n\nVerticle 种类\n这儿有三种不同类型的 Verticle：\n\nStardand Verticle：这是最常用的一类 Verticle —— 它们永远运行在 Event Loop 线程上。稍后的章节我们会讨论更多。\nWorker Verticle：这类 Verticle 会运行在 Worker Pool 中的线程上。一个实例绝对不会被多个线程同时执行。\nMulti-Threaded Worker Verticle：这类 Verticle 也会运行在 Worker Pool 中的线程上。一个实例可以由多个线程同时执行（译者注：因此需要开发者自己确保线程安全）。\n\nStandard Verticle\n当 Standard Verticle 被创建时，它会被分派给一个 Event Loop 线程，并在这个 Event Loop 中执行它的 start 方法。当您在一个 Event Loop 上调用了 Core API 中的方法并传入了处理器时，Vert.x 将保证用与调用该方法时相同的 Event Loop 来执行这些处理器。\n这意味着我们可以保证您的 Verticle 实例中 所有的代码都是在相同Event Loop中执行（只要您不创建自己的线程并调用它！）\n同样意味着您可以将您的应用中的所有代码用单线程方式编写，让 Vert.x 去考虑线程和扩展问题。您不用再考虑 synchronized 和 volatile 的问题，也可以避免传统的多线程应用经常会遇到的竞态条件和死锁的问题。\nWorker Verticle\nWorker Verticle 和 Standard Verticle 很像，但它并不是由一个 Event Loop 来执行，而是由Vert.x中的 Worker Pool 中的线程执行。\nWorker Verticle 被设计来调用阻塞式代码，它不会阻塞任何 Event Loop。\n如果您不想使用 Worker Verticle 来运行阻塞式代码，您还可以在一个Event Loop中直接使用 内联阻塞式代码。\n若您想要将 Verticle 部署成一个 Worker Verticle，您可以通过 setWorker 方法来设置：\nDeploymentOptions options = new DeploymentOptions().setWorker(true);\nvertx.deployVerticle(\"com.mycompany.MyOrderProcessorVerticle\", options);\n\nWorker Verticle 实例绝对不会在 Vert.x 中被多个线程同时执行，但它可以在不同时间由不同线程执行。\nMulti-threaded Worker Verticle\n一个 Multi-threaded Worker Verticle 近似于普通的 Worker Verticle，但是它可以由不同的线程同时执行。\n\n警告：Multi-threaded Worker Verticle 是一个高级功能，大部分应用程序不会需要它。由于这些 Verticle 是并发的，您必须小心地使用标准的Java多线程技术来保持 Verticle 的状态一致性。\n\n编程方式部署Verticle\n您可以指定一个 Verticle 名称或传入您已经创建好的 Verticle 实例，使用任意一个 deployVerticle 方法来部署Verticle。\n\n请注意：通过 Verticle 实例 来部署 Verticle 仅限Java语言。\n\nVerticle myVerticle = new MyVerticle();\nvertx.deployVerticle(myVerticle);\n\n您同样可以指定 Verticle 的 名称 来部署它。\n这个 Verticle 的名称会用于查找实例化 Verticle 的特定 VerticleFactory。\n不同的 Verticle Factory 可用于实例化不同语言的 Verticle，也可用于其他目的，例如加载服务、运行时从Maven中获取Verticle实例等。\n这允许您部署用任何使用Vert.x支持的语言编写的Verticle实例。\n这儿有一个部署不同类型 Verticle 的例子：\nvertx.deployVerticle(\"com.mycompany.MyOrderProcessorVerticle\");\n\n// 部署JavaScript的Verticle\nvertx.deployVerticle(\"verticles/myverticle.js\");\n\n// 部署Ruby的Verticle\nvertx.deployVerticle(\"verticles/my_verticle.rb\");\n\nVerticle名称到Factory的映射规则\n当使用名称部署Verticle时，会通过名称来选择一个用于实例化 Verticle 的 Verticle Factory。\nVerticle 名称可以有一个前缀 —— 使用字符串紧跟着一个冒号，它用于查找存在的Factory，参考例子。\njs:foo.js // 使用JavaScript的Factory\ngroovy:com.mycompany.SomeGroovyCompiledVerticle // 用Groovy的Factory\nservice:com.mycompany:myorderservice // 用Service的Factory\n如果不指定前缀，Vert.x将根据提供名字后缀来查找对应Factory，如：\nfoo.js // 将使用JavaScript的Factory\nSomeScript.groovy // 将使用Groovy的Factory\n若前缀后缀都没指定，Vert.x将假定这个名字是一个Java 全限定类名（FQCN）然后尝试实例化它。\n如何定位Verticle Factory？\n大部分Verticle Factory会从 classpath 中加载，并在 Vert.x 启动时注册。\n您同样可以使用编程的方式去注册或注销Verticle Factory：通过 registerVerticleFactory 方法和 unregisterVerticleFactory 方法。\n等待部署完成\nVerticle的部署是异步方式，可能在 deploy 方法调用返回后一段时间才会完成部署。\n如果您想要在部署完成时被通知则可以指定一个完成处理器：\nvertx.deployVerticle(\"com.mycompany.MyOrderProcessorVerticle\", res -> {\n if (res.succeeded()) {\n System.out.println(\"Deployment id is: \" + res.result());\n } else {\n System.out.println(\"Deployment failed!\");\n }\n});\n\n如果部署成功，这个完成处理器的结果中将会包含部署ID的字符串。这个部署 ID可以在之后您想要撤销它时使用。\n撤销Verticle\n我们可以通过 undeploy 方法来撤销部署好的 Verticle。\n撤销操作也是异步的，因此若您想要在撤销完成过后收到通知则可以指定另一个完成处理器：\nvertx.undeploy(deploymentID, res -> {\n if (res.succeeded()) {\n System.out.println(\"Undeployed ok\");\n } else {\n System.out.println(\"Undeploy failed!\");\n }\n});\n\n设置 Verticle 实例数\n当使用名称部署一个 Verticle 时，您可以指定您想要部署的 Verticle 实例的数量。\nDeploymentOptions options = new DeploymentOptions().setInstances(16);\nvertx.deployVerticle(\"com.mycompany.MyOrderProcessorVerticle\", options);\n\n这个功能对于跨多核扩展时很有用。例如，您有一个实现了Web服务器的Verticle需要部署在多核的机器上，您可以部署多个实例来利用所有的核。\n向 Verticle 传入配置\n可在部署时传给 Verticle 一个 JSON 格式的配置\nJsonObject config = new JsonObject().put(\"name\", \"tim\").put(\"directory\", \"/blah\");\nDeploymentOptions options = new DeploymentOptions().setConfig(config);\nvertx.deployVerticle(\"com.mycompany.MyOrderProcessorVerticle\", options);\n\n传入之后，这个配置可以通过 Context 对象或使用 config 方法访问。\n这个配置会以 JSON 对象（JsonObject）的形式返回，因此您可以用下边代码读取数据：\nSystem.out.println(\"Configuration: \" + config().getString(\"name\"));\n\n在 Verticle 中访问环境变量\n环境变量和系统属性可以直接通过 Java API 访问：\nSystem.getProperty(\"prop\");\nSystem.getenv(\"HOME\");\n\nVerticle 隔离组\n默认情况，当Vert.x部署Verticle时它会调用当前类加载器来加载类，而不会创建一个新的。大多数情况下，这是最简单、最清晰和最干净。\n但是在某些情况下，您可能需要部署一个Verticle，它包含的类要与应用程序中其他类隔离开来。比如您想要在一个Vert.x实例中部署两个同名不同版本的Verticle，或者不同的Verticle使用了同一个jar包的不同版本。\n当使用隔离组时，您需要用 setIsolatedClassed 方法来提供一个您想隔离的类名列表。列表项可以是一个Java 限定类全名，如 com.mycompany.myproject.engine.MyClass；也可以是包含通配符的可匹配某个包或子包的任何类，例如 com.mycompany.myproject.* 将会匹配所有 com.mycompany.myproject 包或任意子包中的任意类名。\n请注意仅仅只有匹配的类会被隔离，其他任意类会被当前类加载器加载。\n若您想要加载的类和资源不存在于主类路径（main classpath），您可使用 setExtraClasspath 方法将额外的类路径添加到这里。\n\n警告：谨慎使用此功能，类加载器可能会导致您的应用难于调试，变得一团乱麻（can of worms）。\n\n以下是使用隔离组隔离 Verticle 的部署例子：\nDeploymentOptions options = new DeploymentOptions().setIsolationGroup(\"mygroup\");\noptions.setIsolatedClasses(Arrays.asList(\"com.mycompany.myverticle.*\",\n \"com.mycompany.somepkg.SomeClass\", \"org.somelibrary.*\"));\nvertx.deployVerticle(\"com.mycompany.myverticle.VerticleClass\", options);\n\n高可用性\nVerticle可以启用高可用方式（HA）部署。在这种方式下，当其中一个部署在 Vert.x 实例中的 Verticle 突然挂掉，这个 Verticle 可以在集群环境中的另一个 Vert.x 实例中重新部署。\n若要启用高可用方式运行一个 Verticle，仅需要追加 -ha 参数：\nvertx run my-verticle.js -ha\n当启用高可用方式时，不需要追加 -cluster 参数。\n关于高可用的功能和配置的更多细节可参考 高可用和故障转移 章节。\n从命令行运行Verticle\n您可以在 Maven 或 Gradle 项目中以正常方式添加 Vert.x Core 为依赖，在项目中直接使用 Vert.x。\n但是，您也可以从命令行直接运行 Vert.x 的 Verticle。\n为此，您需要下载并安装 Vert.x 的发行版，并且将安装的 bin 目录添加到您的 PATH 环境变量中，还要确保您的 PATH 中设置了Java 8的JDK环境。\n\n请注意：JDK需要支持Java代码的运行时编译（on the fly compilation）。\n\n现在您可以使用 vertx run 命令运行Verticle了，这儿是一些例子：\n# 运行JavaScript的Verticle\nvertx run my_verticle.js\n\n# 运行Ruby的Verticle\nvertx run a_n_other_verticle.rb\n\n# 使用集群模式运行Groovy的Verticle\nvertx run FooVerticle.groovy -cluster\n您甚至可以不必编译 Java 源代码，直接运行它：\nvertx run SomeJavaSourceFile.java\nVert.x 将在运行它之前对 Java 源代码文件执行运行时编译，这对于快速原型制作和演示很有用。不需要设置 Maven 或 Gradle 就能跑起来！\n欲了解有关在命令行执行 vertx 可用的各种选项完整信息，可以直接在命令行键入 vertx 查看帮助。\n退出 Vert.x 环境\nVert.x 实例维护的线程不是守护线程，因此它们会阻止JVM退出。\n如果您通过嵌入式的方式使用 Vert.x 并且完成了操作，您可以调用 close 方法关闭它。这将关闭所有内部线程池并关闭其他资源，允许JVM退出。\nContext 对象\n当 Vert.x 传递一个事件给处理器或者调用 Verticle 的 start 或 stop 方法时，它会关联一个 Context 对象来执行。通常来说这个 Context 会是一个 Event Loop Context，它绑定到了一个特定的 Event Loop 线程上。所以在该 Context 上执行的操作总是在同一个 Event Loop 线程中。对于运行内联的阻塞代码的 Worker Verticle 来说，会关联一个 Worker Context，并且所有的操作运都会运行在 Worker 线程池的线程上。\n\n译者注：每个 Verticle 在部署的时候都会被分配一个 Context（根据配置不同，可以是Event Loop Context 或者 Worker Context），之后此 Verticle 上所有的普通代码都会在此 Context 上执行（即对应的 Event Loop 或Worker 线程）。一个 Context 对应一个 Event Loop 线程（或 Worker 线程），但一个 Event Loop 可能对应多个 Context。\n\n您可以通过 getOrCreateContext 方法获取 Context 实例：\nContext context = vertx.getOrCreateContext();\n\n若已经有一个 Context 和当前线程关联，那么它直接重用这个 Context 对象，如果没有则创建一个新的。您可以检查获取的 Context 的类型：\nContext context = vertx.getOrCreateContext();\nif (context.isEventLoopContext()) {\n System.out.println(\"Context attached to Event Loop\");\n} else if (context.isWorkerContext()) {\n System.out.println(\"Context attached to Worker Thread\");\n} else if (context.isMultiThreadedWorkerContext()) {\n System.out.println(\"Context attached to Worker Thread - multi threaded worker\");\n} else if (! Context.isOnVertxThread()) {\n System.out.println(\"Context not attached to a thread managed by vert.x\");\n}\n\n当您获取了这个 Context 对象，您就可以在 Context 中异步执行代码了。换句话说，您提交的任务将会在同一个 Context 中运行：\nvertx.getOrCreateContext().runOnContext(v -> {\n System.out.println(\"This will be executed asynchronously in the same context\");\n});\n\n当在同一个 Context 中运行了多个处理函数时，可能需要在它们之间共享数据。 Context 对象提供了存储和读取共享数据的方法。举例来说，它允许您将数据传递到 runOnContext 方法运行的某些操作中：\nfinal Context context = vertx.getOrCreateContext();\ncontext.put(\"data\", \"hello\");\ncontext.runOnContext((v) -> {\n String hello = context.get(\"data\");\n});\n\n您还可以通过 config 方法访问 Verticle 的配置信息。查看 向 Verticle 传入配置 章节了解更多配置信息。\n执行周期性/延迟性操作\n在 Vert.x 中，想要延迟之后执行或定期执行操作很常见。\n在 Standard Verticle 中您不能直接让线程休眠以引入延迟，因为它会阻塞 Event Loop 线程。取而代之是使用 Vert.x 定时器。定时器可以是一次性或周期性的，两者我们都会讨论到。\n一次性计时器\n一次性计时器会在一定延迟后调用一个 Event Handler，以毫秒为单位计时。\n您可以通过 setTimer 方法传递延迟时间和一个处理器来设置计时器的触发。\nlong timerID = vertx.setTimer(1000, id -> {\n System.out.println(\"And one second later this is printed\");\n});\n\nSystem.out.println(\"First this is printed\");\n\n返回值是一个唯一的计时器id，该id可用于之后取消该计时器，这个计时器id会传入给处理器。\n周期性计时器\n您同样可以使用 setPeriodic 方法设置一个周期性触发的计时器。第一次触发之前同样会有一段设置的延时时间。\nsetPeriodic 方法的返回值也是一个唯一的计时器id，若之后该计时器需要取消则使用该id。传给处理器的参数也是这个唯一的计时器id。\n请记住这个计时器将会定期触发。如果您的定时任务会花费大量的时间，则您的计时器事件可能会连续执行甚至发生更坏的情况：重叠。这种情况，您应考虑使用 setTimer 方法，当任务执行完成时设置下一个计时器。\nlong timerID = vertx.setPeriodic(1000, id -> {\n System.out.println(\"And every second this is printed\");\n});\n\nSystem.out.println(\"First this is printed\");\n\n取消计时器\n指定一个计时器id并调用 cancelTimer 方法来取消一个周期性计时器。如：\nvertx.cancelTimer(timerID);\n\nVerticle 中自动清除定时器\n如果您在 Verticle 中创建了计时器，当这个 Verticle 被撤销时这个计时器会被自动关闭。\nVerticle Worker Pool\nVerticle 使用 Vert.x 中的 Worker Pool 来执行阻塞式行为，例如 executeBlocking 或 Worker Verticle。\n可以在部署配置项中指定不同的Worker 线程池：\nvertx.deployVerticle(\"the-verticle\", new DeploymentOptions().setWorkerPoolName(\"the-specific-pool\"));\n\nEvent Bus\nEvent Bus 是 Vert.x 的神经系统。\n每一个 Vert.x 实例都有一个单独的 Event Bus 实例。您可以通过 Vertx 实例的 eventBus 方法来获得对应的 EventBus 实例。\n您的应用中的不同部分通过 Event Bus 相互通信，无论它们使用哪一种语言实现，无论它们在同一个 Vert.x 实例中或在不同的 Vert.x 实例中。\n甚至可以通过桥接的方式允许在浏览器中运行的客户端JavaScript在相同的Event Bus上相互通信。\nEvent Bus可形成跨越多个服务器节点和多个浏览器的点对点的分布式消息系统。\nEvent Bus支持发布/订阅、点对点、请求/响应的消息通信方式。\nEvent Bus的API很简单。基本上只涉及注册处理器、撤销处理器和发送和发布消息。\n首先来看些基本概念和理论。\n基本概念\n寻址\n消息会被 Event Bus 发送到一个 地址(address)。\n同任何花哨的寻址方案相比，Vert.x的地址格式并不麻烦。Vert.x中的地址是一个简单的字符串，任意字符串都合法。当然，使用某种模式来命名仍然是明智的。如：使用点号来划分命名空间。\n一些合法的地址形如：europe.news.feed1、acme.games.pacman、sausages和X。\n处理器\n消息在处理器（Handler）中被接收。您可以在某个地址上注册一个处理器来接收消息。\n同一个地址可以注册许多不同的处理器，一个处理器也可以注册在多个不同的地址上。\n发布/订阅消息\nEvent Bus支持 发布消息 功能。\n消息将被发布到一个地址中，发布意味着会将信息传递给 所有 注册在该地址上的处理器。这和 发布/订阅模式 很类似。\n点对点模式/请求-响应模式\nEvent Bus也支持 点对点消息模式。\n消息将被发送到一个地址中，Vert.x将会把消息分发到某个注册在该地址上的处理器。若这个地址上有不止一个注册过的处理器，它将使用 不严格的轮询算法 选择其中一个。\n点对点消息传递模式下，可在消息发送的时候指定一个应答处理器（可选）。\n当接收者收到消息并且已经被处理时，它可以选择性决定回复该消息，若选择回复则绑定的应答处理器将会被调用。当发送者收到回复消息时，它也可以回复，这个过程可以不断重复。通过这种方式可以允许在两个不同的 Verticle 之间设置一个对话窗口。这种消息模式被称作 请求-响应 模式。\n尽力传输\nVert.x会尽它最大努力去传递消息，并且不会主动丢弃消息。这种方式称为 尽力传输(Best-effort delivery)。\n但是，当 Event Bus 中的全部或部分发生故障时，则可能会丢失消息。\n若您的应用关心丢失的消息，您应该编写具有幂等性的处理器，并且您的发送者可以在恢复后重试。\n\n译者注：RPC通信通常情况下有三种语义：at least once、at most once 和 exactly once。不同语义情况下要考虑的情况不同。\n\n消息类型\nVert.x 默认允许任何基本/简单类型、String 或 Buffer 作为消息发送。不过在 Vert.x 中的通常做法是使用 JSON 格式来发送消息。\nJSON 对于 Vert.x 支持的所有语言都是非常容易创建、读取和解析的，因此它已经成为了Vert.x中的通用语(lingua franca)。但是若您不想用 JSON，我们并不强制您使用它。\nEvent Bus 非常灵活，它支持在 Event Bus 中发送任意对象。您可以通过为您想要发送的对象自定义一个 MessageCodec 来实现。\nEvent Bus API\n下面我们来看一下 API。\n获取Event Bus\n您可以通过下面的代码获取 Event Bus 的引用：\nEventBus eb = vertx.eventBus();\n\n对于每一个 Vert.x 实例来说它是单例的。\n注册处理器\n最简单的注册处理器的方式是使用 consumer 方法，这儿有个例子：\nEventBus eb = vertx.eventBus();\n\neb.consumer(\"news.uk.sport\", message -> {\n System.out.println(\"I have received a message: \" + message.body());\n});\n\n当一个消息达到您的处理器，该处理器会以 message 为参数被调用。\n调用 consumer 方法会返回一个 MessageConsumer 对象。该对象随后可用于撤销处理器、或将处理器用作流式处理。\n您也可以不设置处理器而使用 consumer 方法直接返回一个 MessageConsumer，之后再来设置处理器。如：\nEventBus eb = vertx.eventBus();\n\nMessageConsumer consumer = eb.consumer(\"news.uk.sport\");\nconsumer.handler(message -> {\n System.out.println(\"I have received a message: \" + message.body());\n});\n\n在集群模式下的Event Bus上注册处理器时，注册信息会花费一些时间才能传播到集群中的所有节点。\n若您希望在完成注册后收到通知，您可以在 MessageConsumer 对象上注册一个 completion handler。\nconsumer.completionHandler(res -> {\n if (res.succeeded()) {\n System.out.println(\"The handler registration has reached all nodes\");\n } else {\n System.out.println(\"Registration failed!\");\n }\n});\n\n注销处理器\n您可以通过 unregister() 方法来注销处理器。\n若您在集群模式下的 Event Bus 中撤销处理器，则同样会花费一些时间在节点中传播。若您想在完成后收到通知，可以使用unregister(handler) 方法注册处理器：\nconsumer.unregister(res -> {\n if (res.succeeded()) {\n System.out.println(\"The handler un-registration has reached all nodes\");\n } else {\n System.out.println(\"Un-registration failed!\");\n }\n});\n\n发布消息\n发布消息很简单，只需使用 publish 方法指定一个地址去发布即可。\neventBus.publish(\"news.uk.sport\", \"Yay! Someone kicked a ball\");\n\n这个消息将会传递给所有在地址 news.uk.sport 上注册过的处理器。\n发送消息\n与发布消息的不同之处在于，发送(send)的消息只会传递给在该地址注册的其中一个处理器，这就是点对点模式。Vert.x 使用不严格的轮询算法来选择绑定的处理器。\n您可以使用 send 方法来发送消息：\neventBus.send(\"news.uk.sport\", \"Yay! Someone kicked a ball\");\n\n设置消息头\n在 Event Bus 上发送的消息可包含头信息。这可通过在发送或发布时提供的 DeliveryOptions 来指定。例如：\nDeliveryOptions options = new DeliveryOptions();\noptions.addHeader(\"some-header\", \"some-value\");\neventBus.send(\"news.uk.sport\", \"Yay! Someone kicked a ball\", options);\n\n消息顺序\nVert.x将按照特定发送者发送消息的顺序来传递消息给特定处理器。\n消息对象\n您在消息处理器中接收到的对象的类型是 Message。\n消息的 body 对应发送或发布的对象。消息的头信息可以通过 headers 方法获取。\n应答消息/发送回复\n当使用 send 方法发送消息时，Event Bus会尝试将消息传递到注册在Event Bus上的 MessageConsumer中。在某些情况下，发送者需要知道消费者何时收到消息并 处理 了消息。\n消费者可以通过调用 reply 方法来应答这个消息。\n当这种情况发生时，它会将消息回复给发送者并且在发送者中调用应答处理器来处理回复的消息。\n看这个例子会更清楚：\n接收者：\nMessageConsumer consumer = eventBus.consumer(\"news.uk.sport\");\nconsumer.handler(message -> {\n System.out.println(\"I have received a message: \" + message.body());\n message.reply(\"how interesting!\");\n});\n\n发送者：\neventBus.send(\"news.uk.sport\", \"Yay! Someone kicked a ball across a patch of grass\", ar -> {\n if (ar.succeeded()) {\n System.out.println(\"Received reply: \" + ar.result().body());\n }\n});\n\n在应答的消息体中可以包含有用的信息。\n关于 处理中 的含义实际上是由应用程序来定义的。这完全取决于消费者如何执行，Event Bus 对此并不关心。\n一些例子：\n\n一个简单地实现了返回当天时间的服务，在应答的消息里会包含当天时间信息。\n一个实现了持久化队列的消息消费者，当消息成功持久化到存储时，可以使用true来应答消息，或false表示失败。\n一个处理订单的消息消费者也许会用true确认这个订单已经成功处理并且可以从数据库中删除。\n\n带超时的发送\n当发送带有应答处理器的消息时，可以在 DeliveryOptions 中指定一个超时时间。如果在这个时间之内没有收到应答，则会以失败为参数调用应答处理器。默认超时是 30 秒。\n发送失败\n消息发送可能会因为其他原因失败，包括：\n\n没有可用的处理器来接收消息\n接收者调用了 fail 方法显式声明失败\n\n发生这些情况时，应答处理器将会以这些失败为参数被调用。\n消息编解码器\n您可以在 Event Bus 中发送任何对象，只要你为这个对象类型注册一个编解码器 MessageCodec。消息编解码器有一个名称，您需要在发送或发布消息时通过 DeliveryOptions 来指定：\neventBus.registerCodec(myCodec);\n\nDeliveryOptions options = new DeliveryOptions().setCodecName(myCodec.name());\n\neventBus.send(\"orders\", new MyPOJO(), options);\n\n若您总是希望某个类使用将特定的编解码器，那么您可以为这个类注册默认编解码器。这样您就不需要在每次发送的时候使用 DeliveryOptions 来指定了：\neventBus.registerDefaultCodec(MyPOJO.class, myCodec);\n\neventBus.send(\"orders\", new MyPOJO());\n\n您可以通过 unregisterCodec 方法注销某个消息编解码器。\n消息编解码器的编码和解码不一定使用同一个类型。例如您可以编写一个编解码器来发送 MyPOJO 类的对象，但是当消息发送给处理器后解码成 MyOtherPOJO 对象。\n集群模式的 Event Bus\nEvent Bus 不仅仅存在于单个 Vert.x 实例中。通过您在网络上将不同的 Vert.x 实例集群在一起，它可以形成一个单一的、分布式的Event Bus。\n通过代码的方式启用集群模式\n若您用编程的方式创建 Vert.x 实例（Vertx），则可以通过将 Vert.x 实例配置成集群模式来获取集群模式的Event Bus：\nVertxOptions options = new VertxOptions();\nVertx.clusteredVertx(options, res -> {\n if (res.succeeded()) {\n Vertx vertx = res.result();\n EventBus eventBus = vertx.eventBus();\n System.out.println(\"We now have a clustered event bus: \" + eventBus);\n } else {\n System.out.println(\"Failed: \" + res.cause());\n }\n});\n\n您需要确在您的 classpath 中（或构建工具的依赖中）包含 ClusterManager 的实现类，如默认的 HazelcastClusterManager。\n通过命令行启用集群模式\n您可以通过以下命令以集群模式运行 Vert.x 应用：\nvertx run my-verticle.js -cluster\nVerticle 中的自动清理\n若您在 Verticle 中注册了 Event Bus 的处理器，那么这些处理器在 Verticle 被撤销的时候会自动被注销。\n配置 Event Bus\nEvent Bus 是可以配置的，这对于以集群模式运行的 Event Bus 是非常有用的。Event Bus 使用 TCP 连接发送和接收消息，因此可以通过 EventBusOptions 对TCP连接进行全面的配置。由于 Event Bus 同时用作客户端和服务器，因此这些配置近似于 NetClientOptions 和 NetServerOptions。\nVertxOptions options = new VertxOptions()\n .setEventBusOptions(new EventBusOptions()\n .setSsl(true)\n .setKeyStoreOptions(new JksOptions().setPath(\"keystore.jks\").setPassword(\"wibble\"))\n .setTrustStoreOptions(new JksOptions().setPath(\"keystore.jks\").setPassword(\"wibble\"))\n .setClientAuth(ClientAuth.REQUIRED)\n );\n\nVertx.clusteredVertx(options, res -> {\n if (res.succeeded()) {\n Vertx vertx = res.result();\n EventBus eventBus = vertx.eventBus();\n System.out.println(\"We now have a clustered event bus: \" + eventBus);\n } else {\n System.out.println(\"Failed: \" + res.cause());\n }\n});\n\n上边代码段描述了如何在Event Bus中使用SSL连接替换传统的TCP连接。\n\n警告： 若要在集群模式下保证安全性，您 必须 将集群管理器配置成加密的或强制安全的。参考集群管理器的文档获取更多细节。\n\nEvent Bus 的配置需要在所有集群节点中保持一致性。\nEventBusOptions还允许您指定 Event Bus 是否运行在集群模式下，以及它的主机信息和端口。您可使用 setClustered、getClusterHost和 getClusterPort 方法来设置。\n在容器中使用时，您也可以配置公共主机和端口号：\nVertxOptions options = new VertxOptions()\n .setEventBusOptions(new EventBusOptions()\n .setClusterPublicHost(\"whatever\")\n .setClusterPublicPort(1234)\n );\n\nVertx.clusteredVertx(options, res -> {\n if (res.succeeded()) {\n Vertx vertx = res.result();\n EventBus eventBus = vertx.eventBus();\n System.out.println(\"We now have a clustered event bus: \" + eventBus);\n } else {\n System.out.println(\"Failed: \" + res.cause());\n }\n});\n\nJSON\n和其他一些语言不同，Java 没有对 JSON 的原生支持（first class support），因此我们提供了两个类，以便在 Vert.x 应用中处理 JSON 更容易。\nJSON 对象\nJsonObject 类用来描述JSON对象。\n一个JSON 对象基本上只是一个 Map 结构。它具有字符串的键，值可以是任意一种JSON 支持的类型（如 string, number, boolean）。\nJSON 对象也支持 null 值。\n创建 JSON 对象\n可以使用默认构造函数创建空的JSON对象。\n您可以通过一个 JSON 格式的字符串创建JSON对象：\nString jsonString = \"{\\\"foo\\\":\\\"bar\\\"}\";\nJsonObject object = new JsonObject(jsonString);\n\n您可以从通过一个Map创建JSON对象：\nMap map = new HashMap<>();\nmap.put(\"foo\", \"bar\");\nmap.put(\"xyz\", 3);\nJsonObject object = new JsonObject(map);\n\n将键值对放入 JSON 对象\n使用put 方法可以将值放入到JSON对象里。\n这个API是流式的，因此这个方法可以被链式地调用。\nJsonObject object = new JsonObject();\nobject.put(\"foo\", \"bar\").put(\"num\", 123).put(\"mybool\", true);\n\n从 JSON 对象获取值\n您可使用 getXXX 方法从JSON对象中获取值。例如：\nString val = jsonObject.getString(\"some-key\");\nint intVal = jsonObject.getInteger(\"some-other-key\");\n\nJSON 对象和 Java 对象间的映射\n您可以从 Java 对象的字段创建一个JSON 对象，如下所示：\n你可以通过一个JSON 对象来实例化一个Java 对象并填充字段值。如下所示：\nrequest.bodyHandler(buff -> {\n JsonObject jsonObject = buff.toJsonObject();\n User javaObject = jsonObject.mapTo(User.class);\n});\n\n请注意上述代码直接使用了 Jackson 的 ObjectMapper#convertValue() 来执行映射。关于字段和构造函数的可见性的影响、对象引用的序列化和反序列化的问题等等可参考 Jackson 的文档获取更多信息。\n在最简单的情况下，如果 Java 类中所有的字段都是 public（或者有 public 的 getter/setter）时，并且有一个 public 的默认构造函数（或不定义构造函数），mapFrom 和 mapTo 都应该成功。\n只要不存在对象的循环引用，嵌套的 Java 对象可以被序列化/反序列化为嵌套的JSON对象。\n将 JSON 对象编码成字符串\n您可使用 encode 方法将一个对象编码成字符串格式。\n\n译者注：如要得到更优美、格式化的字符串，可以使用 encodePrettily 方法。\n\nJSON 数组\nJsonArray 类用来描述 JSON数组。\n一个JSON 数组是一个值的序列（值的类型可以是 string、number、boolean 等）。\nJSON 数组同样可以包含 null 值。\n创建 JSON 数组\n可以使用默认构造函数创建空的JSON数组。\n您可以从JSON格式的字符串创建一个JSON数组：\nString jsonString = \"[\\\"foo\\\",\\\"bar\\\"]\";\nJsonArray array = new JsonArray(jsonString);\n\n将数组项添加到JSON数组\n您可以使用 add 方法添加数组项到JSON数组中：\nJsonArray array = new JsonArray();\narray.add(\"foo\").add(123).add(false);\n\n从 JSON 数组中获取值\n您可使用 getXXX 方法从JSON 数组中获取值。例如：\nString val = array.getString(0);\nInteger intVal = array.getInteger(1);\nBoolean boolVal = array.getBoolean(2);\n\n将 JSON 数组编码成字符串\n您可使用 encode 将一个 JsonArray 编码成字符串格式。\nBuffer\n在 Vert.x 内部，大部分数据被重新组织（shuffle，表意为洗牌）成 Buffer 格式。\n一个 Buffer 是可以读取或写入的0个或多个字节序列，并且根据需要可以自动扩容、将任意字节写入 Buffer。您也可以将 Buffer 想象成字节数组（译者注：类似于 JDK 中的 ByteBuffer）。\n创建 Buffer\n可以使用静态方法 Buffer.buffer 来创建 Buffer。\nBuffer 可以从字符串或字节数组初始化，或者直接创建空的 Buffer。\n这儿有一些创建 Buffer 的例子。\n创建一个空的 Buffer：\nBuffer buff = Buffer.buffer();\n\n从字符串创建一个 Buffer，这个 Buffer 中的字符会以 UTF-8 格式编码：\nBuffer buff = Buffer.buffer(\"some string\");\n\n从字符串创建一个 Buffer，这个字符串可以用指定的编码方式编码，例如：\nBuffer buff = Buffer.buffer(\"some string\", \"UTF-16\");\n\n从字节数组 byte[] 创建 Buffer：\nbyte[] bytes = new byte[] {1, 3, 5};\nBuffer buff = Buffer.buffer(bytes);\n\n创建一个指定初始大小的 Buffer。若您知道您的 Buffer 会写入一定量的数据，您可以创建 Buffer 并指定它的大小。这使得这个 Buffer 初始化时分配了更多的内存，比数据写入时重新调整大小的效率更高。注意以这种方式创建的 Buffer 是 空的。它不会创建一个填满了 0 的Buffer。代码如下：\nBuffer buff = Buffer.buffer(10000);\n\n向Buffer写入数据\n向 Buffer 写入数据的方式有两种：追加和随机写入。任何一种情况下 Buffer 都会自动进行扩容，所以不可能在使用 Buffer 时遇到 IndexOutOfBoundsException。\n追加到Buffer\n您可以使用 appendXXX 方法追加数据到 Buffer。Buffer 类提供了追加各种不同类型数据的追加写入方法。\n因为 appendXXX 方法的返回值就是 Buffer 自身，所以它可以链式地调用:\nBuffer buff = Buffer.buffer();\n\nbuff.appendInt(123).appendString(\"hello\\n\");\n\nsocket.write(buff);\n\n随机访问写Buffer\n您还可以指定一个索引值，通过 setXXX 方法写入数据到 Buffer，它也存在各种不同数据类型的方法。所有的 set 方法都会将索引值作为第一个参数 —— 这表示 Buffer 中开始写入数据的位置。Buffer 始终根据需要进行自动扩容。\nBuffer buff = Buffer.buffer();\n\nbuff.setInt(1000, 123);\nbuff.setString(0, \"hello\");\n\n从Buffer中读取\n可使用 getXXX 方法从 Buffer 中读取数据，它存在各种不同数据类型的方法，这些方法的第一个参数是从哪里获取数据的索引（获取位置）。\nBuffer buff = Buffer.buffer();\nfor (int i = 0; i \n使用无符号数\n可使用 getUnsignedXXX、appendUnsignedXXX 和 setUnsignedXXX 方法将无符号数从 Buffer 中读取或追加/设置到 Buffer 里。这对以优化网络协议和最小化带宽消耗为目的实现的编解码器是很有用的。\n下边例子中，值 200 被设置到了仅占用一个字节的特定位置：\nBuffer buff = Buffer.buffer(128);\nint pos = 15;\nbuff.setUnsignedByte(pos, (short) 200);\nSystem.out.println(buff.getUnsignedByte(pos));\n\n控制台中显示 200。\nBuffer长度\n可使用 length 方法获取Buffer长度，Buffer的长度值是Buffer中包含的字节的最大索引 + 1。\n拷贝Buffer\n可使用 copy 方法创建一个Buffer的副本。\n裁剪Buffer\n裁剪得到的Buffer是基于原始Buffer的一个新的Buffer。它不会拷贝实际的数据。使用 slice 方法裁剪一个Buffer。\nBuffer 重用\n将Buffer写入到一个Socket或其他类似位置后，Buffer就不可被重用了。\n编写 TCP 服务端和客户端\nVert.x允许您很容易编写非阻塞的TCP客户端和服务器。\n创建 TCP 服务端\n最简单地使用所有默认配置项创建 TCP 服务端的方式如下：\nNetServer server = vertx.createNetServer();\n\n配置 TCP 服务端\n若您不想使用默认配置，可以在创建时通过传入一个 NetServerOptions 实例来配置服务器：\nNetServerOptions options = new NetServerOptions().setPort(4321);\nNetServer server = vertx.createNetServer(options);\n\n启动服务端监听\n要告诉服务端监听传入的请求，您可以使用其中一个 listen 方法。\n让服务器监听配置项指定的主机和端口：\nNetServer server = vertx.createNetServer();\nserver.listen();\n\n或在调用 listen 方法时指定主机和端口号，忽略配置项中的配置：\nNetServer server = vertx.createNetServer();\nserver.listen(1234, \"localhost\");\n\n默认主机名是 0.0.0.0，它表示：监听所有可用地址。默认端口号是 0，这也是一个特殊值，它告诉服务器随机选择并监听一个本地没有被占用的端口。\n实际的绑定也是异步的，因此服务器在调用了 listen 方法的一段时间之后才会实际开始监听。若您希望在服务器实际监听时收到通知，您可以在调用 listen 方法时提供一个处理器。例如：\nNetServer server = vertx.createNetServer();\nserver.listen(1234, \"localhost\", res -> {\n if (res.succeeded()) {\n System.out.println(\"Server is now listening!\");\n } else {\n System.out.println(\"Failed to bind!\");\n }\n});\n\n监听随机端口\n若设置监听端口为0，服务器将随机寻找一个没有使用的端口来监听。\n可以调用 actualPort 方法来获得服务器实际监听的端口：\nNetServer server = vertx.createNetServer();\nserver.listen(0, \"localhost\", res -> {\n if (res.succeeded()) {\n System.out.println(\"Server is now listening on actual port: \" + server.actualPort());\n } else {\n System.out.println(\"Failed to bind!\");\n }\n});\n\n接收传入连接的通知\n若您想要在连接创建完时收到通知，则需要设置一个 connectHandler：\nNetServer server = vertx.createNetServer();\nserver.connectHandler(socket -> {\n // 在这里处理传入连接\n});\n\n当连接成功时，您可以在回调函数中处理得到的 NetSocket 实例。这是一个代表了实际连接的套接字接口，它允许您读取和写入数据、以及执行各种其他操作，如关闭 Socket。\n从Socket读取数据\n您可以在Socket上调用 handler 方法来设置用于读取数据的处理器。\n每次 Socket 接收到数据时，会以 Buffer 对象为参数调用处理器。\nNetServer server = vertx.createNetServer();\nserver.connectHandler(socket -> {\n socket.handler(buffer -> {\n System.out.println(\"I received some bytes: \" + buffer.length());\n });\n});\n\n向Socket中写入数据\n您可使用 write 方法写入数据到Socket：\nBuffer buffer = Buffer.buffer().appendFloat(12.34f).appendInt(123);\nsocket.write(buffer);\n\n// 以UTF-8的编码方式写入一个字符串\nsocket.write(\"some data\");\n\n// 以指定的编码方式写入一个字符串\nsocket.write(\"some data\", \"UTF-16\");\n\n写入操作是异步的，可能调用 write 方法返回过后一段时间才会发生。\n关闭处理器\n若您想要在 Socket 关闭时收到通知，可以设置一个 closeHandler：\nsocket.closeHandler(v -> {\n System.out.println(\"The socket has been closed\");\n});\n\n处理异常\n您可以设置一个 exceptionHandler 用以在发生任何异常的时候接收异常信息。\nEvent Bus 写处理器\n每个 Socket 会自动在Event Bus中注册一个处理器，当这个处理器中收到任意 Buffer 时，它会将数据写入到 Socket。\n这意味着您可以通过向这个地址发送 Buffer 的方式，从不同的 Verticle 甚至是不同的 Vert.x 实例中向指定的 Socket 发送数据。\n处理器的地址由 writeHandlerID 方法提供。\n本地和远程地址\n您可以通过 localAddress方法获取 NetSocket 的本地地址，通过 remoteAddress 方法获取 NetSocket 的远程地址（即连接的另一端的地址）。\n发送文件或 Classpath 中的资源\n您可以直接通过 sendFile 方法将文件和 classpath 中的资源写入Socket。这种做法是非常高效的，它可以被操作系统内核直接处理。\n请阅读 从 Classpath 访问文件 章节了解类路径的限制或禁用它。\n流式的Socket\nNetSocket 接口继承了 ReadStream 和 WriteStream 接口，因此您可以将它套用（pump）到其他的读写流上。\n有关更多信息，请参阅 流和管道 章节。\n升级到 SSL/TLS 连接\n一个非SSL/TLS连接可以通过upgradeToSsl方法升级到SSL/TLS连接。\n必须为服务器或客户端配置SSL/TLS才能正常工作。请参阅SSL/TLS章节来获取详细信息。\n关闭 TCP 服务端\n您可以调用 close 方法关闭服务端。关闭操作将关闭所有打开的连接并释放所有服务端资源。\n关闭操作也是异步的，可能直到方法调用返回过后一段时间才会实际关闭。若您想在实际关闭完成时收到通知，那么您可以传递一个处理器。\n当关闭操作完成后，绑定的处理器将被调用：\nserver.close(res -> {\n if (res.succeeded()) {\n System.out.println(\"Server is now closed\");\n } else {\n System.out.println(\"close failed\");\n }\n});\n\nVerticle中的自动清理\n若您在 Verticle 内创建了 TCP 服务端和客户端，它们将会在Verticle 撤销时自动被关闭。\n扩展 - 共享 TCP 服务端\n任意一个 TCP 服务端中的处理器总是在相同的 Event Loop 线程上执行。这意味着如果您在多核的服务器上运行，并且只部署了一个实例，那么您的服务器上最多只能使用一个核。\n为了利用更多的服务器核，您将需要部署更多的服务器实例。您可以在代码中以编程方式实例化更多（Server的）实例：\nfor (int i = 0; i {\n socket.handler(buffer -> {\n //仅回传数据\n socket.write(buffer);\n });\n });\n server.listen(1234, \"localhost\");\n}\n\n如果您使用的是 Verticle，您可以通过在命令行上使用 -instances 选项来简单部署更多的服务器实例：\nvertx run com.mycompany.MyVerticle -instances 10\n或者使用编程方式部署您的 Verticle 时：\nDeploymentOptions options = new DeploymentOptions().setInstances(10);\nvertx.deployVerticle(\"com.mycompany.MyVerticle\", options);\n\n一旦您这样做，您将发现echo服务器在功能上与之前相同，但是服务器上的所有核都可以被利用，并且可以处理更多的工作。\n在这一点上，您可能会问自己：如何让多台服务器在同一主机和端口上侦听？尝试部署一个以上的实例时真的不会遇到端口冲突吗？\nVert.x在这里有一点魔法。\n当您在与现有服务器相同的主机和端口上部署另一个服务器实例时，实际上它并不会尝试创建在同一主机/端口上侦听的新服务器实例。\n相反，它内部仅仅维护一个服务器实例。当传入新的连接时，它以轮询的方式将其分发给任意一个连接处理器处理。\n因此，Vert.x TCP 服务端可以水平扩展到多个核，并且每个实例保持单线程环境不变。\n创建 TCP 客户端\n使用所有默认选项创建 TCP 客户端的最简单方法如下：\nNetClient client = vertx.createNetClient();\n\n配置 TCP 客户端\n如果您不想使用默认值，则可以在创建实例时传入 NetClientOptions 给客户端：\nNetClientOptions options = new NetClientOptions().setConnectTimeout(10000);\nNetClient client = vertx.createNetClient(options);\n\n创建连接\n您可以使用 connect 方法创建到服务器的连接。请指定服务器的端口和主机，以及用于处理 NetSocket 的处理器。当连接成功或失败时处理器会被调用。\nNetClientOptions options = new NetClientOptions().setConnectTimeout(10000);\nNetClient client = vertx.createNetClient(options);\nclient.connect(4321, \"localhost\", res -> {\n if (res.succeeded()) {\n System.out.println(\"Connected!\");\n NetSocket socket = res.result();\n } else {\n System.out.println(\"Failed to connect: \" + res.cause().getMessage());\n }\n});\n\n配置连接重试\n可以将客户端配置为在无法连接的情况下自动重试。这是通过 setReconnectInterval 和 setReconnectAttempts 方法配置的。\n\n注意：目前如果连接失效，Vert.x将不尝试重新连接。重新连接尝试和时间间隔仅适用于创建初始连接。\n\nNetClientOptions options = new NetClientOptions().\n setReconnectAttempts(10).\n setReconnectInterval(500);\n\nNetClient client = vertx.createNetClient(options);\n\n默认情况下，多个连接尝试是被禁用的。\n记录网络活动\n网络活动可以被记录下来，用于调试：\nNetServerOptions options = new NetServerOptions().setLogActivity(true);\n\nNetServer server = vertx.createNetServer(options);\n\n对于客户端：\nNetClientOptions options = new NetClientOptions().setLogActivity(true);\n\nNetClient client = vertx.createNetClient(options);\n\nNetty 使用 DEBUG 级别和 io.netty.handler.logging.LoggingHandler 名称来记录网络活动。使用网络活动记录时，需要注意以下几点：\n\n日志的记录是由Netty而不是Vert.x的日志来执行\n这个功能不能用于生产环境\n\n您应该阅读 Netty 日志记录 章节来了解详细信息。\n配置服务端和客户端以使用SSL/TLS\nTCP 客户端和服务端可以通过配置来使用 TLS（传输层安全性协议）。早期版本的TLS被称为SSL。\n无论是否使用SSL/TLS，服务器和客户端的API都是相同的。通过创建客户端/服务器时使用的 NetClientOptions / NetServerOptions 来启用TLS/SSL。\n在服务端启用SSL/TLS\n您需要设置 ssl 配置项来启用 SSL/TLS。默认是禁用的。\n指定服务端的密钥/证书\nSSL/TLS 服务端通常向客户端提供证书，以便验证服务端的身份。\n可以通过以下几种方式为服务端配置证书/密钥：\n第一种方法是指定包含证书和私钥的Java密钥库位置。可以使用 JDK 附带的 keytool 实用程序来管理Java密钥存储。\n还应提供密钥存储的密码：\nNetServerOptions options = new NetServerOptions().setSsl(true).setKeyStoreOptions(\n new JksOptions().\n setPath(\"/path/to/your/server-keystore.jks\").\n setPassword(\"password-of-your-keystore\")\n);\nNetServer server = vertx.createNetServer(options);\n\n或者，您可以自己读取密钥库到一个Buffer，并将它直接提供给 JksOptions：\nBuffer myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking(\"/path/to/your/server-keystore.jks\");\nJksOptions jksOptions = new JksOptions().\n setValue(myKeyStoreAsABuffer).\n setPassword(\"password-of-your-keystore\");\nNetServerOptions options = new NetServerOptions().\n setSsl(true).\n setKeyStoreOptions(jksOptions);\nNetServer server = vertx.createNetServer(options);\n\nPKCS＃12格式的密钥/证书（http://en.wikipedia.org/wiki/PKCS_12，通常为.pfx或.p12扩展名）也可以用与JKS密钥存储相似的方式加载：\nNetServerOptions options = new NetServerOptions().setSsl(true).setPfxKeyCertOptions(\n new PfxOptions().\n setPath(\"/path/to/your/server-keystore.pfx\").\n setPassword(\"password-of-your-keystore\")\n);\nNetServer server = vertx.createNetServer(options);\n\n也支持通过 Buffer 来配置：\nBuffer myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking(\"/path/to/your/server-keystore.pfx\");\nPfxOptions pfxOptions = new PfxOptions().\n setValue(myKeyStoreAsABuffer).\n setPassword(\"password-of-your-keystore\");\nNetServerOptions options = new NetServerOptions().\n setSsl(true).\n setPfxKeyCertOptions(pfxOptions);\nNetServer server = vertx.createNetServer(options);\n\n另外一种分别提供服务器私钥和证书的方法是使用.pem文件。\nNetServerOptions options = new NetServerOptions().setSsl(true).setPemKeyCertOptions(\n new PemKeyCertOptions().\n setKeyPath(\"/path/to/your/server-key.pem\").\n setCertPath(\"/path/to/your/server-cert.pem\")\n);\nNetServer server = vertx.createNetServer(options);\n\n也支持通过 Buffer 来配置：\nBuffer myKeyAsABuffer = vertx.fileSystem().readFileBlocking(\"/path/to/your/server-key.pem\");\nBuffer myCertAsABuffer = vertx.fileSystem().readFileBlocking(\"/path/to/your/server-cert.pem\");\nPemKeyCertOptions pemOptions = new PemKeyCertOptions().\n setKeyValue(myKeyAsABuffer).\n setCertValue(myCertAsABuffer);\nNetServerOptions options = new NetServerOptions().\n setSsl(true).\n setPemKeyCertOptions(pemOptions);\nNetServer server = vertx.createNetServer(options);\n\n请记住pem的配置和私钥是不加密的。\n指定服务器信任\nSSL/TLS 服务端可以使用证书颁发机构来验证客户端的身份。\n证书颁发机构可通过多种方式为服务端配置。\n可使用JDK随附的keytool实用程序来管理Java 受信存储。\n还应提供受信存储的密码：\nNetServerOptions options = new NetServerOptions().\n setSsl(true).\n setClientAuth(ClientAuth.REQUIRED).\n setTrustStoreOptions(\n new JksOptions().\n setPath(\"/path/to/your/truststore.jks\").\n setPassword(\"password-of-your-truststore\")\n );\nNetServer server = vertx.createNetServer(options);\n\n或者您可以自己读取受信存储到Buffer，并将它直接提供：\nBuffer myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking(\"/path/to/your/truststore.jks\");\nNetServerOptions options = new NetServerOptions().\n setSsl(true).\n setClientAuth(ClientAuth.REQUIRED).\n setTrustStoreOptions(\n new JksOptions().\n setValue(myTrustStoreAsABuffer).\n setPassword(\"password-of-your-truststore\")\n );\nNetServer server = vertx.createNetServer(options);\n\nPKCS＃12格式的密钥/证书（http://en.wikipedia.org/wiki/PKCS_12，通常为.pfx或.p12扩展名）也可以用与JKS密钥存储相似的方式加载：\nNetServerOptions options = new NetServerOptions().\n setSsl(true).\n setClientAuth(ClientAuth.REQUIRED).\n setPfxTrustOptions(\n new PfxOptions().\n setPath(\"/path/to/your/truststore.pfx\").\n setPassword(\"password-of-your-truststore\")\n );\nNetServer server = vertx.createNetServer(options);\n\n也支持通过 Buffer 来配置：\nBuffer myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking(\"/path/to/your/truststore.pfx\");\nNetServerOptions options = new NetServerOptions().\n setSsl(true).\n setClientAuth(ClientAuth.REQUIRED).\n setPfxTrustOptions(\n new PfxOptions().\n setValue(myTrustStoreAsABuffer).\n setPassword(\"password-of-your-truststore\")\n );\nNetServer server = vertx.createNetServer(options);\n\n另一种提供服务器证书颁发机构的方法是使用一个 .pem 文件列表。\nNetServerOptions options = new NetServerOptions().\n setSsl(true).\n setClientAuth(ClientAuth.REQUIRED).\n setPemTrustOptions(\n new PemTrustOptions().\n addCertPath(\"/path/to/your/server-ca.pem\")\n );\nNetServer server = vertx.createNetServer(options);\n\n也支持通过 Buffer 来配置：\nBuffer myCaAsABuffer = vertx.fileSystem().readFileBlocking(\"/path/to/your/server-ca.pfx\");\nNetServerOptions options = new NetServerOptions().\n setSsl(true).\n setClientAuth(ClientAuth.REQUIRED).\n setPemTrustOptions(\n new PemTrustOptions().\n addCertValue(myCaAsABuffer)\n );\nNetServer server = vertx.createNetServer(options);\n\n客户端启用SSL/TLS\n客户端也可以轻松地配置为SSL。使用SSL和使用标准套接字具有完全相同的API。\n若要启用 NetClient 上的SSL，可调用函数 setSSL(true)。\n客户端受信配置\n若客户端将 trustAll 设置为 true，则客户端将信任所有服务端证书。连接仍然会被加密，但这种模式很容易受到中间人攻击。即您无法确定您正连接到谁，请谨慎使用。默认值为false。\nNetClientOptions options = new NetClientOptions().\n setSsl(true).\n setTrustAll(true);\nNetClient client = vertx.createNetClient(options);\n\n若客户端没有设置trustAll，则必须配置客户端受信存储，并且受信客户端应该包含服务器的证书。\n默认情况下，客户端禁用主机验证。要启用主机验证，请在客户端上设置使用的算法（目前仅支持HTTPS和LDAPS）：\nNetClientOptions options = new NetClientOptions().\n setSsl(true).\n setHostnameVerificationAlgorithm(\"HTTPS\");\nNetClient client = vertx.createNetClient(options);\n\n和服务器配置相同，也可通过以下几种方式配置受信客户端：\n第一种方法是指定包含证书颁发机构的Java受信库的位置。\n它只是一个标准的Java密钥存储，与服务器端的密钥存储相同。通过在jsk options上使用path设置客户端受信存储位置。如果服务器在连接期间提供不在客户端受信存储中的证书，则尝试连接将不会成功。\nNetClientOptions options = new NetClientOptions().\n setSsl(true).\n setTrustStoreOptions(\n new JksOptions().\n setPath(\"/path/to/your/truststore.jks\").\n setPassword(\"password-of-your-truststore\")\n );\nNetClient client = vertx.createNetClient(options);\n\n它也支持Buffer的配置：\nBuffer myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking(\"/path/to/your/truststore.jks\");\nNetClientOptions options = new NetClientOptions().\n setSsl(true).\n setTrustStoreOptions(\n new JksOptions().\n setValue(myTrustStoreAsABuffer).\n setPassword(\"password-of-your-truststore\")\n );\nNetClient client = vertx.createNetClient(options);\n\nPKCS＃12格式的密钥/证书（http://en.wikipedia.org/wiki/PKCS_12，通常为.pfx或.p12扩展名）也可以用与JKS密钥存储相似的方式加载：\nNetClientOptions options = new NetClientOptions().\n setSsl(true).\n setPfxTrustOptions(\n new PfxOptions().\n setPath(\"/path/to/your/truststore.pfx\").\n setPassword(\"password-of-your-truststore\")\n );\nNetClient client = vertx.createNetClient(options);\n\n也支持通过 Buffer 来配置：\nBuffer myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking(\"/path/to/your/truststore.pfx\");\nNetClientOptions options = new NetClientOptions().\n setSsl(true).\n setPfxTrustOptions(\n new PfxOptions().\n setValue(myTrustStoreAsABuffer).\n setPassword(\"password-of-your-truststore\")\n );\nNetClient client = vertx.createNetClient(options);\n\n另一种提供服务器证书颁发机构的方法是使用一个.pem文件列表。\nNetClientOptions options = new NetClientOptions().\n setSsl(true).\n setPemTrustOptions(\n new PemTrustOptions().\n addCertPath(\"/path/to/your/ca-cert.pem\")\n );\nNetClient client = vertx.createNetClient(options);\n\n也支持通过 Buffer 来配置：\nBuffer myTrustStoreAsABuffer = vertx.fileSystem().readFileBlocking(\"/path/to/your/ca-cert.pem\");\nNetClientOptions options = new NetClientOptions().\n setSsl(true).\n setPemTrustOptions(\n new PemTrustOptions().\n addCertValue(myTrustStoreAsABuffer)\n );\nNetClient client = vertx.createNetClient(options);\n\n指定客户端的密钥/证书\n如果服务器需要客户端认证，那么当连接时，客户端必须向服务器提供自己的证书。可通过以下几种方式配置客户端：\n第一种方法是指定包含密钥和证书的Java 密钥库的位置，它只是一个常规的Java 密钥存储。使用jks options上的功能路径设置客户端密钥库位置。\nNetClientOptions options = new NetClientOptions().setSsl(true).setKeyStoreOptions(\n new JksOptions().\n setPath(\"/path/to/your/client-keystore.jks\").\n setPassword(\"password-of-your-keystore\")\n);\nNetClient client = vertx.createNetClient(options);\n\n也支持通过 Buffer 来配置：\nBuffer myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking(\"/path/to/your/client-keystore.jks\");\nJksOptions jksOptions = new JksOptions().\n setValue(myKeyStoreAsABuffer).\n setPassword(\"password-of-your-keystore\");\nNetClientOptions options = new NetClientOptions().\n setSsl(true).\n setKeyStoreOptions(jksOptions);\nNetClient client = vertx.createNetClient(options);\n\nPKCS＃12格式的密钥/证书（http://en.wikipedia.org/wiki/PKCS_12，通常为.pfx或.p12扩展名）也可以用与JKS密钥存储相似的方式加载：\nNetClientOptions options = new NetClientOptions().setSsl(true).setPfxKeyCertOptions(\n new PfxOptions().\n setPath(\"/path/to/your/client-keystore.pfx\").\n setPassword(\"password-of-your-keystore\")\n);\nNetClient client = vertx.createNetClient(options);\n\n也支持通过 Buffer 来配置：\nBuffer myKeyStoreAsABuffer = vertx.fileSystem().readFileBlocking(\"/path/to/your/client-keystore.pfx\");\nPfxOptions pfxOptions = new PfxOptions().\n setValue(myKeyStoreAsABuffer).\n setPassword(\"password-of-your-keystore\");\nNetClientOptions options = new NetClientOptions().\n setSsl(true).\n setPfxKeyCertOptions(pfxOptions);\nNetClient client = vertx.createNetClient(options);\n\n另一种单独提供服务器私钥和证书的方法是使用 .pem 文件。\nNetClientOptions options = new NetClientOptions().setSsl(true).setPemKeyCertOptions(\n new PemKeyCertOptions().\n setKeyPath(\"/path/to/your/client-key.pem\").\n setCertPath(\"/path/to/your/client-cert.pem\")\n);\nNetClient client = vertx.createNetClient(options);\n\n也支持通过 Buffer 来配置：\nBuffer myKeyAsABuffer = vertx.fileSystem().readFileBlocking(\"/path/to/your/client-key.pem\");\nBuffer myCertAsABuffer = vertx.fileSystem().readFileBlocking(\"/path/to/your/client-cert.pem\");\nPemKeyCertOptions pemOptions = new PemKeyCertOptions().\n setKeyValue(myKeyAsABuffer).\n setCertValue(myCertAsABuffer);\nNetClientOptions options = new NetClientOptions().\n setSsl(true).\n setPemKeyCertOptions(pemOptions);\nNetClient client = vertx.createNetClient(options);\n\n请记住 pem 的配置和私钥是不加密的。\n用于测试和开发目的的自签名证书\n\n提醒：不要在生产设置中使用，这里生成的密钥非常不安全。\n\n在运行单元/集成测试或是运行开发版的应用程序时都经常需要自签名证书。\nSelfSignedCertificate 可用于提供自签名PEM证书，并可以提供 KeyCertOptions和 TrustOptions 配置：\nSelfSignedCertificate certificate = SelfSignedCertificate.create();\n\nNetServerOptions serverOptions = new NetServerOptions()\n .setSsl(true)\n .setKeyCertOptions(certificate.keyCertOptions())\n .setTrustOptions(certificate.trustOptions());\n\nNetServer server = vertx.createNetServer(serverOptions)\n .connectHandler(socket -> socket.write(\"Hello!\").end())\n .listen(1234, \"localhost\");\n\nNetClientOptions clientOptions = new NetClientOptions()\n .setSsl(true)\n .setKeyCertOptions(certificate.keyCertOptions())\n .setTrustOptions(certificate.trustOptions());\n\nNetClient client = vertx.createNetClient(clientOptions);\nclient.connect(1234, \"localhost\", ar -> {\n if (ar.succeeded()) {\n ar.result().handler(buffer -> System.out.println(buffer));\n } else {\n System.err.println(\"Woops: \" + ar.cause().getMessage());\n }\n});\n\n客户端也可配置为信任所有证书：\nNetClientOptions clientOptions = new NetClientOptions()\n .setSsl(true)\n .setTrustAll(true);\n\n自签名证书也适用于其他基于TCP的协议，如HTTPS：\nSelfSignedCertificate certificate = SelfSignedCertificate.create();\n\nvertx.createHttpServer(new HttpServerOptions()\n .setSsl(true)\n .setKeyCertOptions(certificate.keyCertOptions())\n .setTrustOptions(certificate.trustOptions()))\n .requestHandler(req -> req.response().end(\"Hello!\"))\n .listen(8080);\n\n待撤销证书颁发机构\n可以通过配置证书吊销列表（CRL）来吊销不再被信任的证书机构。crlPath配置了使用的CRL：\nNetClientOptions options = new NetClientOptions().\n setSsl(true).\n setTrustStoreOptions(trustOptions).\n addCrlPath(\"/path/to/your/crl.pem\");\nNetClient client = vertx.createNetClient(options);\n\n也支持通过Buffer来配置：\nBuffer myCrlAsABuffer = vertx.fileSystem().readFileBlocking(\"/path/to/your/crl.pem\");\nNetClientOptions options = new NetClientOptions().\n setSsl(true).\n setTrustStoreOptions(trustOptions).\n addCrlValue(myCrlAsABuffer);\nNetClient client = vertx.createNetClient(options);\n\n配置密码套件\n默认情况下，TLS配置将使用运行Vert.x的JVM 密码套件，该密码套件可以配置一套启用的密码：\nNetServerOptions options = new NetServerOptions().\n setSsl(true).\n setKeyStoreOptions(keyStoreOptions).\n addEnabledCipherSuite(\"ECDHE-RSA-AES128-GCM-SHA256\").\n addEnabledCipherSuite(\"ECDHE-ECDSA-AES128-GCM-SHA256\").\n addEnabledCipherSuite(\"ECDHE-RSA-AES256-GCM-SHA384\").\n addEnabledCipherSuite(\"CDHE-ECDSA-AES256-GCM-SHA384\");\nNetServer server = vertx.createNetServer(options);\n\n密码套件可在NetServerOptions或NetClientOptions配置项中指定。\n配置TLS协议版本\n默认情况下，TLS配置将使用以下协议版本：SSLv2Hello、TLSv1、TLSv1.1 和 TLSv1.2。 协议版本可以通过显式添加启用协议进行配置：\nNetServerOptions options = new NetServerOptions().\n setSsl(true).\n setKeyStoreOptions(keyStoreOptions).\n addEnabledSecureTransportProtocol(\"TLSv1.1\").\n addEnabledSecureTransportProtocol(\"TLSv1.2\");\nNetServer server = vertx.createNetServer(options);\n\n协议版本可在NetServerOptions或NetClientOptions配置项中指定。\nSSL引擎\n引擎实现可以配置为使用 OpenSSL 而不是JDK实现（来支持SSL）。 OpenSSL提供比JDK引擎更好的性能和CPU使用率、以及JDK版本独立性。\n引擎选项可使用：\n\n当getSslEngineOptions被设置时，使用该选项\n否则使用JdkSSLEngineOptions\n\nNetServerOptions options = new NetServerOptions().\n setSsl(true).\n setKeyStoreOptions(keyStoreOptions);\n\n// Use JDK SSL engine explicitly\n// 显式使用JDK SSL引擎\noptions = new NetServerOptions().\n setSsl(true).\n setKeyStoreOptions(keyStoreOptions).\n setJdkSslEngineOptions(new JdkSSLEngineOptions());\n\n// Use OpenSSL engine\n// 使用OpenSSL引擎\noptions = new NetServerOptions().\n setSsl(true).\n setKeyStoreOptions(keyStoreOptions).\n setOpenSslEngineOptions(new OpenSSLEngineOptions());\n\n应用层协议协商\nALPN(Application-Layer Protocol Negotiation)是应用层协议协商的TLS扩展，它被HTTP/2使用：在TLS握手期时，客户端给出其接受的应用协议列表，之后服务器使用它所支持的协议响应。\n标准的Java 8不支持ALPN，所以ALPN应该通过其他方式启用：\n\nOpenSSL支持\nJetty-ALPN支持\n\n引擎选项可使用:\n\n当 getSslEngineOptions 被设置时，使用该选项\nJDK中ALPN可用时使用 JdkSSLEngineOptions\nOpenSSL中ALPN可用时使用 OpenSSLEngineOptions\n否则失败\n\nOpenSSL ALPN支持\nOpenSSL提供了原生的ALPN支持。\nOpenSSL需要配置 setOpenSslEngineOptions 并在类路径上使用 netty-tcnative 的jar库。依赖于tcnative的实现它需要OpenSSL安装在您的操作系统中。\nJetty-ALPN支持\nJetty-ALPN是一个小型的jar，它覆盖了几种Java 8发行版用以支持ALPN。\nJVM必须将 alpn-boot-${version}.jar 放在它的 boot classpath 中启动：\n-Xbootclasspath/p:/path/to/alpn-boot${version}.jar\n其中 ${version} 取决于JVM的版本，如 OpenJDK 1.8.0u74 中的 8.1.7.v20160121。这个完整列表可以在 Jetty-ALPN 页面上找到。\n这种方法主要缺点是ALPN的实现版本依赖于JVM的版本。为了解决这个问题，可以使用 Jetty ALPN agent。agent是一个JVM代理，它会为运行它的JVM选择正确的ALPN版本：\n-javaagent:/path/to/alpn/agent\n客户端连接使用代理\nNetClient 支持HTTP/1.x CONNECT、SOCKS4a 或 SOCKS5 代理。\n代理可以在 NetClientOptions 内设置 ProxyOptions 来配置代理类型、主机名、端口、可选的用户名和密码。\n以下是一个例子：\nNetClientOptions options = new NetClientOptions()\n .setProxyOptions(new ProxyOptions().setType(ProxyType.SOCKS5)\n .setHost(\"localhost\").setPort(1080)\n .setUsername(\"username\").setPassword(\"secret\"));\nNetClient client = vertx.createNetClient(options);\n\nDNS 解析总是在代理服务器上完成解析，为了实现 SOCKS4 客户端的功能，需要先在本地解析 DNS 地址。\n编写 HTTP 服务端和客户端\nVert.x 允许您轻松编写非阻塞的 HTTP 客户端和服务端。\nVert.x 支持 HTTP/1.0、HTTP/1.1 和 HTTP/2 协议。\n用于 HTTP 的基本 API 对 HTTP/1.x 和 HTTP/2 是相同的，特定的API功能也可用于处理 HTTP/2 协议。\n创建 HTTP 服务端\n使用所有默认选项创建 HTTP 服务端的最简单方法如下：\nHttpServer server = vertx.createHttpServer();\n\n配置 HTTP 服务端\n若您不想用默认值，可以在创建服务器时传递一个 HttpServerOptions 实例给它：\nHttpServerOptions options = new HttpServerOptions().setMaxWebsocketFrameSize(1000000);\n\nHttpServer server = vertx.createHttpServer(options);\n\n配置 HTTP/2 服务端\nVert.x支持 TLS h2和TCP h2c之上的 HTTP/2 协议。\n\nh2 表示使用了TLS的应用层协议协商(ALPN)协议来协商的 HTTP/2 协议\nh2c 表示在TCP层上使用明文形式的 HTTP/2 协议，这样的连接是使用 HTTP/1.1升级 请求或者直接建立\n\n要处理 h2 请求，你必须调用 setUseAlpn 方法来启用TLS：\nHttpServerOptions options = new HttpServerOptions()\n .setUseAlpn(true)\n .setSsl(true)\n .setKeyStoreOptions(new JksOptions().setPath(\"/path/to/my/keystore\"));\n\nHttpServer server = vertx.createHttpServer(options);\n\nALPN是一个TLS的扩展，它在客户端和服务器开始交换数据之前协商协议。\n不支持ALPN的客户端仍然可以执行经典的SSL握手。\n通常情况，ALPN会对 h2 协议达成一致，尽管服务器或客户端决定了仍然使用 HTTP/1.1 协议。\n要处理 h2c 请求，TLS必须被禁用，服务器将升级到 HTTP/2 以满足任何希望升级到 HTTP/2 的 HTTP/1.1 请求。它还将接受以 PRI*HTTP/2.0\\r\\nSM\\r\\n 开始的h2c直接连接。\n\n警告：大多数浏览器不支持 h2c，所以在建站时，您应该使用 h2 而不是 h2c。\n\n当服务器接受 HTTP/2 连接时，它会向客户端发送其初始设置。定义客户端如何使用连接，服务器的默认初始设置为：\n\ngetMaxConcurrentStreams：按照 HTTP/2 RFC建议推荐值为100\n其他默认的 HTTP/2 的设置\n\n\n请注意：Worker Verticle 和 HTTP/2 不兼容。\n\n记录服务端网络活动\n为了进行调试，可记录网络活动。\nHttpServerOptions options = new HttpServerOptions().setLogActivity(true);\n\nHttpServer server = vertx.createHttpServer(options);\n\n详细说明请参阅 记录网络活动 章节。\n开启服务端监听\n要告诉服务器监听传入的请求，您可以使用其中一个 listen 方法。\n在配置项中告诉服务器监听指定的主机和端口：\nHttpServer server = vertx.createHttpServer();\nserver.listen();\n\n或在调用 listen 方法时指定主机和端口号，这样就忽略了配置项（中的主机和端口）：\nHttpServer server = vertx.createHttpServer();\nserver.listen(8080, \"myhost.com\");\n\n默认主机名是0.0.0.0，它表示：监听所有可用地址；默认端口号是80。\n实际的绑定也是异步的，因此服务器也许并没有在调用 listen 方法返回时监听，而是在一段时间过后才监听。\n若您希望在服务器实际监听时收到通知，您可以向 listen 提供一个处理器。例如：\nHttpServer server = vertx.createHttpServer();\nserver.listen(8080, \"myhost.com\", res -> {\n if (res.succeeded()) {\n System.out.println(\"Server is now listening!\");\n } else {\n System.out.println(\"Failed to bind!\");\n }\n});\n\n收到传入请求的通知\n若您需要在收到请求时收到通知，则需要设置一个 requestHandler：\nHttpServer server = vertx.createHttpServer();\nserver.requestHandler(request -> {\n // 在这里处理请求\n});\n\n处理请求\n当请求到达时，Vert.x 会像对应的处理函数传入一个 HttpServerRequest 实例并调用请求处理函数，此对象表示服务端 HTTP 请求。当请求的头信息被完全读取时会调用该请求处理器。\n如果请求包含请求体，那么该请求体将在请求处理器被调用后的某个时间到达服务器。\n服务请求对象允许您检索 uri，path，params 和 headers 等其他信息。\n每一个服务请求对象和一个服务响应对象绑定，您可以用 response 方法获取一个 HttpServerResponse 对象的引用。\n这是服务器处理请求并回复 “hello world” 的简单示例。\nvertx.createHttpServer().requestHandler(request -> {\n request.response().end(\"Hello world\");\n}).listen(8080);\n\n请求版本\n在请求中指定的 HTTP 版本可通过 version 方法获取。\n请求方法\n使用 method 方法读取请求中的 HTTP Method（即GET、POST、PUT、DELETE、HEAD、OPTIONS等）。\n请求URI\n使用 uri 方法读取请求中的URI路径。\n请注意，这是在HTTP 请求中传递的实际URI，它总是一个相对的URI。\n这个URI是在 Section 5.1.2 of the HTTP specification - Request-URI 中定义的。\n请求路径\n使用 path 方法读取URI中的路径部分。\n例如，请求的URI为：\na/b/c/page.html?param1=abc¶m2=xyz\n路径部分应该是：\n/a/b/c/page.html\n请求查询\n使用query读取URI中的查询部分。\n例如，请求的URI为：\na/b/c/page.html?param1=abc¶m2=xyz\n查询部分应该是：\nparam1=abc¶m2=xyz\n请求头部\n使用 headers 方法获取HTTP 请求中的请求头部信息。\n这个方法返回一个 MultiMap 实例。它像一个普通的Map或Hash，并且它还允许同一个键支持多个值 —— 因为HTTP允许同一个键支持多个请求头的值。\n它的键值不区分大小写，这意味着您可以执行以下操作：\nMultiMap headers = request.headers();\n\n// Get the User-Agent:\n// 读取User-Agent\nSystem.out.println(\"User agent is \" + headers.get(\"user-agent\"));\n\n// You can also do this and get the same result:\n// 这样做可以得到和上边相同的结果\nSystem.out.println(\"User agent is \" + headers.get(\"User-Agent\"));\n\n请求主机\n使用 host 方法返回 HTTP 请求中的主机名。\n对于 HTTP/1.x 请求返回请求头中的 host 值，对于 HTTP/1 请求则返回伪头中的:authority的值。\n请求参数\n您可以使用 params 方法返回HTTP请求中的参数信息。像 headers 方法一样它也会返回一个 MultiMap 实例，因为可以有多个具有相同名称的参数。\n请求参数在请求URI的 path 部分之后，例如URI是：\n/page.html?param1=abc¶m2=xyz\n那么参数将包含以下内容：\nparam1: 'abc'\nparam2: 'xyz'\n请注意，这些请求参数是从请求的 URI 中解析读取的，若您已经将表单属性存放在请求体中发送出去，并且该请求为 multi-part/form-data 类型请求，那么它们将不会显示在此处的参数中。\n远程地址\n可以使用 remoteAddress 方法读取请求发送者的地址。\n绝对URI\nHTTP 请求中传递的URI通常是相对的，若您想要读取请求中和相对URI对应的绝对URI，可调用 absoluteURI 方法。\n结束处理器\n当整个请求（包括任何正文）已经被完全读取时，请求中的 endHandler 方法会被调用。\n请求体中读取数据\nHTTP请求通常包含我们需要读取的主体。如前所述，当请求头部达到时，请求处理器会被调用，因此请求对象在此时没有请求体。\n这是因为请求体可能非常大（如文件上传），并且我们不会在内容发送给您之前将其全部缓冲存储在内存中，这可能会导致服务器耗尽可用内存。\n要接收请求体，您可在请求中调用 handler 方法设置一个处理器，每次请求体的一小块数据收到时，该处理器都会被调用。以下是一个例子：\nrequest.handler(buffer -> {\n System.out.println(\"I have received a chunk of the body of length \" + buffer.length());\n});\n\n传递给处理器的对象是一个 Buffer，当数据从网络到达时，处理器可以多次被调用，这取决于请求体的大小。\n在某些情况下（例：若请求体很小），您将需要将这个请求体聚合到内存中，以便您可以按照下边的方式进行聚合：\nBuffer totalBuffer = Buffer.buffer();\n\nrequest.handler(buffer -> {\n System.out.println(\"I have received a chunk of the body of length \" + buffer.length());\n totalBuffer.appendBuffer(buffer);\n});\n\nrequest.endHandler(v -> {\n System.out.println(\"Full body received, length = \" + totalBuffer.length());\n});\n\n这是一个常见的情况，Vert.x为您提供了一个 bodyHandler 方法来执行此操作。当所有请求体被收到时，bodyHandler 绑定的处理器会被调用一次：\nrequest.bodyHandler(totalBuffer -> {\n System.out.println(\"Full body received, length = \" + totalBuffer.length());\n});\n\nPumping 请求\n请求对象实现了 ReadStream 接口，因此您可以将请求体读取到任何 WriteStream 实例中。\n详细请参阅 流和管道 章节。\n处理 HTML 表单\n您可使用 application/x-www-form-urlencoded 或 multipart/form-data 这两种 content-type 来提交 HTML 表单。\n对于使用 URL 编码过的表单，表单属性会被编码在URL中，如同普通查询参数一样。\n对于 multipart 类型的表单，它会被编码在请求体中，而且在整个请求体被完全读取之前它是不可用的。Multipart 表单还可以包含文件上传。\n若您想要读取 multipart 表单的属性，您应该告诉 Vert.x 您会在读取任何正文 之前 调用 setExpectMultipart(true) 方法，然后在整个请求体都被读取后，您可以使用 formAttributes 方法来读取实际的表单属性。\nserver.requestHandler(request -> {\n request.setExpectMultipart(true);\n request.endHandler(v -> {\n // 请求体被完全读取，所以直接读取表单属性\n MultiMap formAttributes = request.formAttributes();\n });\n});\n\n处理文件上传\nVert.x 可以处理以 multipart 编码形式上传的的文件。\n要接收文件，您可以告诉 Vert.x 使用 multipart 表单，并对请求设置 uploadHandler。\n当服务器每次接收到上传请求时，该处理器将被调用一次。\n传递给处理器的对象是一个 HttpServerFileUpload 实例。\nserver.requestHandler(request -> {\n request.setExpectMultipart(true);\n request.uploadHandler(upload -> {\n System.out.println(\"Got a file upload \" + upload.name());\n });\n});\n\n上传的文件可能很大，我们不会在单个缓冲区中包含整个上传的数据，因为这样会导致内存耗尽。相反，上传数据是以块的形式被接收的：\nrequest.uploadHandler(upload -> {\n upload.handler(chunk -> {\n System.out.println(\"Received a chunk of the upload of length \" + chunk.length());\n });\n});\n\n上传对象实现了 ReadStream 接口，因此您可以将请求体读取到任何 WriteStream 实例中。详细说明请参阅 流和管道（泵） 章节。\n若您只是想将文件上传到服务器的某个磁盘，可以使用 streamToFileSystem 方法：\nrequest.uploadHandler(upload -> {\n upload.streamToFileSystem(\"myuploads_directory/\" + upload.filename());\n});\n\n\n警告：确保您检查了生产系统的文件名，以避免恶意客户将文件上传到文件系统中的任意位置。有关详细信息，参阅 安全说明。\n\n处理压缩体\nVert.x 可以处理在客户端通过 deflate 或 gzip 算法压缩过的请求体信息。\n若要启用解压缩功能则您要在创建服务器时调用 setDecompressionSupported 方法设置配置项。默认情况下解压缩是被禁用的。\n接收自定义 HTTP/2 帧\nHTTP/2 是用于 HTTP 请求/响应模型的包含各种帧的一种帧协议，该协议允许发送和接收其他类型的帧。\n若要接收自定义帧(frame)，您可以在请求中使用 customFrameHandler，每次当自定义的帧数据到达时，这个处理器会被调用。这而是一个例子：\nrequest.customFrameHandler(frame -> {\n System.out.println(\"Received a frame type=\" + frame.type() +\n \" payload\" + frame.payload().toString());\n});\n\nHTTP/2 帧不受流量控制限制 —— 当接收到自定义帧时，不论请求是否暂停，自定义帧处理器都将立即被调用。\n非标准的 HTTP 方法\nOTHER HTTP 方法可用于非标准方法，在这种情况下，rawMethod 方法返回客户端发送的实际 HTTP 方法。\n发回响应\n服务器响应对象是一个 HttpServerResponse 实例，它可以从 request 对应的 response 方法中读取。\n您可以使用响应对象回写一个响应到 HTTP客户端。\n设置状态码和消息\n默认的 HTTP 状态响应码为 200，表示 OK。\n可使用 setStatusCode 方法设置不同状态代码。\n您还可用 setStatusMessage 方法指定自定义状态消息。\n若您不指定状态信息，将会使用默认的状态码响应。\n\n注意：对于 HTTP/2 中的状态不会在响应中描述 —— 因为协议不会将消息发送回客户端。\n\n向 HTTP 响应写入数据\n想要将数据写入 HTTP Response，您可使用任意一个 write 方法。\n它们可以在响应结束之前被多次调用，它们可以通过以下几种方式调用：\n对用单个缓冲区：\nHttpServerResponse response = request.response();\nresponse.write(buffer);\n\n写入字符串，这种请求字符串将使用 UTF-8 进行编码，并将结果写入到报文中。\nHttpServerResponse response = request.response();\nresponse.write(\"hello world!\");\n\n写入带编码方式的字符串，这种情况字符串将使用指定的编码方式编码，并将结果写入到报文中。\nHttpServerResponse response = request.response();\nresponse.write(\"hello world!\", \"UTF-16\");\n\n响应写入是异步的，并且在写操作进入队列之后会立即返回。\n若您只需要将单个字符串或 Buffer 写入到HTTP 响应，则可使用 end 方法将其直接写入响应中并发回到客户端。\n第一次写入操作会触发响应头的写入，因此，若您不使用HTTP 分块，那么必须在写入响应之前设置 Content-Length 头，否则会太迟。若您使用 HTTP 分块则不需要担心这点。\n完成 HTTP 响应\n一旦您完成了 HTTP 响应，可调用 end 将其发回客户端。\n这可以通过几种方式完成：\n没有参数，直接结束响应，发回客户端：\nHttpServerResponse response = request.response();\nresponse.write(\"hello world!\");\nresponse.end();\n\n您也可以和调用write方法一样传 String 或 Buffer 给 end 方法。这种情况，它和先调用带 String 或 Buffer 参数的 write 方法，之后调用无参 end 方法一样。例如：\nHttpServerResponse response = request.response();\nresponse.end(\"hello world!\");\n\n关闭底层连接\n您可以调用 close 方法关闭底层的TCP 连接。\n当响应结束时，Vert.x 将自动关闭非 keep-alive 的连接。\n默认情况下，Vert.x 不会自动关闭 keep-alive 的连接，若您想要在一段空闲时间之后让 Vert.x 自动关闭 keep-alive 的连接，则使用setIdleTimeout 方法进行配置。\nHTTP/2 连接在关闭响应之前会发送 GOAWAY 帧。\n设置响应头\nHTTP 响应头可直接添加到 HTTP 响应中，通常直接操作 headers：\nHttpServerResponse response = request.response();\nMultiMap headers = response.headers();\nheaders.set(\"content-type\", \"text/html\");\nheaders.set(\"other-header\", \"wibble\");\n\n或您可使用 putHeader 方法：\nHttpServerResponse response = request.response();\nresponse.putHeader(\"content-type\", \"text/html\").putHeader(\"other-header\", \"wibble\");\n\n响应头必须在写入响应正文消息之前进行设置。\n分块 HTTP 响应和附加尾部\nVert.x 支持 分块传输编码(HTTP Chunked Transfer Encoding)。\n这允许HTTP 响应体以块的形式写入，通常在响应体预先不知道尺寸、需要将很大响应正文以流式传输到客户端时使用。\n您可以通过如下方式开启分块模式：\nHttpServerResponse response = request.response();\nresponse.setChunked(true);\n\n默认是不分块的，当处于分块模式，每次调用任意一个 write 方法将导致新的 HTTP 块被写出。\n在分块模式下，您还可以将响应的HTTP 响应附加尾部(trailers)写入响应，这种方式实际上是在写入响应的最后一块。\n\n注意：分块响应在 HTTP/2 流中无效。\n\n若要向响应添加尾部，则直接添加到 trailers 里。\nHttpServerResponse response = request.response();\nresponse.setChunked(true);\nMultiMap trailers = response.trailers();\ntrailers.set(\"X-wibble\", \"woobble\").set(\"X-quux\", \"flooble\");\n\n或者调用 putTrailer 方法：\nHttpServerResponse response = request.response();\nresponse.setChunked(true);\nresponse.putTrailer(\"X-wibble\", \"woobble\").putTrailer(\"X-quux\", \"flooble\");\n\n直接从磁盘或 Classpath 读文件\n若您正在编写一个Web 服务端，一种从磁盘中读取并提供文件的方法是将文件作为 AsyncFile 对象打开并其传送到HTTP 响应中。\n或您可以使用 readFile 方法一次性加载它，并直接将其写入响应。\n或者，Vert.x 提供了一种方法，允许您在一个操作中将文件从磁盘或文件系统中读取并提供给HTTP 响应。若底层操作系统支持，这会导致操作系统不通过用户空间复制而直接将文件内容中字节数据从文件传输到Socket。这是使用 sendFile 方法完成的，对于大文件处理通常更有效，而这个方法对于小文件可能很慢。\n这儿是一个非常简单的 Web 服务器，它使用 sendFile 方法从文件系统中读取并提供文件：\nvertx.createHttpServer().requestHandler(request -> {\n String file = \"\";\n if (request.path().equals(\"/\")) {\n file = \"index.html\";\n } else if (!request.path().contains(\"..\")) {\n file = request.path();\n }\n request.response().sendFile(\"web/\" + file);\n}).listen(8080);\n\n发送文件是异步的，可能在调用返回一段时间后才能完成。如果要在文件写入时收到通知，可以在 sendFile 方法中设置一个处理器。\n请阅读 从 Classpath 访问文件 章节了解类路径的限制或禁用它。\n\n注意：若在 HTTPS 协议中使用 sendFile 方法，它将会通过用户空间进行复制，因为若内核将数据直接从磁盘复制到 Socket，则不会给我们任何加密的机会。\n警告：若您要直接使用 Vert.x 编写 Web 服务器，请注意，您想提供文件和类路径之外访问的位置 —— 用户是无法直接利用路径访问的。更安全的做法是使用Vert.x Web替代。\n\n当需要提供文件的一部分，从给定的字节开始，您可以像下边这样做：\nvertx.createHttpServer().requestHandler(request -> {\n long offset = 0;\n try {\n offset = Long.parseLong(request.getParam(\"start\"));\n } catch (NumberFormatException e) {\n // 异常处理\n }\n\n long end = Long.MAX_VALUE;\n try {\n end = Long.parseLong(request.getParam(\"end\"));\n } catch (NumberFormatException e) {\n // 异常处理\n }\n\n request.response().sendFile(\"web/mybigfile.txt\", offset, end);\n}).listen(8080);\n\n若您想要从偏移量开始发送文件直到尾部，则不需要提供长度信息，这种情况下，您可以执行以下操作：\nvertx.createHttpServer().requestHandler(request -> {\n long offset = 0;\n try {\n offset = Long.parseLong(request.getParam(\"start\"));\n } catch (NumberFormatException e) {\n //异常处理\n }\n\n request.response().sendFile(\"web/mybigfile.txt\", offset);\n}).listen(8080);\n\nPumping 响应\n服务端响应 HttpServerResponse 也是一个 WriteStream 实例，因此您可以从任何 ReadStream 向其泵送数据，如 AsyncFile、NetSocket、WebSocket 或 HttpServerRequest。\n这儿有一个例子，它回应了任何 PUT 方法的响应中的请求体，它为请求体使用了 Pump，所以即使 HTTP 请求体很大并填满了内存，任何时候它依旧会工作：\nvertx.createHttpServer().requestHandler(request -> {\n HttpServerResponse response = request.response();\n if (request.method() == HttpMethod.PUT) {\n response.setChunked(true);\n Pump.pump(request, response).start();\n request.endHandler(v -> response.end());\n } else {\n response.setStatusCode(400).end();\n }\n}).listen(8080);\n\n写入 HTTP/2 帧\nHTTP/2 是用于 HTTP 请求/响应模型的包含各种帧的一种帧协议，该协议允许发送和接收其他类型的帧。\n要发送这样的帧，您可以在响应中使用 writeCustomFrame 方法，以下是一个例子：\nint frameType = 40;\nint frameStatus = 10;\nBuffer payload = Buffer.buffer(\"some data\");\n\n// 向客户端发送一帧\nresponse.writeCustomFrame(frameType, frameStatus, payload);\n\n这些帧被立即发送，并且不受流程控制的影响——当这样的帧被发送到那里时，可以在其他的 DATA 帧之前完成。\n流重置\nHTTP/1.x 不允许请求或响应流执行清除重置，如当客户端上传的资源已经存在于服务器上，服务器就需要接受整个响应。\nHTTP/2 在请求/响应期间随时支持流重置：\nrequest.response().reset();\n\n默认的 NO_ERROR(0) 错误代码会发送，您也可以发送另外一个错误代码：\nrequest.response().reset(8);\n\nHTTP/2 规范中定义了可用的 错误码 列表：\n若使用了 request handler 和 response handler 两个处理器过后，在流重置完成时您将会收到通知：\nrequest.response().exceptionHandler(err -> {\n if (err instanceof StreamResetException) {\n StreamResetException reset = (StreamResetException) err;\n System.out.println(\"Stream reset \" + reset.getCode());\n }\n});\n\n服务器推送\n服务器推送(Server Push)是 HTTP/2 支持的一个新功能，可以为单个客户端请求并行发送多个响应。\n当服务器处理请求时，它可以向客户端推送请求/响应：\nHttpServerResponse response = request.response();\n\n// 推送main.js到客户端\nresponse.push(HttpMethod.GET, \"/main.js\", ar -> {\n\n if (ar.succeeded()) {\n\n // 服务器准备推送响应\n HttpServerResponse pushedResponse = ar.result();\n\n // 发送main.js响应\n pushedResponse.\n putHeader(\"content-type\", \"application/json\").\n end(\"alert(\\\"Push response hello\\\")\");\n } else {\n System.out.println(\"Could not push client resource \" + ar.cause());\n }\n});\n\n// 发送请求的资源内容\nresponse.sendFile(\"\");\n\n当服务器准备推送响应时，推送响应处理器会被调用，并会发送响应。\n推送响应处理器客户能会接收到失败，如：客户端可能取消推送，因为它已经在缓存中包含了 main.js，并不在需要它。\n您必须在响应结束之前调用 push 方法，但是在推送响应过后依然可以写响应。\nHTTP 压缩\nVert.x 支持 HTTP 压缩。\n这意味着在响应发送回客户端之前，您可以将响应体自动压缩。\n若客户端不支持HTTP 压缩，则它可以发回没有压缩过的请求。\n这允许它同时处理支持HTTP 压缩的客户端和不支持的客户端。\n要启用压缩，可以使用 setCompressionSupported 方法进行配置。默认情况下，未启用压缩。\n当启用HTTP 压缩时，服务器将检查客户端请求头中是否包含了 Accept-Encoding 并支持常用的 deflate 和 gzip 压缩算法。Vert.x 两者都支持。若找到这样的请求头，服务器将使用所支持的压缩算法之一自动压缩响应正文并发送回客户端。\n注意：压缩可以减少网络流量，单是CPU密集度会更高。\n为了解决后边一个问题，Vert.x也允许您调整原始的 gzip/deflate 压缩算法的 “压缩级别” 参数\n压缩级别允许根据所得数据的压缩比和压缩/解压的计算成本来配置 gzip/deflate 算法。\n压缩级别是从 1 到 9 的整数值，其中 1 表示更低的压缩比但是最快的算法，9 表示可用的最大压缩比但比较慢的算法。\n使用高于 1-2 的压缩级别通常允许仅仅保存一些字节大小 —— 它的增益不是线性的，并取决于要压缩的特定数据 —— 但它可以满足服务器所要求的CPU周期的不可控的成本（注意现在Vert.x不支持任何缓存形式的响应数据，如静态文件，因此压缩是在每个请求体生成时进行的）,它可生成压缩过的响应数据、并对接收的响应解码（膨胀）—— 和客户端使用的方式一致，这种操作随着压缩级别的增长会变得更加倾向于CPU密集型。\n默认情况下 —— 如果通过 setCompressionSupported 方法启用压缩，Vert.x 将使用 6 作为压缩级别，但是该参数可通过 setCompressionLevel 方法来更改。\n创建 HTTP 客户端\n您可通过以下方式创建一个具有默认配置的 HttpClient 实例：\nHttpClient client = vertx.createHttpClient();\n\n若您想要配置客户端选项，可按以下方式创建：\nHttpClientOptions options = new HttpClientOptions().setKeepAlive(false);\nHttpClient client = vertx.createHttpClient(options);\n\nVert.x 支持基于 TLS h2 和 TCP h2c 的 HTTP/2 协议。\n默认情况下，HTTP 客户端会发送 HTTP/1.1 请求。若要执行 HTTP/2 请求，则必须调用 setProtocolVersion 方法将版本设置成 HTTP_2。\n对于 h2 请求，必须使用应用层协议协商(ALPN)启用TLS：\nHttpClientOptions options = new HttpClientOptions().\n setProtocolVersion(HttpVersion.HTTP_2).\n setSsl(true).\n setUseAlpn(true).\n setTrustAll(true);\n\nHttpClient client = vertx.createHttpClient(options);\n\n对于 h2c 请求，TLS必须禁用，客户端将执行 HTTP/1.1 请求并尝试升级到 HTTP/2：\nHttpClientOptions options = new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_2);\n\nHttpClient client = vertx.createHttpClient(options);\n\nh2c 连接也可以直接建立，如连接可以使用前文提到的方式创建，当 setHttp2ClearTextUpgrade 选项设置为 false 时：建立连接后，客户端将发送 HTTP/2 连接前缀，并期望从服务端接收相同的连接偏好。\nHTTP 服务端可能不支持 HTTP/2，当响应到达时，可以使用 version 方法检查响应实际HTTP版本。\n当客户端连接到 HTTP/2 服务端时，它将向服务端发送其初始设置。设置定义服务器如何使用连接、客户端的默认初始设置是由 HTTP/2 RFC定义的。\n记录客户端网络活动\n为了进行调试，可以记录网络活动：\nHttpClientOptions options = new HttpClientOptions().setLogActivity(true);\nHttpClient client = vertx.createHttpClient(options);\n\n详情请参阅 记录网络活动 章节。\n发出请求\nHTTP 客户端是很灵活的，您可以通过各种方式发出请求。\n通常您希望使用 HTTP 客户端向同一个主机/端口发送很多请求。为避免每次发送请求时重复设主机/端口，您可以为客户端配置默认主机/端口：\nHttpClientOptions options = new HttpClientOptions().setDefaultHost(\"wibble.com\");\n// Can also set default port if you want...\n// 若您想可设置默认端口\nHttpClient client = vertx.createHttpClient(options);\nclient.getNow(\"/some-uri\", response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n});\n\n或者您发现自己使用相同的客户端向不同主机的主机/端口发送大量请求，则可以在发出请求时简单指定主机/端口：\nHttpClient client = vertx.createHttpClient();\n\n// 指定端口和主机名\nclient.getNow(8080, \"myserver.mycompany.com\", \"/some-uri\", response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n});\n\n// 这次使用默认端口80和指定的主机名\nclient.getNow(\"foo.othercompany.com\", \"/other-uri\", response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n});\n\n用客户端发出请求的所有不同方式都支持这两种指定主机/端口的方法。\n无请求体的简单请求\n通常，您想发出没有请求体的HTTP 请求，这种情况通常如HTTP GET、OPTIONS 和 HEAD 请求。\n使用 Vert.x HTTP Client 执行这种请求最简单的方式是使用加了 Now 后缀的请求方法，如 getNow。这些方法会创建HTTP 请求，并在单个方法调用中发送它，而且允许您提供一个处理器，当HTTP 响应发送回来时调用该处理器来处理响应结果。\nHttpClient client = vertx.createHttpClient();\n\n// 发送GET请求\nclient.getNow(\"/some-uri\", response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n});\n\n// 发送HEAD请求\nclient.headNow(\"/other-uri\", response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n});\n\n发送通用请求\n有时您在运行时不知道发送请求的 HTTP 方法，对于这种情况，我们提供通用请求方法 request，允许您在运行时指定 HTTP 方法：\nHttpClient client = vertx.createHttpClient();\n\nclient.request(HttpMethod.GET, \"some-uri\", response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n}).end();\n\nclient.request(HttpMethod.POST, \"foo-uri\", response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n}).end(\"some-data\");\n\n写请求体\n有时您想要发送一个包含了请求体的请求，或者也许您想要在发送请求之前写入头部到请求中。\n为此，您可以调用其中一个指定的请求方法，如 post 或一个其他通用请求方法，如 request。这些方法都不会立即发送请求，而是返回一个 HttpClientRequest 实例，它可以用来写数据到请求体和请求头。\n这儿有一些写入请求体的 POST 请求例子：\nHttpClient client = vertx.createHttpClient();\n\nHttpClientRequest request = client.post(\"some-uri\", response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n});\n\n// 现在准备请求的一些东西\nrequest.putHeader(\"content-length\", \"1000\");\nrequest.putHeader(\"content-type\", \"text/plain\");\nrequest.write(body);\n\n// 确保请求完成后结束\nrequest.end();\n\n// 或使用Fluent的API\nclient.post(\"some-uri\", response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n}).putHeader(\"content-length\", \"1000\").putHeader(\"content-type\", \"text/plain\").write(body).end();\n\n// 或事情更简单\nclient.post(\"some-uri\", response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n}).putHeader(\"content-type\", \"text/plain\").end(body);\n\n可以用UTF-8编码方式编码字符串和以指定方式编码编码字符串、或写Buffer的方法：\n// 写UTF-8编码的字符串\nrequest.write(\"some data\");\n\n// 写指定编码的字符串\nrequest.write(\"some other data\", \"UTF-16\");\n\n// 写Buffer\nBuffer buffer = Buffer.buffer();\nbuffer.appendInt(123).appendLong(245l);\nrequest.write(buffer);\n\n若您仅需要写单个字符串或 Buffer 到HTTP请求中，您可以直接调用 end 函数完成写入和请求的发送操作。\nrequest.end(\"some simple data\");\n\n// 在单次调用中写Buffer并结束请求（直接发送）\nBuffer buffer = Buffer.buffer().appendDouble(12.34d).appendLong(432l);\nrequest.end(buffer);\n\n当您写入请求时，第一次调用 write 方法将先将请求头写入到请求报文中。\n实际写入操作是异步的，它可能在调用返回一段时间后才发生。\n带请求体的非分块 HTTP 请求需要提供 Content-Length 头。因此，若您不使用 HTTP 分块，则必须在写入请求之前设置Content-Length头，否则会出错。\n若您在调用其中一个 end 方法处理 String 或 Buffer，在写入请求体之前，Vert.x 将自动计算并设置 Content-Length。若您在使用HTTP 分块模式，则不需要 Content-Length 头，因此您不必先计算大小。\n写请求头\n您可以直接使用 MultiMap 结构的 headers 来设置请求头：\nMultiMap headers = request.headers();\nheaders.set(\"content-type\", \"application/json\").set(\"other-header\", \"foo\");\n\n这个headers是一个 MultiMap 的实例，它提供了添加、设置、删除条目的操作。HTTP Header允许一个特定的键包含多个值。\n您也可以使用 putHeader 方法编写头文件：\nrequest.putHeader(\"content-type\", \"application/json\").putHeader(\"other-header\", \"foo\");\n\n若您想写入请求头，则您必须在写入任何请求体之前这样做来设置请求头。\n非标准的HTTP 方法\nOTHER HTTP方法用于非标准HTTP方法，当使用此方法时，必须使用 setRawMethod 方法来设置需要发送到服务器的raw方法。\n发送 HTTP 请求\n一旦完成了 HTTP 请求的准备工作，您必须调用其中一个 end 方法来发送该请求（结束请求）。\n结束一个请求时，若请求头尚未被写入，会导致它们被写入，并且请求被标记成完成的。\n请求可以通过多种方式结束。无参简单结束请求的方式如：\nrequest.end();\n\n或可以在调用 end 方法时提供 String 或 Buffer，这个和先调用带 String/Buffer 参数的 write 方法之后再调用无参 end 方法一样：\nrequest.end(\"some-data\");\n\n// 使用buffer结束\nBuffer buffer = Buffer.buffer().appendFloat(12.3f).appendInt(321);\nrequest.end(buffer);\n\n分块 HTTP 请求\nVert.x 支持 HTTP Chunked Transfer Encoding 请求。\n这允许使用块方式写入HTTP 请求体，这个在请求体比较大需要流式发送到服务器，或预先不知道大小时很常用。\n您可使用 setChuncked 将HTTP 请求设置成分块模式。\n在分块模式下，每次调用 write 方法将导致新的块被写入到报文，这种模式中，无需先设置请求头中的 Content-Length。\nrequest.setChunked(true);\n\n// Write some chunks\n// 写一些块\nfor (int i = 0; i \n请求超时\n您可使用 setTimeout设置一个特定 HTTP 请求的超时时间。\n若请求在超时期限内未返回任何数据，则异常将会被传给异常处理器（若提供），并且请求将会被关闭。\n处理异常\n您可以通过在 HttpClientRequest 实例中设置异常处理器来处理请求时发生的异常：\nHttpClientRequest request = client.post(\"some-uri\", response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n});\nrequest.exceptionHandler(e -> {\n System.out.println(\"Received exception: \" + e.getMessage());\n e.printStackTrace();\n});\n\n这种处理器不处理需要在 HttpClientResponse 中处理的非 2xx 响应：\nHttpClientRequest request = client.post(\"some-uri\", response -> {\n if (response.statusCode() == 200) {\n System.out.println(\"Everything fine\");\n return;\n }\n if (response.statusCode() == 500) {\n System.out.println(\"Unexpected behavior on the server side\");\n return;\n }\n});\nrequest.end();\n\n\n重要提示：一系列的 XXXNow 方法均不接收异常处理器做为参数。\n\n客户端请求中指定处理器\n不像在调用中提供响应处理器来创建客户端请求对象，相反您可以当请求创建时不提供处理器、稍后在请求对象中调用 handler 来设置。如：\nHttpClientRequest request = client.post(\"some-uri\");\nrequest.handler(response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n});\n\n使用流式请求\nHttpClientRequest 实例实现了 WriteStream 接口，这意味着您可以从任何 ReadStream 实例将数据泵入请求中。\n例如，您可以将磁盘上的文件直接泵送到HTTP 请求体中，如下所示：\nrequest.setChunked(true);\nPump pump = Pump.pump(file, request);\nfile.endHandler(v -> request.end());\npump.start();\n\n写 HTTP/2 帧\nHTTP/2 是用于 HTTP 请求/响应模型的具有各种帧的一个帧协议，该协议允许发送和接收其他类型的帧。\n要发送这样的帧，您可以使用 write 方法写入请求，以下是一个例子：\nint frameType = 40;\nint frameStatus = 10;\nBuffer payload = Buffer.buffer(\"some data\");\n\n// Sending a frame to the server\n// 发送一帧到服务器\nrequest.writeCustomFrame(frameType, frameStatus, payload);\n\n流重置\nHTTP/1.x 不允许请求或响应流进行重置，如当客户端上传了服务器上存在的资源时，服务器依然要接收整个响应。\nHTTP/2 在请求/响应期间随时支持流重置：\nrequest.reset();\n\n默认情况，发送 NO_ERROR(0)错误代码，可发送另一个代码：\nrequest.reset(8);\n\nHTTP/2规范定义了可使用的 错误码 列表。\n若使用了 request handler 和 response handler 两个处理器过后，在流重置完成时您将会收到通知。\nrequest.exceptionHandler(err -> {\n if (err instanceof StreamResetException) {\n StreamResetException reset = (StreamResetException) err;\n System.out.println(\"Stream reset \" + reset.getCode());\n }\n});\n\n处理 HTTP 响应\n您可以在请求方法中指定处理器或通过 HttpClientRequest 对象直接设置处理器来接收到 HttpClientResponse 的实例。\n您可以通过 statusCode 和 statusMessage 方法从响应中查询响应的状态码和状态消息：\nclient.getNow(\"some-uri\", response -> {\n // the status code - e.g. 200 or 404\n // 状态代码,如:200、404\n System.out.println(\"Status code is \" + response.statusCode());\n\n // the status message e.g. \"OK\" or \"Not Found\".\n // 状态消息,如:OK、Not Found\n System.out.println(\"Status message is \" + response.statusMessage());\n});\n\n使用流式响应\nHttpClientResponse 实例也是一个 ReadStream 实例，这意味着您可以泵送数据到任何 WriteStream 实例。\n响应头和尾\nHTTP 响应可包含头信息。您可以使用 headers 方法来读取响应头。该方法返回的对象是 一个 MultiMap 实例，因为 HTTP 响应头中单个键可以关联多个值。\nString contentType = response.headers().get(\"content-type\");\nString contentLength = response.headers().get(\"content-lengh\");\n\n分块 HTTP 响应还可以包含响应尾(trailer) —— 这实际上是在发送响应体的最后一个（数据）块。\n您可使用 trailers方法读取响应尾，尾数据也是一个 MultiMap。\n读取请求体\n当从报文中读取到响应头时，响应处理器就会被调用。如果收到的HTTP 响应包含响应体（正文），它可能会在响应头被读取后的某个时间以分片的方式到达。在调用响应处理器之前，我们不要等待所有的响应体到达，因为它可能非常大而要等待很长时间、又或者会花费大量内存。\n当响应体的某部分（数据）到达时，handler 方法绑定的回调函数将会被调用，其中传入的 Buffer 中包含了响应体的这一分片（部分）内容：\nclient.getNow(\"some-uri\", response -> {\n\n response.handler(buffer -> {\n System.out.println(\"Received a part of the response body: \" + buffer);\n });\n});\n\n若您知道响应体不是很大，并想在处理之前在内存中聚合所有响应体数据，那么您可以自己聚合：\nclient.getNow(\"some-uri\", response -> {\n\n // Create an empty buffer\n // 创建空的缓冲区\n Buffer totalBuffer = Buffer.buffer();\n\n response.handler(buffer -> {\n System.out.println(\"Received a part of the response body: \" + buffer.length());\n\n totalBuffer.appendBuffer(buffer);\n });\n\n response.endHandler(v -> {\n // Now all the body has been read\n // 现在所有的响应体都读取了\n System.out.println(\"Total response body length is \" + totalBuffer.length());\n });\n});\n\n或者当响应已被完全读取时，您可以使用 bodyHandler 方法以便读取整个响应体：\nclient.getNow(\"some-uri\", response -> {\n\n response.bodyHandler(totalBuffer -> {\n // Now all the body has been read\n // 现在所有的响应体都读取了\n System.out.println(\"Total response body length is \" + totalBuffer.length());\n });\n});\n\n响应完成处理器\n当整个响应体被完全读取或者无响应体的响应头被完全读取时，响应的 endHandler 就会被调用。\n从响应中读取Cookie\n您可以通过 cookies 方法从响应中获取 Cookie 列表。或者您可以在响应中自己解析Set-Cookie头。\n30x 重定向处理器\n客户端可配置成遵循HTTP 重定向：当客户端接收到 301、302、303 或 307 状态代码时，它遵循由 Location 响应头提供的重定向，并且响应处理器将传递重定向响应以替代原始响应。\n这有个例子：\nclient.get(\"some-uri\", response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n}).setFollowRedirects(true).end();\n\n重定向策略如下：\n\n当接收到 301、302 或 303 状态代码时，使用 GET 方法执行重定向\n当接收到 307 状态代码时，使用相同的 HTTP 方法和缓存的请求体执行重定向\n\n\n警告：随后的重定向会缓存请求体。\n\n默认情况最大的重定向数为 16，您可使用 setMaxRedirects 方法设置。\nHttpClient client = vertx.createHttpClient(\n new HttpClientOptions()\n .setMaxRedirects(32));\n\nclient.get(\"some-uri\", response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n}).setFollowRedirects(true).end();\n\n没有放之四海而皆准的策略，缺省的重定向策略可能不能满足您的需要。默认重定向策略可使用自定义实现更改：\nclient.redirectHandler(response -> {\n\n // Only follow 301 code\n // 仅仅遵循301状态代码\n if (response.statusCode() == 301 && response.getHeader(\"Location\") != null) {\n\n // Compute the redirect URI\n // 计算重定向URI\n String absoluteURI = resolveURI(response.request().absoluteURI(), response.getHeader(\"Location\"));\n\n // Create a new ready to use request that the client will use\n // 创建客户端将使用的新的可用请求\n return Future.succeededFuture(client.getAbs(absoluteURI));\n }\n\n // We don't redirect\n // 我们不需要重定向\n return null;\n});\n\n这个策略将会处理接收到的原始 HttpClientResponse，并返回 null 或 Future 。\n\n当返回的是 null 时，处理原始响应\n当返回的是 Future 时，请求将在它成功完成后发送\n当返回的是 Future 时，请求失败时调用设置的异常处理器\n\n返回的请求必须是未发送的，这样原始请求处理器才会被发送而且客户端之后才能发送请求。大多数原始请求设置将会传播（拷贝）到新请求中：\n\n请求头，除非您已经设置了一些头（包括 setHost）\n请求体，除非返回的请求使用了 GET 方法\n响应处理器\n请求异常处理器\n请求超时\n\n100-Continue 处理\n根据 HTTP/1.1 规范，一个客户端可以设置请求头 Expect: 100-Continue，并且在发送剩余请求体之前先发送请求头。然后服务器可以通过回复临时响应状态 Status: 100 (Continue) 来告诉客户端可以发送请求的剩余部分。\n这里的想法是允许服务器在发送大量数据之前授权、接收/拒绝请求，若请求不能被接收，则发送大量数据信息会浪费带宽，并将服务器绑定在读取即将丢弃的无用数据中。\nVert.x 允许您在客户端请求对象中设置一个 continueHandler。它将在服务器发回一个状态 Status: 100 (Continue) 时被调用, 同时也表示（客户端）可以发送请求的剩余部分。通常将其与 sendHead 结合起来发送请求的头信息。\n以下是一个例子：\nHttpClientRequest request = client.put(\"some-uri\", response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n});\n\nrequest.putHeader(\"Expect\", \"100-Continue\");\n\nrequest.continueHandler(v -> {\n // OK to send rest of body\n // 可发送请求体剩余部分\n request.write(\"Some data\");\n request.write(\"Some more data\");\n request.end();\n});\n\n在服务端，Vert.x HTTP Server可配置成接收到 Expect: 100-Continue 头时自动发回 100 Continue 临时响应信息。这个可通过 setHandle100ContinueAutomatically 方法来设置。\n若您想要决定是否手动发送持续响应，那么此属性可设置成false（默认值），然后您可以通过检查头信息并且调用 writeContinue 方法让客户端持续发送请求体：\nhttpServer.requestHandler(request -> {\n if (request.getHeader(\"Expect\").equalsIgnoreCase(\"100-Continue\")) {\n\n // Send a 100 continue response\n // 发送100 Continue持续响应\n request.response().writeContinue();\n\n // The client should send the body when it receives the 100 response\n // 当客户端收到100响应代码则可以发送剩余请求体\n request.bodyHandler(body -> {\n // Do something with body\n });\n\n request.endHandler(v -> {\n request.response().end();\n });\n }\n});\n\n您也可以通过直接发送故障状态代码来拒绝该请求：这种情况下，请求体应该被忽略或连接应该被关闭（100-Continue 是一个性能提示，并不是逻辑协议约束）：\nhttpServer.requestHandler(request -> {\n if (request.getHeader(\"Expect\").equalsIgnoreCase(\"100-Continue\")) {\n\n //\n boolean rejectAndClose = true;\n if (rejectAndClose) {\n\n // Reject with a failure code and close the connection\n // this is probably best with persistent connection\n // 使用失败码拒绝并关闭这个连接，这可能是长连接最好的\n request.response()\n .setStatusCode(405)\n .putHeader(\"Connection\", \"close\")\n .end();\n } else {\n\n // Reject with a failure code and ignore the body\n // this may be appropriate if the body is small\n // 使用失败码拒绝忽略请求体，若体很小，这是适用的\n request.response()\n .setStatusCode(405)\n .end();\n }\n }\n});\n\n客户端推送\n服务器推送(Server Push)是 HTTP/2 的一个新功能，它可以为单个客户端并行发送多个响应。\n可以在接收服务器推送的请求/响应的请求上设置一个推送处理器：\nHttpClientRequest request = client.get(\"/index.html\", response -> {\n // Process index.html response\n // 处理index.html响应\n});\n\n// Set a push handler to be aware of any resource pushed by the server\n// 设置一个推送处理器来感知服务器推送的任何资源\nrequest.pushHandler(pushedRequest -> {\n\n // A resource is pushed for this request\n // 为当前请求推送资源\n System.out.println(\"Server pushed \" + pushedRequest.path());\n\n // Set an handler for the response\n // 为响应设置处理器\n pushedRequest.handler(pushedResponse -> {\n System.out.println(\"The response for the pushed request\");\n });\n});\n\n// End the request\n// 结束请求\nrequest.end();\n\n若客户端不想收到推送请求，它可重置流：\nrequest.pushHandler(pushedRequest -> {\n if (pushedRequest.path().equals(\"/main.js\")) {\n pushedRequest.reset();\n } else {\n // Handle it\n // 处理逻辑\n }\n});\n\n若没有设置任何处理器时，任何被推送的流将被客户端自动重置流（错误代码 8）。\n接收自定义 HTTP/2 帧\nHTTP/2 是用于 HTTP 请求/响应模型的具有各种帧的一个帧协议，该协议允许发送和接收其他类型的帧。\n要接收自定义帧，您可以在请求中使用 customFrameHandler，每次自定义帧到达时就会调用它。以下是一个例子：\nresponse.customFrameHandler(frame -> {\n\n System.out.println(\"Received a frame type=\" + frame.type() +\n \" payload\" + frame.payload().toString());\n});\n\n客户端启用压缩\nHTTP 客户端支持开箱即用的 HTTP 压缩功能。这意味着客户端可以让远程服务器知道它支持压缩，并且能处理压缩过的响应体（数据）。\nHTTP 服务端可以自由地使用自己支持的压缩算法之一进行压缩，也可以在不压缩的情况下将响应体发回。所以这仅仅是 HTTP 服务端的一个可能被随意忽略的提示。\n要告诉服务器当前客户端支持哪种压缩，则它（请求头）将包含一个 Accept-Encoding 头，其值为可支持的压缩算法，（该值可）支持多种压缩算法。这种情况 Vert.x 将添加以下头：\nAccept-Encoding: gzip, deflate\n\n服务器将从其中（算法）选择一个，您可以通过服务器发回的响应中响应头 Content-Encoding 来检测服务器是否适应这个正文。\n若响应体通过 gzip 压缩，它将包含例如下边的头：\nContent-Encoding: gzip\n\n创建客户端时可使用 setTryUseCompression 设置配置项启用压缩。\n默认情况压缩被禁用。\nHTTP/1.x Pooling 和 Keep alive\nHTTP 的 Keep Alive 允许单个 HTTP 连接用于多个请求。当您向同一台服务器发送多个请求时，可以更加有效使用连接。\n对于 HTTP/1.x 版本，HTTP 客户端支持连接池，它允许您重用请求之间的连接。\n为了连接池（能）工作，配置客户端时，keep alive 必须通过 setKeepAlive 方法设置成true。默认值为true。\n当 keep alive 启用时，Vert.x 将为每一个发送的 HTTP/1.0 请求添加一个 Connection: Keep-Alive 头。当 keep alive 禁用时，Vert.x 将为每一个 HTTP/1.1 请求添加一个 Connection: Close 头 —— 表示在响应完成后连接将被关闭。\n可使用 setMaxPoolSize 方法为每个服务器配置连接池的最大连接数。\n当启用连接池创建请求时，若存在少于已经为服务器创建的最大连接数，Vert.x 将创建一个新连接，否则直接将请求添加到队列中。\nKeep Alive的连接将不会被客户端自动关闭，要关闭它们您可以关闭客户端实例。\n或者，您可使用setIdleTimeout设置空闲时间——在设置的时间内然后没使用的连接将被关闭。请注意空闲超时值以秒为单位而不是毫秒。\nHTTP/1.1 Pipe-lining\n客户端还支持连接上的请求管道(pipeline)。\n管道意味着在返回一个响应之前，在同一个连接上发送另一个请求，管道不适合所有请求。\n若要启用管道，必须调用setPipelining方法，默认管道是禁止的。\n当启用管道时，请求可以不等待以前的响应返回而写入到连接。\n单个连接的管道请求限制数由 setPipeliningLimit 方法设置，此选项定义了发送到服务器的等待响应的最大请求数。这个限制可以确保和同一个服务器的连接分发到客户端的公平性。\nHTTP/2 多路复用\nHTTP/2 提倡使用服务器的单一连接，默认情况下，HTTP 客户端针对每个服务器都使用单一连接，同样服务器上的所有流都会复用到对应连接中。\n当客户端需要使用连接池并使用超过一个连接时，则可使用setHttp2MaxPoolSize 设置。\n当您希望限制每个连接的多路复用流数量而使用连接池而不是单个连接时，可使用 setHttp2MultiplexingLimit 设置。\nHttpClientOptions clientOptions = new HttpClientOptions().\n setHttp2MultiplexingLimit(10).\n setHttp2MaxPoolSize(3);\n\n// Uses up to 3 connections and up to 10 streams per connection\n// 每个连接最多可用三个连接，每个连接可连接10个流\nHttpClient client = vertx.createHttpClient(clientOptions);\n\n连接的复用限制是在客户端上设置限制单个连接的流数量，如果服务器使用 SETTINGS_MAX_CONCURRENT_STREAMS 设置了下限，则有效值可以更低。\nHTTP/2 连接不会被客户端自动关闭，若要关闭它们，可以调用 close 来关闭客户端实例。\n或者，您可以使用setIdleTimeout设置空闲时间——这个时间内没有使用的任何连接将被关闭，注意，空闲时间以秒为单位，不是毫秒。\nHTTP 连接\nHttpConnection 接口提供了处理HTTP 连接事件、生命周期、设置的API。\nHTTP/2 实现了完整的 HttpConnection API。\nHTTP/1.x 实现了 HttpConnection 中的部分API：仅关闭操作，实现了关闭处理器和异常处理器。该协议并不提供其他操作的语义。\n服务端连接\nconnection 方法会返回服务器上的请求连接：\nHttpConnection connection = request.connection();\n\n可以在服务器上设置连接处理器，任意连接传入时可得到通知：\nHttpServer server = vertx.createHttpServer(http2Options);\n\nserver.connectionHandler(connection -> {\n System.out.println(\"A client connected\");\n});\n\n客户端连接\nconnection 方法会返回客户端上的连接请求：\nHttpConnection connection = request.connection();\n\n可以在请求上设置连接处理器在连接发生时通知：\nrequest.connectionHandler(connection -> {\n System.out.println(\"Connected to the server\");\n});\n\n连接配置\nHTTP/2 由 Http2Settings 数据对象来配置。\n每个 Endpoint 都必须遵守连接另一端的发送设置。\n当建立连接时，客户端和服务器交换初始配置，初始设置由客户端上的 setInitialSettings 和服务器上的 setInitialSettings 方法配置。\n连接建立后可随时更改设置：\nconnection.updateSettings(new Http2Settings().setMaxConcurrentStreams(100));\n\n由于远程方应该确认接收者的配置更新，也有可能在回调中接收确认通知：\nconnection.updateSettings(new Http2Settings().setMaxConcurrentStreams(100), ar -> {\n if (ar.succeeded()) {\n System.out.println(\"The settings update has been acknowledged \");\n }\n});\n\n相反，在收到新的远程设置时会通知 remoteSettingsHandler：\nconnection.remoteSettingsHandler(settings -> {\n System.out.println(\"Received new settings\");\n});\n\n\n请注意：此功能仅适用于 HTTP/2 协议。\n\n连接 Ping\nHTTP/2 连接 ping 对于确定连接往返时间或检查连接有效性很有用：ping 发送 PING 帧到远端：\nBuffer data = Buffer.buffer();\nfor (byte i = 0;i {\n System.out.println(\"Remote side replied\");\n});\n\n当接收到 PING 帧时，Vert.x 将自动发送确认，可设置处理器当收到 ping 帧时发送通知调用处理器：\nconnection.pingHandler(ping -> {\n System.out.println(\"Got pinged by remote side\");\n});\n\n处理器只是接到通知，确认被发送，这个功能旨在基于 HTTP/2 协议之上实现。\n\n请注意：此功能仅适用于 HTTP/2 协议。\n\n连接关闭/GOAWAY\n调用 shutdown 方法将发送 GOAWAY 帧到远程的连接，要求其停止创建流：客户端将停止发送新请求，并且服务器将停止推送响应。发送 GOAWAY 帧后，连接将等待一段时间（默认为30秒），直到所有当前流关闭和连接关闭。\nconnection.shutdown();\n\nshutdownHandler 通知何时关闭所有流，连接尚未关闭。\n有可能只需发送 GOAWAY 帧，和关闭主要的区别在于它将只是告诉远程连接停止创建新流，而没有计划关闭连接：\nconnection.goAway(0);\n\n相反，也可以在收到 GOAWAY 时收到通知：\nconnection.goAwayHandler(goAway -> {\n System.out.println(\"Received a go away frame\");\n});\n\n当所有当前流已经关闭并且可关闭连接时，shutdownHandler 将被调用：\nconnection.goAway(0);\nconnection.shutdownHandler(v -> {\n\n // All streams are closed, close the connection\n // 所有流被关闭，连接也关闭\n connection.close();\n});\n\n当接收到 GOAWAY 时也适用。\n\n请注意：此功能仅适用于HTTP/2协议。\n\n连接关闭\n您可以通过 close 方法关闭连接：\n\n对于 HTTP/1.x 来说，它会关闭底层的 Socket\n对于 HTTP/2 来说，它将执行无延迟关闭，GOAWAY 帧将会在连接关闭之前被发送\n\n连接关闭时 closeHandler 将发出通知。\nHttpClient 使用说明\nHttpClient可以在一个 Verticle 中使用或者嵌入使用。\n在 Verticle 中使用时，Verticle 应该使用自己的客户端实例。\n一般来说，不应该在不同的 Vert.x 上下文环境之间共享客户端，因为它可能导致不可预知的意外。例如：保持活动连接将在打开连接的请求上下文环境调用客户端处理器，后续请求将使用相同上下文环境。\n当这种情况发生时，Vert.x会检测到并记录下边警告：\nReusing a connection with a different context: an HttpClient is probably shared between different Verticles\nHttpClient 可以嵌套在非 Vert.x 线程中，如单元测试或纯Java的 main 线程中：客户端处理器将被不同的Vert.x 线程和上下文调用，这样的上下文会根据需要创建。对于生产环境，不推荐这样使用。\n水平扩展 - 服务端共享\n当多个 HTTP 服务端在同一个端口上监听时，Vert.x 会使用轮询策略来管理请求处理。\n我们用 Verticle 来创建 HTTP 服务端，如：\nio.vertx.examples.http.sharing.HttpServerVerticle\nvertx.createHttpServer().requestHandler(request -> {\n request.response().end(\"Hello from server \" + this);\n}).listen(8080);\n\n这个服务正在监听 8080 端口。所以，当这个 Verticle 被实例化多次，如运行以下命令：\nvertx run io.vertx.examples.http.sharing.HttpServerVerticle -instances 2\n将会发生什么？如果两个 Verticle 都绑定到同一个端口，您将收到一个 Socket 异常。幸运的是，Vert.x 可以为您处理这种情况。在与现有服务端相同的主机和端口上部署另一个服务器时，实际上并不会尝试创建在同一主机/端口上监听的新服务端，它只绑定一次到Socket，当接收到请求时，会按照轮询策略调用服务端的请求处理函数。\n我们现在想象一个客户端，如下：\nvertx.setPeriodic(100, (l) -> {\n vertx.createHttpClient().getNow(8080, \"localhost\", \"/\", resp -> {\n resp.bodyHandler(body -> {\n System.out.println(body.toString(\"ISO-8859-1\"));\n });\n });\n});\n\nVert.x 将请求顺序委托给其中一个服务器：\nHello from i.v.e.h.s.HttpServerVerticle@1\nHello from i.v.e.h.s.HttpServerVerticle@2\nHello from i.v.e.h.s.HttpServerVerticle@1\nHello from i.v.e.h.s.HttpServerVerticle@2\n...\n因此，服务器可直接扩展可用的核，而每个 Vert.x 中的 Verticle 实例仍然严格使用单线程，您不需要像编写负载均衡器那样使用任何特殊技巧去编写，以便在多核机器上扩展服务器。\n使用 HTTPS\nVert.x 的 HTTP 服务端和客户端可以配置成和网络服务器完全相同的方式使用 HTTPS。\n有关详细信息，请参阅 配置网络服务器以使用 SSL 章节。\nSSL可以通过每个请求的 RequestOptions 来启用/禁用，或在指定模式时调用 requestAbs：\nclient.getNow(new RequestOptions()\n .setHost(\"localhost\")\n .setPort(8080)\n .setURI(\"/\")\n .setSsl(true), response -> {\n System.out.println(\"Received response with status code \" + response.statusCode());\n});\n\nsetSsl 设置将用作客户端默认配置。\nsetSsl 将覆盖默认客户端设置：\n\n即使客户端配置成使用 SSL/TLS，该值设置成false将禁用SSL/TLS。\n即使客户端配置成不使用 SSL/TLS，该值设置成true将启用SSL/TLS，实际的客户端SSL/TLS（如受信、密钥/证书、密码、ALPN 等）将被重用。\n\n同样，requestAbs 方法也会（在调用时）覆盖默认客户端设置。\nWebSocket\nWebSocket 是一种Web技术，可以在 HTTP 服务端和 HTTP 客户端（通常是浏览器）之间实现全双工 Socket 连接。\nVert.x HTTP 客户端和服务端都支持 WebSocket。\n服务端 WebSocket\n在服务端处理 WebSocket 有两种方法。\n\nWebSocket Handler\n\n第一种方法需要在服务端实例上提供一个 websocketHandler。\n当对服务端创建 WebSocket 连接时，Vert.x 将向 Handler传入一个 ServerWebSocket 实例，在其中去处理它。\nserver.websocketHandler(websocket -> {\n System.out.println(\"Connected!\");\n});\n\n您可以调用reject 方法来拒绝一个 WebSocket。\nserver.websocketHandler(websocket -> {\n if (websocket.path().equals(\"/myapi\")) {\n websocket.reject();\n } else {\n // Do something\n // 做一些事\n }\n});\n\n\n转换到 WebSocket\n\n处理 WebSocket 的第二种方法是处理从客户端发送的HTTP升级请求，调用服务器请求对象的 upgrade方法：\nserver.requestHandler(request -> {\n if (request.path().equals(\"/myapi\")) {\n\n ServerWebSocket websocket = request.upgrade();\n // Do something\n // 做一些事\n } else {\n // Reject\n // 拒绝\n request.response().setStatusCode(400).end();\n }\n});\n\n\n服务端 WebSocket\n\nServerWebSocket 实例能够让您读取在WebSocket 握手中的HTTP 请求的 headers、path、query 和 URI。\n客户端 WebSocket\nVert.x 的 HttpClient 支持 WebSocket。\n您可以调用其中任意一个 websocket 方法创建 WebSocket 连接到服务端，并提供回调函数。\n当连接建立时，处理器将被调用并且传入 WebSocket实例：\nclient.websocket(\"/some-uri\", websocket -> {\n System.out.println(\"Connected!\");\n});\n\n向 WebSocket 写入消息\n若您想将一个 WebSocket 消息写入 WebSocket，可使用writeBinaryMessage 方法或 writeTextMessage 方法来执行该操作：\nBuffer buffer = Buffer.buffer().appendInt(123).appendFloat(1.23f);\nwebsocket.writeBinaryMessage(buffer);\n\n// Write a simple text message\n// 写一个简单文本消息\nString message = \"hello\";\nwebsocket.writeTextMessage(message);\n\n若WebSocket 消息大于使用setMaxWebsocketFrameSize 设置的W ebSocket 的帧的最大值，则Vert.x在将其发送到报文之前将其拆分为多个WebSocket 帧。\n向 WebSocket 写入帧\nWebSocket 消息可以由多个帧组成，在这种情况下，第一帧是二进制或文本帧（text | binary），后边跟着零个或多个 连续 帧。\n消息中的最后一帧标记成 final。\n要发送多个帧组成的消息，请使用 WebSocketFrame.binaryFrame、WebSocketFrame.textFrame 或 WebSocketFrame.continuationFrame 方法创建帧，并使用 writeFrame 方法将其写入WebSocket。\n以下是二进制帧的示例：\nWebSocketFrame frame1 = WebSocketFrame.binaryFrame(buffer1, false);\nwebsocket.writeFrame(frame1);\n\nWebSocketFrame frame2 = WebSocketFrame.continuationFrame(buffer2, false);\nwebsocket.writeFrame(frame2);\n\n// Write the final frame\n// 写最终帧\nWebSocketFrame frame3 = WebSocketFrame.continuationFrame(buffer2, true);\nwebsocket.writeFrame(frame3);\n\n许多情况下，您只需要发送一个包含了单个最终帧的 WebSocket 消息，因此我们提供了 writeFinalBinaryFrame 和 writeFinalTextFrame 这两个快捷方法。\n下边是示例：\nwebsocket.writeFinalTextFrame(\"Geronimo!\");\n\n// Send a websocket messages consisting of a single final binary frame:\n// 发送由单个最终二进制帧组成的websocket消息：\nBuffer buff = Buffer.buffer().appendInt(12).appendString(\"foo\");\n\nwebsocket.writeFinalBinaryFrame(buff);\n\n从 WebSocket 读取帧\n要 从WebSocket 读取帧，您可以使用frameHandler 方法。\n当帧到达时，会传入一个WebSocketFrame实例给帧处理器，并调用它，例如：\nwebsocket.frameHandler(frame -> {\n System.out.println(\"Received a frame of size!\");\n});\n\n关闭 WebSocket\n处理完成之后，请使用 close 方法关闭 WebSocket 连接。\n流式 WebSocket\nWebSocket 实例也是ReadStream和WriteStream 的实现类，因此可以和泵(pump)一起使用。\n当使用 WebSocket 作为可写流或可读流时，它只能用于不分割多个帧的二进制帧一起使用的 WebSocket 连接。\n使用 HTTP/HTTPS 连接代理\nHTTP 客户端支持通过HTTP 代理（如Squid）或 SOCKS4a 或 SOCKS5 代理访问 HTTP/HTTPS 的 URL。CONNECT 协议使用 HTTP/1.x，但可以连接到 HTTP/1.x 和 HTTP/2 服务器。\n到 h2c（未加密HTTP/2服务器）的连接可能不受 HTTP 代理支持，因为代理仅支持 HTTP/1.1。\n您可以通过 HttpClientOptions 中的 ProxyOptions 对象配置来配置代理（包括代理类型、主机名、端口和可选用户名和密码）。\n以下是使用 HTTP 代理的例子：\nHttpClientOptions options = new HttpClientOptions()\n .setProxyOptions(new ProxyOptions().setType(ProxyType.HTTP)\n .setHost(\"localhost\").setPort(3128)\n .setUsername(\"username\").setPassword(\"secret\"));\nHttpClient client = vertx.createHttpClient(options);\n\n当客户端连接到HTTP URL时，它连接到代理服务器，并在HTTP请求中提供完整URL（GET http://www.somehost.com/path/file.html HTTP/1.1）。\n当客户端连接到HTTPS URL时，它要求代理使用 CONNECT 方法创建到远程主机的通道。\n对于 SOCKS5 代理：\nHttpClientOptions options = new HttpClientOptions()\n .setProxyOptions(new ProxyOptions().setType(ProxyType.SOCKS5)\n .setHost(\"localhost\").setPort(1080)\n .setUsername(\"username\").setPassword(\"secret\"));\nHttpClient client = vertx.createHttpClient(options);\n\nDNS 解析会一直在代理服务器上执行。为了实现 SOCKS4 客户端的功能，需要先在本地解析 DNS 地址。\nVerticle 中自动清理\n如果您是在 Verticle 内部创建的 HTTP 服务端和客户端，则在撤销该Verticle时，它们将自动关闭。\n使用 Vert.x 共享数据\n共享数据（Shared Data）包含的功能允许您可以安全地在应用程序的不同部分之间、同一 Vert.x 实例中的不同应用程序之间或集群中的不同 Vert.x 实例之间安全地共享数据。\n共享数据包括本地共享Map、分布式、集群范围Map、异步集群范围锁和异步集群范围计数器。\n\n重要提示：分布式数据结构的行为取决于您使用的集群管理器，网络分区面临的备份（复制）和行为由集群管理器和它的配置来定义。请参阅集群管理器文档以及底层框架手册。\n\n本地共享Map\n本地共享Map LocalMap 允许您在同一个 Vert.x 实例中的不同 Event Loop（如不同的 Verticle 中）之间安全共享数据。\n本地共享Map仅允许将某些数据类型作为键值和值，这些类型必须是不可变的，或可以像Buffer那样复制某些其他类型。在后一种情况中，键/值将被复制，然后再放到Map中。\n这样，我们可以确保在Vert.x应用程序不同线程之间 没有共享访问可变状态，因此您不必担心需要通过同步访问来保护该状态。\n以下是使用 LocalMap 的示例：\nSharedData sd = vertx.sharedData();\n\nLocalMap map1 = sd.getLocalMap(\"mymap1\");\n\n// String是不可变的，所以不需要复制\nmap1.put(\"foo\", \"bar\"); // Strings are immutable so no need to copy\n\nLocalMap map2 = sd.getLocalMap(\"mymap2\");\n\n// Buffer将会在添加到Map之前拷贝\nmap2.put(\"eek\", Buffer.buffer().appendInt(123)); // This buffer will be copied before adding to map\n\n// Then... in another part of your application:\n// 之后，您的应用另外一部分\nmap1 = sd.getLocalMap(\"mymap1\");\n\nString val = map1.get(\"foo\");\n\nmap2 = sd.getLocalMap(\"mymap2\");\n\nBuffer buff = map2.get(\"eek\");\n\n集群范围异步Map\n集群范围异步Map(Cluster-wide asynchronous maps)允许从集群的任何节点将数据放到 Map 中，并从任何其他节点读取。\n这使得它们对于托管Vert.x Web应用程序的服务器场中的会话状态存储非常有用。\n您可以使用 getClusterWideMap 方法获取AsyncMap的实例。\n获取Map的过程是异步的，返回结果可以传给您指定的处理器中。以下是一个例子：\nSharedData sd = vertx.sharedData();\n\nsd.getClusterWideMap(\"mymap\", res -> {\n if (res.succeeded()) {\n AsyncMap map = res.result();\n } else {\n // Something went wrong!\n // 出现一些错误\n }\n});\n\n将数据放入Map\n您可以使用 put 方法将数据放入Map。put方法是异步的，一旦完成它会通知处理器：\nmap.put(\"foo\", \"bar\", resPut -> {\n if (resPut.succeeded()) {\n // Successfully put the value\n // 成功放入值\n } else {\n // Something went wrong!\n // 出了些问题\n }\n});\n\n从Map读取数据\n您可以使用 get 方法从Map读取数据。get 方法也是异步的，一段时间过后它会通知处理器并传入结果。\nmap.get(\"foo\", resGet -> {\n if (resGet.succeeded()) {\n // Successfully got the value\n // 成功读取值\n Object val = resGet.result();\n } else {\n // Something went wrong!\n // 出了些问题\n }\n});\n\n其他Map操作\n您还可以从异步Map中删除条目、清除Map、读取它的大小。\n有关更多信息，请参阅 API 文档。\n集群范围锁\n集群范围锁（Lock）允许您在集群中获取独占锁 —— 当您想要在任何时间只在集群一个节点上执行某些操作或访问资源时，这很有用。\n集群范围锁具有异步API，它和大多数等待锁释放的阻塞调用线程的API锁不相同。\n可使用 getLock 方法获取锁。\n它不会阻塞，但当锁可用时，将 Lock 的实例传入处理器并调用它，表示您现在拥有该锁。\n若您拥有的锁没有其他调用者，集群上的任何地方都可以获得该锁。\n当您用完锁后，您可以调用 release 方法来释放它，以便另一个调用者可获得它。\nsd.getLock(\"mylock\", res -> {\n if (res.succeeded()) {\n // Got the lock!\n // 获得锁\n Lock lock = res.result();\n\n // 5 seconds later we release the lock so someone else can get it\n // 5秒后我们释放该锁其他人可以得到它\n vertx.setTimer(5000, tid -> lock.release());\n\n } else {\n // Something went wrong\n // 出了些问题\n }\n});\n\n您可以为锁设置一个超时，若在超时时间期间无法获取锁，将会进入失败状态，处理器会去处理对应的异常：\nsd.getLockWithTimeout(\"mylock\", 10000, res -> {\n if (res.succeeded()) {\n // Got the lock!\n // 获得锁\n Lock lock = res.result();\n\n } else {\n // Failed to get lock\n // 锁获取失败\n }\n});\n\n集群范围计时器\n很多时候我们需要在集群范围内维护一个原子计数器。\n您可以用 Counter 来做到这一点。\n您可以通过 getCounter 方法获取一个实例：\nsd.getCounter(\"mycounter\", res -> {\n if (res.succeeded()) {\n Counter counter = res.result();\n } else {\n // Something went wrong!\n // 出了些问题\n }\n});\n\n一旦您有了一个实例，您可以获取当前的计数，以原子方式递增、递减，并使用各种方法添加一个值。\n有更多信息，请参阅 API 文档。\n访问文件系统\nVert.x 中的 FileSystem 对象提供了许多操作文件系统的方法。\n每个Vert.x 实例有一个文件系统对象，您可以使用 fileSystem 方法获取它。\n每个操作都提供了阻塞和非阻塞版本，其中非阻塞版本接受一个处理器 Handler，当操作完成或发生错误时调用该处理器。\n以下是文件异步拷贝的示例：\nFileSystem fs = vertx.fileSystem();\n\n// Copy file from foo.txt to bar.txt\n// 从foo.txt拷贝到bar.txt\nfs.copy(\"foo.txt\", \"bar.txt\", res -> {\n if (res.succeeded()) {\n // Copied ok!\n // 拷贝完成\n } else {\n // Something went wrong\n // 出了些问题\n }\n});\n\n阻塞版本的方法名为 xxxBlocking，它要么返回结果或直接抛出异常。很多情况下，一些潜在的阻塞操作可以快速返回（这取决于操作系统和文件系统），这就是我们为什么提供它。但是强烈建议您在 Event Loop 中使用它之前测试使用它们究竟需要耗费多长时间，以避免打破黄金法则。\n以下是使用阻塞 API的拷贝示例：\nFileSystem fs = vertx.fileSystem();\n\n// Copy file from foo.txt to bar.txt synchronously\n// 同步拷贝从foo.txt到bar.txt\nfs.copyBlocking(\"foo.txt\", \"bar.txt\");\n\nVert.x 文件系统支持诸如 copy、move、truncate、chmod 和许多其他文件操作。我们不会在这里列出所有内容，请参考 API 文档 获取完整列表。\n让我们看看使用异步方法的几个例子：\nVertx vertx = Vertx.vertx();\n\n// Read a file\n// 读取文件\nvertx.fileSystem().readFile(\"target/classes/readme.txt\", result -> {\n if (result.succeeded()) {\n System.out.println(result.result());\n } else {\n System.err.println(\"Oh oh ...\" + result.cause());\n }\n});\n\n// Copy a file\n// 拷贝文件\nvertx.fileSystem().copy(\"target/classes/readme.txt\", \"target/classes/readme2.txt\", result -> {\n if (result.succeeded()) {\n System.out.println(\"File copied\");\n } else {\n System.err.println(\"Oh oh ...\" + result.cause());\n }\n});\n\n// Write a file\n// 写文件\nvertx.fileSystem().writeFile(\"target/classes/hello.txt\", Buffer.buffer(\"Hello\"), result -> {\n if (result.succeeded()) {\n System.out.println(\"File written\");\n } else {\n System.err.println(\"Oh oh ...\" + result.cause());\n }\n});\n\n// Check existence and delete\n// 检测存在以及删除\nvertx.fileSystem().exists(\"target/classes/junk.txt\", result -> {\n if (result.succeeded() && result.result()) {\n vertx.fileSystem().delete(\"target/classes/junk.txt\", r -> {\n System.out.println(\"File deleted\");\n });\n } else {\n System.err.println(\"Oh oh ... - cannot delete the file: \" + result.cause());\n }\n});\n\n异步文件访问\nVert.x提供了异步文件访问的抽象，允许您操作文件系统上的文件。\n您可以像下边代码打开一个 AsyncFile ：\nOpenOptions options = new OpenOptions();\nfileSystem.open(\"myfile.txt\", options, res -> {\n if (res.succeeded()) {\n AsyncFile file = res.result();\n } else {\n // Something went wrong!\n // 出了些问题\n }\n});\n\nAsyncFile 实现了 ReadStream 和 WriteStream 接口，因此您可以将文件和其他流对象配合 泵 工作，如 NetSocket、HTTP 请求和响应和 WebSocket 等。\n它们还允许您直接读写。\n随机访问写\n要使用AsyncFile进行随机访问写，请使用 write 方法。\n这个方法的参数有：\n\nbuffer：要写入的缓冲\nposition：一个整数指定在文件中写入缓冲的位置，若位置大于或等于文件大小，文件将被扩展以适应偏移的位置\nhandler：结果处理器\n\n这是随机访问写的示例：\nVertx vertx = Vertx.vertx();\nvertx.fileSystem().open(\"target/classes/hello.txt\", new OpenOptions(), result -> {\n if (result.succeeded()) {\n AsyncFile file = result.result();\n Buffer buff = Buffer.buffer(\"foo\");\n for (int i = 0; i {\n if (ar.succeeded()) {\n System.out.println(\"Written ok!\");\n // etc\n // 等\n } else {\n System.err.println(\"Failed to write: \" + ar.cause());\n }\n });\n }\n } else {\n System.err.println(\"Cannot open file \" + result.cause());\n }\n});\n\n随机访问读\n要使用AsyncFile进行随机访问读，请使用 read 方法。\n该方法的参数有：\n\nbuffer：读取数据的 Buffer\noffset：读取数据将被放到 Buffer 中的偏移量\nposition：从文件中读取数据的位置\nlength：要读取的数据的字节数\nhandler：结果处理器\n\n一下是随机访问读的示例：\nVertx vertx = Vertx.vertx();\nvertx.fileSystem().open(\"target/classes/les_miserables.txt\", new OpenOptions(), result -> {\n if (result.succeeded()) {\n AsyncFile file = result.result();\n Buffer buff = Buffer.buffer(1000);\n for (int i = 0; i {\n if (ar.succeeded()) {\n System.out.println(\"Read ok!\");\n } else {\n System.err.println(\"Failed to write: \" + ar.cause());\n }\n });\n }\n } else {\n System.err.println(\"Cannot open file \" + result.cause());\n }\n});\n\n打开选项\n打开 AsyncFile 时，您可以传递一个 OpenOptions 实例，这些选项描述了访问文件的行为。例如：您可使用 setRead、setWrite 和 setPerm 方法配置文件访问权限。\n若打开的文件已经存在，则可以使用 setCreateNew 和 setTruncateExisting 配置对应行为。\n您可以使用 setDeleteOnClose 标记在关闭时或JVM停止时要删除的文件。\n将数据刷新到底层存储\n在 OpenOptions 中，您可以使用 setDsync 方法在每次写入时启用/禁用内容的自动同步。这种情况下，您可以使用 flush 方法手动刷新OS缓存中的数据写入。\n该方法也可使用一个处理器来调用，这个处理器在 flush 完成时被调用。\n将 AsyncFile 作为 ReadStream 和 WriteStream\nAsyncFile实现了 ReadStream 和 WriteStream 接口。您可以使用泵将数据与其他读取和写入流进行数据泵送。例如，这会将内容复制到另外一个AsyncFile：\nVertx vertx = Vertx.vertx();\nfinal AsyncFile output = vertx.fileSystem().openBlocking(\"target/classes/plagiary.txt\", new OpenOptions());\n\nvertx.fileSystem().open(\"target/classes/les_miserables.txt\", new OpenOptions(), result -> {\n if (result.succeeded()) {\n AsyncFile file = result.result();\n Pump.pump(file, output).start();\n file.endHandler((r) -> {\n System.out.println(\"Copy done\");\n });\n } else {\n System.err.println(\"Cannot open file \" + result.cause());\n }\n});\n\n您还可以使用泵将文件内容写入到HTTP 响应中，或者写入任意 WriteStream。\n从 Classpath 访问文件\n当Vert.x找不到文件系统上的文件时，它尝试从类路径中解析该文件。请注意，类路径的资源路径不以 / 开头。\n由于Java不提供对类路径资源的异步方法，所以当类路径资源第一次被访问时，该文件将复制到工作线程中的文件系统。当第二次访问相同资源时，访问的文件直接从（工作线程的）文件系统提供。即使类路径资源发生变化（例如开发系统中），也会提供原始内容。\n您可以将系统属性vertx.disableFileCaching设置为true，禁用此（文件）缓存行为。文件缓存的路径默认为.vertx，它可以通过设置系统属性vertx.cacheDirBase进行自定义。\n您还可以通过系统属性vertx.disableFileCPResolving设置为true来禁用整个类路径解析功能。\n\n请注意：当加载io.vertx.core.impl.FileResolver类时，这些系统属性将被评估一次，因此，在加载此类之前应该设置这些属性，或者在启动它时作为JVM系统属性来设置。\n\n关闭 AsyncFile\n您可调用 close 方法来关闭 AsyncFile。关闭是异步的，如果希望在关闭过后收到通知，您可指定一个处理器作为函数（close）参数传入。\n数据报套接字（UDP）\n在Vert.x中使用用户数据报协议（UDP）就是小菜一碟。\nUDP是无连接的传输，这意味着您与远程客户端没有建立持续的连接。\n所以，您发送和接收的数据包都要包含有远程的地址。\n除此之外，UDP不像TCP的使用那样安全，这也就意味着不能保证发送的数据包一定会被对应的接收端（Endpoint）接收。\n唯一的保证是，它既不会被完全接收到，也不会完全不被接收到，即只有部分会被接收到。\n因为每一个数据包将会作为一个包发送，所以在通常情况下您不能发送大于网络接口的最大传输单元（MTU）的数据包。\n但是要注意，即使数据包尺寸小于MTU，它仍然可能会发送失败。\n它失败的尺寸取决于操作系统等（其他原因），所以按照经验法则就是尝试发送小数据包。\n依照UDP的本质，它最适合一些允许丢弃数据包的应用（如监视应用程序）。\n其优点是与TCP相比具有更少的开销，而且可以由NetServer和NetClient处理（参考前文）。\n创建 DatagramSocket\n要使用UDP，您首先要创建一个 DatagramSocket 实例，无论您是要仅仅发送数据或者收发数据，这都是一样的。\nDatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions());\n\n返回的 DatagramSocket 实例不会绑定到特定端口，如果您只想发送数据（如作为客户端）的话，这是没问题的，但更多详细的内容在下一节。\n发送数据报包\n如上所述，用户数据报协议（UDP）将数据分组发送给远程对等体，但是以不持续的方式来传送到它们。\n这意味着每个数据包都可以发送到不同的远程对等体。\n发送数据包很容易，如下所示：\nDatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions());\nBuffer buffer = Buffer.buffer(\"content\");\n// 发送Buffer\nsocket.send(buffer, 1234, \"10.0.0.1\", asyncResult -> {\n System.out.println(\"Send succeeded? \" + asyncResult.succeeded());\n});\n// 发送一个字符串\nsocket.send(\"A string used as content\", 1234, \"10.0.0.1\", asyncResult -> {\n System.out.println(\"Send succeeded? \" + asyncResult.succeeded());\n});\n\n接收数据报包\n若您想要接收数据包，则您需要调用 listen(...) 方法绑定 DatagramSocket。\n这样您就可以接收到被发送至 DatagramSocket 所监听的地址和端口的 DatagramPacket。\n除此之外，您还要设置一个Handler，每接收到一个 DatagramPacket 时它都会被调用。\nDatagramPacket 有以下方法：\n\nsender：表示数据发送方的InetSocketAddress。\ndata：保存接收数据的Buffer。\n\n当您需要监听一个特定地址和端口时，您可以像下边这样：\nDatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions());\nsocket.listen(1234, \"0.0.0.0\", asyncResult -> {\n if (asyncResult.succeeded()) {\n socket.handler(packet -> { \n // 对包进行处理\n });\n } else {\n System.out.println(\"Listen failed\" + asyncResult.cause());\n }\n});\n\n注意，即使 AsyncResult 成功，它只意味着它可能已经写入了网络堆栈，但不保证它已经到达或者将到达远端。\n若您需要这样的保证，您可在TCP之上建立一些握手逻辑。\n多播\n发送多播数据包\n多播允许多个Socket接收相同的数据包，该目标可以通过加入到同一个可发送数据包的多播组来实现。\n我们将在下一节中介绍如何加入多播组，从而接收数据包。\n现在让我们专注于如何发送多播报文，发送多播报文与发送普通数据报报文没什么不同。\n唯一的区别是您可以将多播组的地址传递给 send 方法发送出去。\n如下所示：\nDatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions());\nBuffer buffer = Buffer.buffer(\"content\");\n// Send a Buffer to a multicast address\n// 发送Buffer到多播地址\nsocket.send(buffer, 1234, \"230.0.0.1\", asyncResult -> {\n System.out.println(\"Send succeeded? \" + asyncResult.succeeded());\n});\n\n所有已经加入多播组 230.0.0.1 的Socket都将收到该报文。\n接收多播数据包\n若要接收特定多播组的数据包，您需要通过调用 DatagramSocket 的listen(...)方法来绑定一个地址并且加入多播组，并加入多播组。\n这样，您将能够接收到被发送到 DatagramSocket 所监听的地址和端口的数据报，同时也可以接收被发送到该多播组的数据报。\n除此之外，您还可设置一个处理器，它在每次接收到 DatagramPacket 时会被调用。\nDatagramPacket 有以下方法：\n\nsender()：表示数据报发送方的InetSocketAddress\ndata()：保存接收数据的Buffer\n\n因此，要监听指定的地址和端口、并且接收多播组230.0.0.1的数据报，您将执行如下操作：\nDatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions());\nsocket.listen(1234, \"0.0.0.0\", asyncResult -> {\n if (asyncResult.succeeded()) {\n socket.handler(packet -> { \n // 对数据包进行处理\n });\n\n // 加入多播组\n socket.listenMulticastGroup(\"230.0.0.1\", asyncResult2 -> {\n System.out.println(\"Listen succeeded? \" + asyncResult2.succeeded());\n });\n } else {\n System.out.println(\"Listen failed\" + asyncResult.cause());\n }\n});\n\n取消订阅/离开多播组\n有时候您想只在特定时间内接收多播组的数据包。\n这种情况下，您可以先监听他们，之后再取消监听。\n如下所示：\nDatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions());\nsocket.listen(1234, \"0.0.0.0\", asyncResult -> {\n if (asyncResult.succeeded()) {\n socket.handler(packet -> {\n // Do something with the packet\n // 处理数据报\n });\n\n // join the multicast group\n // 加入多播组\n socket.listenMulticastGroup(\"230.0.0.1\", asyncResult2 -> {\n if (asyncResult2.succeeded()) {\n // will now receive packets for group\n // 现在将接收组的数据包\n // do some work\n // 做一些工作\n socket.unlistenMulticastGroup(\"230.0.0.1\", asyncResult3 -> {\n System.out.println(\"Unlisten succeeded? \" + asyncResult3.succeeded());\n });\n } else {\n System.out.println(\"Listen failed\" + asyncResult2.cause());\n }\n });\n } else {\n System.out.println(\"Listen failed\" + asyncResult.cause());\n }\n});\n\n屏蔽多播\n除了取消监听一个多播地址以外，也可以做到屏蔽指定发送者地址的多播。\n请注意这仅适用于某些操作系统和内核版本，所以请检查操作系统文档看是它是否支持。\n这是专家级别的技巧。\n要屏蔽来自特定地址的多播，您可以在 DatagramSocket 上调用 blockMulticastGroup(...)，如下所示：\nDatagramSocket socket = vertx.createDatagramSocket(new DatagramSocketOptions());\n\n// Some code\n// 一些代码\n\n// This would block packets which are send from 10.0.0.2\n// 这将阻止从10.0.0.2发送的数据包\nsocket.blockMulticastGroup(\"230.0.0.1\", \"10.0.0.2\", asyncResult -> {\n System.out.println(\"block succeeded? \" + asyncResult.succeeded());\n});\n\nDatagramSocket 属性\n当创建DatagramSocket时，您可以通过DatagramSocketOptions对象来设置多个属性以更改它的功能。这些（属性）列在这儿：\n\nsetSendBufferSize以字节为单位设置发送缓冲区的大小。\nsetReceiveBufferSize设置TCP接收缓冲区大小（以字节为单位）。\nsetReuseAddress若为true，则TIME_WAIT状态中的地址在关闭后可重用。\nsetTrafficClass\nsetBroadcast设置或清除SO_BROADCAST套接字选项，设置此选项时，数据报（UDP）数据包可能会发送到本地接口的广播地址。\nsetMulticastNetworkInterface设置或清除IP_MULTICAST_LOOP套接字选项，设置此选项时，多播数据包也将在本地接口上接收。\nsetMulticastTimeToLive设置IP_MULTICAST_TTL套接字选项。TTL表示“活动时间”，单这种情况下，它指定允许数据包经过的IP跳数，特别是用于多播流量。转发数据包的每个路由器或网管会递减TTL，如果路由器将TTL递减为0，则不会再转发。\n\nDatagramSocket本地地址\n若您在调用listen(...)之前已经绑定了DatagramSocket，您可以通过调用localAddress来查找套接字的本地地址（即UDP Socket这边的地址，它将返回一个InetSocketAddress，否则返回null。\n关闭DatagramSocket\n您可以通过调用close方法来关闭Socket，它将关闭Socket并释放所有资源。\nDNS 客户端\n通常情况下，您需要以异步方式来获取DNS信息。\n但不幸的是，Java 虚拟机本身附带的API是不可能的，因此Vert.x提供了它自己的完全异步解析DNS的API。\n若要获取 DnsClient 实例，您可以通过 Vertx 实例来创建一个。\nDnsClient client = vertx.createDnsClient(53, \"10.0.0.1\");\n\n请注意，您可以传入 InetSocketAddress 参数的变量，以指定多个的DNS服务器来尝试查询解析DNS。它将按照此处指定的相同顺序查询DNS服务器，若在使用上一个DNS服务器解析时出现了错误，下一个将会被继续调用。\nlookup\n当尝试为一个指定名称元素获取A（ipv4）或 AAAA（ipv6）记录时，第一条被返回的（记录）将会被使用。它的操作方式和操作系统上使用 nslookup 类似。\n要为 vertx.io 获取 A/AAAA 记录，您需要像下面那样做：\nDnsClient client = vertx.createDnsClient(53, \"10.0.0.1\");\nclient.lookup(\"vertx.io\", ar -> {\n if (ar.succeeded()) {\n System.out.println(ar.result());\n } else {\n System.out.println(\"Failed to resolve entry\" + ar.cause());\n }\n});\n\nlookup4\n尝试查找给定名称的A（ipv4）记录。第一个返回的（记录）将会被使用，因此它的操作方式与操作系统上使用nslookup类似。\n要查找 vertx.io 的A记录，您需要像下面那样做：\nDnsClient client = vertx.createDnsClient(53, \"10.0.0.1\");\nclient.lookup4(\"vertx.io\", ar -> {\n if (ar.succeeded()) {\n System.out.println(ar.result());\n } else {\n System.out.println(\"Failed to resolve entry\" + ar.cause());\n }\n});\n\nlookup6\n尝试查找给定名称的 AAAA（ipv6）记录。第一个返回的（记录）将会被使用，因此它的操作方式与在操作系统上使用 nslookup 类似。\n要查找 vertx.io 的 AAAA记录，您需要像下面那样做：\nDnsClient client = vertx.createDnsClient(53, \"10.0.0.1\");\nclient.lookup6(\"vertx.io\", ar -> {\n if (ar.succeeded()) {\n System.out.println(ar.result());\n } else {\n System.out.println(\"Failed to resolve entry\" + ar.cause());\n }\n});\n\nresolveA\n尝试解析给定名称的所有A（ipv4）记录，这与在unix操作系统上使用dig类似。\n要查找vertx.io的所有A记录，您通常会执行以下操作：\nDnsClient client = vertx.createDnsClient(53, \"10.0.0.1\");\nclient.resolveA(\"vertx.io\", ar -> {\n if (ar.succeeded()) {\n List records = ar.result();\n for (String record : records) {\n System.out.println(record);\n }\n } else {\n System.out.println(\"Failed to resolve entry\" + ar.cause());\n }\n});\n\nresolveAAAA\n尝试解析给定名称的所有AAAA（ipv6）记录，这与在Unix操作系统上使用dig类似。\n要查找vertx.io的所有AAAA记录，您通常会执行以下操作：\nDnsClient client = vertx.createDnsClient(53, \"10.0.0.1\");\nclient.resolveAAAA(\"vertx.io\", ar -> {\n if (ar.succeeded()) {\n List records = ar.result();\n for (String record : records) {\n System.out.println(record);\n }\n } else {\n System.out.println(\"Failed to resolve entry\" + ar.cause());\n }\n});\n\nresolveCNAME\n尝试解析给定名称的所有CNAME记录，这与在Unix操作系统上使用dig类似。\n要查找vertx.io的所有CNAME记录，您通常会执行以下操作：\nDnsClient client = vertx.createDnsClient(53, \"10.0.0.1\");\nclient.resolveCNAME(\"vertx.io\", ar -> {\n if (ar.succeeded()) {\n List records = ar.result();\n for (String record : records) {\n System.out.println(record);\n }\n } else {\n System.out.println(\"Failed to resolve entry\" + ar.cause());\n }\n});\n\nresolveMX\n尝试解析给定名称的所有MX记录，MX记录用于定义哪个邮件服务器接受给定域的电子邮件。\n要查找您常用执行的vertx.io的所有MX记录：\nDnsClient client = vertx.createDnsClient(53, \"10.0.0.1\");\nclient.resolveMX(\"vertx.io\", ar -> {\n if (ar.succeeded()) {\n List records = ar.result();\n for (MxRecord record: records) {\n System.out.println(record);\n }\n } else {\n System.out.println(\"Failed to resolve entry\" + ar.cause());\n }\n});\n\n请注意，列表将包含按照它们优先级排序的MxRecord，这意味着列表中优先级低的MX记录会第一个优先出现在列表中。\nMxRecord允许您通过下边提供的方法访问MX记录的优先级和名称：\nrecord.priority();\nrecord.name();\n\nresolveTXT\n尝试解析给定名称的所有TXT记录，TXT记录通常用于定义域的额外信息。\n要解析vertx.io的所有TXT记录，您可以使用下边几行：\nDnsClient client = vertx.createDnsClient(53, \"10.0.0.1\");\nclient.resolveTXT(\"vertx.io\", ar -> {\n if (ar.succeeded()) {\n List records = ar.result();\n for (String record: records) {\n System.out.println(record);\n }\n } else {\n System.out.println(\"Failed to resolve entry\" + ar.cause());\n }\n});\n\nresolveNS\n尝试解析给定名称的所有NS记录，NS记录指定哪个DNS服务器托管给定域的DNS信息。\n要解析vertx.io的所有NS记录，您可以使用下边几行：\nDnsClient client = vertx.createDnsClient(53, \"10.0.0.1\");\nclient.resolveNS(\"vertx.io\", ar -> {\n if (ar.succeeded()) {\n List records = ar.result();\n for (String record: records) {\n System.out.println(record);\n }\n } else {\n System.out.println(\"Failed to resolve entry\" + ar.cause());\n }\n});\n\nresolveSRV\n尝试解析给定名称的所有SRV记录，SRV记录用于定义服务端口和主机名等额外信息。一些协议需要这个额外信息。\n要查找vertx.io的所有SRV记录，您通常会执行以下操作：\nDnsClient client = vertx.createDnsClient(53, \"10.0.0.1\");\nclient.resolveSRV(\"vertx.io\", ar -> {\n if (ar.succeeded()) {\n List records = ar.result();\n for (SrvRecord record: records) {\n System.out.println(record);\n }\n } else {\n System.out.println(\"Failed to resolve entry\" + ar.cause());\n }\n});\n\n请注意，列表将包含按照它们优先级排序的SrvRecord，这意味着优先级低的记录会第一个优先出现在列表中。\nSrvRecord允许您访问SRV记录本身中包含的所有信息：\nrecord.priority();\nrecord.name();\nrecord.weight();\nrecord.port();\nrecord.protocol();\nrecord.service();\nrecord.target();\n\n有关详细信息，请参阅API文档。\nresolvePTR\n尝试解析给定名称的PTR记录，PTR记录将ipaddress映射到名称。\n要解析IP地址10.0.0.1的PTR记录，您将使用1.0.0.10.in-addr.arpa的PTR概念。\nDnsClient client = vertx.createDnsClient(53, \"10.0.0.1\");\nclient.resolvePTR(\"1.0.0.10.in-addr.arpa\", ar -> {\n if (ar.succeeded()) {\n String record = ar.result();\n System.out.println(record);\n } else {\n System.out.println(\"Failed to resolve entry\" + ar.cause());\n }\n});\n\nreverseLookup\n尝试对ipaddress进行反向查找，这与解析PTR记录类似，但是允许您只传递ipaddress，而不是有效的PTR查询字符串。\n要做ipaddress 10.0.0.1的反向查找类似的事：\nDnsClient client = vertx.createDnsClient(53, \"10.0.0.1\");\nclient.reverseLookup(\"10.0.0.1\", ar -> {\n if (ar.succeeded()) {\n String record = ar.result();\n System.out.println(record);\n } else {\n System.out.println(\"Failed to resolve entry\" + ar.cause());\n }\n});\n\n错误处理\n如前边部分所述，DnsClient 允许您传递一个Handler，一旦查询完成将会传入一个AsyncResult给Handler并通知它。\n在出现错误的情况下，通知中将包含一个DnsException，该异常会包含一个说明为何失败的DnsResponseCode。此DnsResponseCode可用于更详细检查原因。\n可能的DnsResponseCode值是：\n\nNOERROR 没有找到给定查询的记录\nFORMERROR 格式错误\nSERVFAIL 服务器故障\nNXDOMAIN 名称错误\nNOTIMPL DNS 服务器没实现\nREFUSED DNS 服务器拒绝查询\nYXDOMAIN 域名不应该存在\nYXRESET 资源记录不应该存在\nNXRRSET RRSET不存在\nNOTZONE 名称不在区域内\nBADVERS 版本的扩展机制不好\nBADSIG 非法签名\nBADKEY 非法密钥\nBADTIME 错误时间戳\n\n所有这些错误都由DNS服务器本身“生成”，您可以从 DnsException 中获取 DnsResponseCode，如：\nDnsClient client = vertx.createDnsClient(53, \"10.0.0.1\");\nclient.lookup(\"nonexisting.vert.xio\", ar -> {\n if (ar.succeeded()) {\n String record = ar.result();\n System.out.println(record);\n } else {\n Throwable cause = ar.cause();\n if (cause instanceof DnsException) {\n DnsException exception = (DnsException) cause;\n DnsResponseCode code = exception.code();\n // ...\n } else {\n System.out.println(\"Failed to resolve entry\" + ar.cause());\n }\n }\n});\n\n流\nVert.x有多个对象可以用于文件的读取和写入。\n在以前的版本中，只能通过操作指定的 Buffer 对象来实现文件读写。从现在开始，流不再与 Buffer 耦合，它们可以和任意类型的对象一起工作。\n在 Vert.x 中，写调用是立即返回的，而写操作的实际是在内部队列中排队写入。\n不难看出，若写入对象的速度比实际写入底层数据资源速度快，那么写入队列就会无限增长，最终导致内存耗尽。\n为了解决这个问题，Vert.x API中的一些对象提供了简单的流程控制（回压）功能。\n任何可控制的写入流对象都实现了 WriteStream 接口，相应的，任何可控制的读取流对象都实现了 ReadStream 接口。\n让我们举个例子，我们要从ReadStream中读取数据，然后将数据写入WriteStream。\n一个非常简单的例子是从NetSocket读取然后写回到同一个NetSocket —— 因为NetSocket既实现了ReadStream也实现了WriteStream 接口。请注意，这些操作适用于任何实现了ReadStream和 WriteStream 接口的对象，包括HTTP 请求、HTTP 响应、异步文件 I/O 和 WebSocket等。\n一个最简单的方法是直接获取已经读取的数据，并立即将其写入NetSocket：\nNetServer server = vertx.createNetServer(\n new NetServerOptions().setPort(1234).setHost(\"localhost\")\n);\nserver.connectHandler(sock -> {\n sock.handler(buffer -> {\n // Write the data straight back\n // 直接写入数据\n sock.write(buffer);\n });\n}).listen();\n\n上面的例子有一个问题：如果从Socket读取数据的速度比写回Socket的速度快，那么它将在NetSocket的写队列中不断堆积，最终耗尽内存。这是有可能会发生，例如，若Socket另一端的客户端读取速度不够快，无法快速地向连接的另一端回压。\n由于 NetSocket 实现了 WriteStream 接口，我们可以在写入之前检查 WriteStream 是否已满：\nNetServer server = vertx.createNetServer(\n new NetServerOptions().setPort(1234).setHost(\"localhost\")\n);\nserver.connectHandler(sock -> {\n sock.handler(buffer -> {\n if (!sock.writeQueueFull()) {\n sock.write(buffer);\n }\n });\n\n}).listen();\n\n这个例子不会耗尽内存，但如果写入队列已满，我们最终会丢失数据。我们真正想要做的是在写入队列已满时暂停读取 NetSocket：\nNetServer server = vertx.createNetServer(\n new NetServerOptions().setPort(1234).setHost(\"localhost\")\n);\nserver.connectHandler(sock -> {\n sock.handler(buffer -> {\n sock.write(buffer);\n if (sock.writeQueueFull()) {\n sock.pause();\n }\n });\n}).listen();\n\n我们已经快达到我们的目标，但还没有完全实现。现在 NetSocket 在文件已满时会暂停，但是当写队列处理完成时，我们需要取消暂停：\nNetServer server = vertx.createNetServer(\n new NetServerOptions().setPort(1234).setHost(\"localhost\")\n);\nserver.connectHandler(sock -> {\n sock.handler(buffer -> {\n sock.write(buffer);\n if (sock.writeQueueFull()) {\n sock.pause();\n sock.drainHandler(done -> {\n sock.resume();\n });\n }\n });\n}).listen();\n\n在这里，我们的目标实现了。当写队列准备好接收更多的数据时，drainHandler事件处理器将被调用，它会恢复NetSocket的状态，允许读取更多的数据。\n在编写Vert.x 应用程序时，这样做是很常见的，因此我们提供了一个名为Pump的帮助类，它为您完成所有这些艰苦的工作。您只需要给 ReadStream 追加上 WriteStream，然后启动它：\nNetServer server = vertx.createNetServer(\n new NetServerOptions().setPort(1234).setHost(\"localhost\")\n);\nserver.connectHandler(sock -> {\n Pump.pump(sock, sock).start();\n}).listen();\n\n这和更加详细的例子完全一样。\n现在我们来看看 ReadStream 和 WriteStream 的方法。\nReadStream\nReadStream（可读流） 接口的实现类包括：HttpClientResponse, DatagramSocket, HttpClientRequest, HttpServerFileUpload, HttpServerRequest, MessageConsumer, NetSocket, WebSocket, TimeoutStream, AsyncFile。\n函数：\n\nhandler：设置一个处理器，它将从ReadStream读取项\npause：暂停处理器，暂停时，处理器中将不会受到任何项\nresume：恢复处理器，若任何项到达则处理器将被调用\nexceptionHandler若ReadStream发生异常，将被调用\nendHandler：当流到达时将被调用。这有可能是到达了描述文件的EOF、达到HTTP请求的请求结束、或TCP Socket的连接被关闭\n\nWriteStream\nWriteStream（可写流）接口的实现类包括：HttpClientRequest, HttpServerResponse，WebSocket, NetSocket, AsyncFile, MessageProducer\n函数：\n\nwrite：写入一个对象到 WriteStream，该方法将永远不会阻塞，内部是排队写入并且底层资源是异步写入。\nsetWriteQueueMaxSize：设置写入队列被认为是 full 的对象的数量——方法writeQueueFull返回true。注意，当写队列被认为已满时，若写（操作）被调用则数据依然会被接收和排队。实际数量取决于流的实现，对于Buffer，尺寸代表实际写入的字节数，而并非缓冲区的数量。\nwriteQueueFull：若写队列被认为已满，则返回true。\nexceptionHandler：若WriteStream发生异常，则被调用。\ndrainHandler：若WriteStream被认为不再满，则处理器将被调用。\n\n泵\n泵（Pump）的实例有以下几种方法：\n\nstart：启动泵。\nstop：停止泵，当泵启动时它要处于停止模式。\nsetWriteQueueMaxSize：与 WriteStream 接口的 setWriteQueueMaxSize 方法相同。\n\n一个泵可以启动和停止多次。\n当泵首次创建时，它不会启动，您需要调用 start() 方法来启动它。\n记录解析器\n记录解析器（Record Parser）允许您轻松解析由字节序列或固定尺寸带分隔符的记录的协议。\n它将输入缓冲区序列转换为已配置的缓冲区序列（固定大小或带分隔符的记录）。\n例如，若您使用\\n分割的简单ASCII文本协议，并输入如下：\nbuffer1:HELLO\\nHOW ARE Y\nbuffer2:OU?\\nI AM\nbuffer3: DOING OK\nbuffer4:\\n\n记录解析器将生成下结果：\nbuffer1:HELLO\nbuffer2:HOW ARE YOU?\nbuffer3:I AM DOING OK\n我们来看看相关代码：\nfinal RecordParser parser = RecordParser.newDelimited(\"\\n\", h -> {\n System.out.println(h.toString());\n});\n\nparser.handle(Buffer.buffer(\"HELLO\\nHOW ARE Y\"));\nparser.handle(Buffer.buffer(\"OU?\\nI AM\"));\nparser.handle(Buffer.buffer(\"DOING OK\"));\nparser.handle(Buffer.buffer(\"\\n\"));\n\n我们还可以生成固定尺寸的块，如下：\nRecordParser.newFixed(4, h -> {\n System.out.println(h.toString());\n});\n\n有关更多详细信息，请查看RecordParser类。\n线程安全\n大多数Vert.x 对象可以从被不同的线程安全地访问，但在相同的上下文中访问它们时，性能才是最优的。\n例如，若您部署了一个创建NetServer的Verticle，该NetServer在处理器中提供了NetSocket 实例，则最好始终从该Verticle的Event Loop中访问Socket 实例。\n如您坚持使用标准的Vert.x Verticle部署模型，避免在 Verticle 之间分享对象，那这种情况您无需考虑。\nMetrics SPI\n默认情况下，Vert.x不会记录任何指标。相反，它为其他人提供了一个SPI，可以将其添加到类路径中。SPI是一项高级功能，允许实施者从Vert.x捕获事件以收集指标。有关详细信息，请参阅 API 文档。\n若使用setFactory嵌入了Vert.x实例，也可以用编程方式指定度量工厂。\nOSGi\nVert.x Core被打包成了 OSGi Bundle，因此可以在任何OSGi R4.2+环境中使用，如 Apache Felix 或 Eclipse Equinox，（这个）Bundle导出io.vertx.core*。\n但是 Bundle 对 Jackson 和 Netty 有一些依赖，若部署Vert.x Core Bundle则需要：\n\nJackson Annotation [2.6.0,3)\nJackson Core [2.6.2,3)\nJackson Databind [2.6.2,3)\nNetty Buffer [4.0.31,5)\nNetty Codec [4.0.31,5)\nNetty Codec/Socks [4.0.31,5)\nNetty Codec/Common [4.0.31,5)\nNetty Codec/Handler [4.0.31,5)\nNetty Codec/Transport [4.0.31,5)\n\n下边是Apache Felix 5.2.0上的工作部署：\n14|Active | 1|Jackson-annotations (2.6.0)\n15|Active | 1|Jackson-core (2.6.2)\n16|Active | 1|jackson-databind (2.6.2)\n18|Active | 1|Netty/Buffer (4.0.31.Final)\n19|Active | 1|Netty/Codec (4.0.31.Final)\n20|Active | 1|Netty/Codec/HTTP (4.0.31.Final)\n21|Active | 1|Netty/Codec/Socks (4.0.31.Final)\n22|Active | 1|Netty/Common (4.0.31.Final)\n23|Active | 1|Netty/Handler (4.0.31.Final)\n24|Active | 1|Netty/Transport (4.0.31.Final)\n25|Active | 1|Netty/Transport/SCTP (4.0.31.Final)\n26|Active | 1|Vert.x Core (3.1.0)\n在Equinox上，您可能需要使用下边的框架属性禁用ContextFilter：eclipse.bundle.setTCCL=false。\nvertx 命令行\nvertx 命令行工具用于在终端中与 Vert.x 进行交互。主要用于运行 Vert.x Verticle。为此，您需要下载并安装Vert.x 发行版，并将安装目录中的bin添加到PATH环境变量中，还要确保您的PATH上有一个Java 8的JDK。\n\n请注意：JDK需要支持Java代码的快速编译。\n\n运行 Verticle\n您可以使用 vertx run 从命令行直接运行Vert.x 的 Verticle，以下是run命令的几个实例：\nvertx run my-verticle.js (1)\nvertx run my-verticle.groovy (2)\nvertx run my-verticle.rb (3)\n\nvertx run io.vertx.example.MyVerticle (4)\nvertx run io.vertx.example.MVerticle -cp my-verticle.jar (5)\n\nvertx run MyVerticle.java (6)\n\n部署一个JavaScript的Verticle\n部署一个Groovy的Verticle\n部署一个Ruby的Verticle\n部署一个已经编译好的Java的Verticle，类的根路径是当前目录\n部署一个已经打包成jar的Verticle，这个jar需要在类路径中\n编译Java源代码并进行部署\n\n正如您在Java中可看到的，该Verticle的名称要么是Java 完全限定类名，也可以指定Java 源文件，Vert.x会为你编译它。\n您可以用其他语言的前缀来指定Verticle的名称进行部署。例如：若Verticle是一个编译的Groovy 类，您可以使用语言前缀groovy:，因此Vert.x 知道它是一个Groovy 类而不是Java 类。\nvertx run groovy:io.vertx.example.MyGroovyVerticle\nvertx run命令可以使用几个可选参数，它们是：\n\n-conf ：提供了Verticle的一些配置，config_file是包含描述Verticle配置的JSON对象的文本文件的名称，该参数是可选的。\n-cp ：搜索Verticle和它使用的其他任何资源的路径，默认为.（当前目录）。若您的Verticle引用了其他脚本、类或其他资源（例如jar文件），请确保这些脚本、其他资源存在此路径上。该路径可以包含由以下内容分隔的多个路径条目：:（冒号）或;（分号）——这取决于操作系统。每个路径条目可以是包含脚本的目录的绝对路径或相对路径，也可以是jar或zip文件的绝对或相对文件名。一个示例路径可能是-cp classes:lib/otherscripts:jars/myjar.jar:jars/otherjar.jar。始终使用路径引用您的Verticle需要的任何资源，不要将它们放在系统类路径上，因为这会导致部署的Verticle之间的隔离问题。\n-instances ：要实例化的Verticle实例的数目，每个Verticle实例都是严格单线程（运行）的，以便在可用的核上扩展应用程序，您可能需要部署多个实例。若省略，则部署单个实例。\n-worker：此选项可确定一个Verticle是否为Worker Verticle。\n-cluster：此选项确定Vert.x实例是否尝试与网络上的其他Vert.x实例形成集群，集群Vert.x实例允许Vert.x与其他节点形成分布式Event Bus。默认为false（非集群模式）。\n-cluster-port：若指定了cluster选项，则可以确定哪个端口将用于与其他Vert.x实例进行集群通信。默认为0——这意味着“选择一个空闲的随机端口”。除非您帧需要绑定特定端口，您通常不需要指定此参数。\n-cluster-host：若指定了cluster选项，则可以确定哪个主机地址将用于其他Vert.x实例进行集群通信。默认情况下，它将尝试从可用的接口中选一个。若您有多个接口而您想要使用指定的一个，就在这里指定。\n-ha：若指定，该Verticle将部署为（支持）高可用性（HA）。有关详细信息，请参阅相关章节。\n-quorum：该参数需要和-ha一起使用，它指定集群中所有HA部署ID处于活动状态的最小节点数，默认为0。\n-hagroup：该参数需要和-ha一起使用，它指定此节点将加入的HA组。集群中可以有多个HA组，节点只会故障转移到同一组中的其他节点。默认为__DEFAULT__。\n\n您还可以使用下边方式设置系统属性：-Dkey=value。\n下面有更多的例子：\n使用默认设置运行JavaScript的Verticle：server.js：\nvertx run server.js\n运行指定类路径的预编译好的10个Java Verticle实例\nvertx run com.acme.MyVerticle -cp \"classes:lib/myjar.jar\" -instances 10\n通过源文件运行10个Java Verticle的实例\nvertx run MyVerticle.java -instances 10\n运行20个Ruby语言的Worker Verticle实例\nvertx run order_worker.rb -instances 20 -worker\n在同一台计算机上运行两个JavaScript Verticle，并让它们彼此在网络上的其他任何服务器上集群在一起：\nvertx run handler.js -cluster\nvertx run sender.js -cluster\n运行一个Ruby Verticle并传入一些配置：\nvertx run my_verticle.rb -conf my_verticle.conf\n其中my_verticle.conf也许会包含以下配置：\n{\n \"name\": \"foo\",\n \"num_widgets\": 46\n}\n\n该配置可通过Core API在Verticle内部可用。\n当使用Vert.x的高可用功能时，您可能需要创建一个Vert.x的 裸 实例。此实例在启动时未部署任何Verticle，但它若接收到若集群中的另一个节点死亡，则会在此节点运行之前挂掉的实例。如需要创建一个 裸 实例，执行以下命令：\nvertx bare\n根据您的集群配置，您可能需要添加cluster-host和cluster-port参数。\n执行打包成 fat-jar 的Vert.x 应用\nfat-jar 是一个包含了所有依赖项jar的可执行的jar，这意味着您不必在执行jar的机器上预先安装Vert.x。它像任何可执行的Java jar一样可直接执行：\njava -jar my-application-fat.jar\n对于这点，Vert.x 没什么特别的，您可以使用任何Java应用程序。\n您可以创建自己的主类并在 MANIFEST 中指定，但建议您将代码编写成Verticle，并使用Vert.x中的Launcher类（io.vertx.core.Launcher）作为您的主类。这是在命令行中运行Vert.x使用的主类，因此允许您指定命令行参数，如 -instances 以便更轻松地扩展应用程序。\n要将您的Verticle全部部署在这个fat-jar中时，您必须将下边信息写入MANIFEST：\n\nMain-Class设置为io.vertx.core.Launcher\nMain-Verticle指定要运行的Main Verticle（Java完全限定类名或脚本文件名）\n\n您还可以提供您将传递给 vertx run 的常用命令行参数：\njava -jar my-verticle-fat.jar -cluster -conf myconf.json\njava -jar my-verticle-fat.jar -cluster -conf myconf.json -cp path/to/dir/conf/cluster_xml\n\n注意：请参阅官方 Vert.x Examples 仓库中中的 Maven/Gradle 相应示例来了解如何将应用打包成 fat-jar。\n\n通过 fat jar 运行应用时，默认会执行 run 命令。\n显示Vert.x的版本\n若想显示Vert.x的版本，只需执行：\nvertx version\n其他命令\n除了run和version以外，vertx命令行和 Launcher 还提供了其他命令：\n您可以使用下边命令创建一个bare实例：\nvertx bare\n# or\njava -jar my-verticle-fat.jar bare\n您还可以在后台启动应用程序：\njava -jar my-verticle-fat.jar start -Dvertx-id=my-app-name\n若my-app-name未设置，将生成一个随机的id，并在命令提示符中打印。您可以将run选项传递给start命令：\njava -jar my-verticle-fat.jar start -Dvertx-id=my-app-name -cluster\n一旦在后台启动，可以使用stop命令停止它：\njava -jar my-verticle-fat.jar stop my-app-name\n您还可以使用一下方式列出后台启动的Vert.x应用程序：\njava -jar my-verticle-fat.jar list\nvertx工具也可以使用start、stop和list命令，start命令支持几个选项：\n\nvertx-id：应用程序ID，若未设置，则使用随机UUID\njava-opts：Java虚拟机选项，若未设置，则使用JAVA_OPTS环境变量\nredirect-output：重定向生成的进程输出和错误流到父进程流\n\n若选项值包含空白，请不要忘记在“”（双引号）之间包装值。\n由于start命令产生一个新的进程，传递给JVM的java选项不会被传播，所以您必须使用java-opts来配置JVM（-X，-D...）。若您使用 CLASSPATH 环境变量，请确保路径下包含所有需要的jar（vertx-core、您的jar和所有依赖项）。\n该命令集是可扩展的，请参考 扩展 Vert.x 启动器 部分。\n实时重部署\n在开发时，可以方便在文件更改时实时重新部署应用程序。vertx 命令行工具和更普遍的 Launcher 类提供了这个功能。这里有些例子：\nvertx run MyVerticle.groovy --redeploy=\"**/*.groovy\" --launcher-class=io.vertx.core.Launcher\nvertx run MyVerticle.groovy --redeploy=\"**/*.groovy,**/*.rb\" --launcher-class=io.vertx.core.Launcher\njava io.vertx.core.Launcher run org.acme.MyVerticle --redeploy=\"**/*.class\" --launcher-class=io.vertx.core\n.Launcher -cp ...\n重新部署过程如下执行。首先，您的应用程序作为后台应用程序启动（使用start命令）。当发现文件更改时，该进程将停止并重新启动该应用、这样可避免泄露。\n要启用实时重新部署，请将 --redeploy 选项传递给 run 命令。--redeploy 表示要监视的文件集，这个集合可使用 Ant 样式模式（使用 **，* 和 ?），您也可以使用逗号（,）分隔它们来指定多个集合。模式相当于当前工作目录。\n传递给 run 命令的参数最终会传递给应用程序，可使用 --java-opts 配置JVM虚拟机选项。\n--launcher-class 选项确定应用程序的主类启动器。它通常是一个 Launcher，单您已使用了您自己的主类。\n也可以在IDE中使用重部署功能：\n\nEclipse：创建一个运行配置，使用io.vertx.core.Launcher类作为主类。在 Program Arguments 区域（参数选项卡中），写入run your-verticle-fully-qualified-name --redeploy=**/*.java --launcher-class=io.vertx.core.Launcher，您还可以添加其他参数。随着 Eclipse 在保存时会增量编译您的文件，重部署工作会顺利进行。\nIntelliJ IDEA：创建一个运行配置（应用）,将主类设置为io.vertx.core.Launcher。在程序参数中写：run your-verticle-fully-qualified-name --redeploy=**/*.class --launcher-class=io.vertx.core.Launcher。要触发重新部署，您需要显示构造项目或模块（Build -> Make project）。\n\n要调试应用程序，请将运行配置创建为远程应用程序，并使用--java-opts配置调试器。每次重新部署后，请勿忘记重新插入(re-plug)调试器，因为它每次都会创建一个新进程。\n您还可以在重新部署周期中挂接（hook）构建过程：\njava -jar target/my-fat-jar.jar --redeploy=\"**/*.java\" --on-redeploy=\"mvn package\"\njava -jar build/libs/my-fat-jar.jar --redeploy=\"src/**/*.java\" --on-redeploy='./gradlew shadowJar'\n\"on-redeploy\"选项指定在应用程序关闭后和重新启动之前调用的命令。因此，如果更新某些运行时工作，则可以钩住构建工具。例如，您可以启动gulp或grunt来更新您的资源。\n重新部署功能还支持以下设置：\n\nredeploy-scan-period：文件系统检查周期（以毫秒为单位），默认为250ms\nredeploy-grace-period：在2次重新部署之间等待的时间（以毫秒为单位），默认为1000ms\nredeploy-termination-period：停止应用程序后等待的时间（在启动用户命令之前）。这个在Windows上非常有用，因为这个进程并没立即被杀死。时间以毫秒为单位，默认20ms\n\n集群管理器\n在 Vert.x 中，集群管理器可用于各种功能，包括：\n\n对集群中 Vert.x 节点发现和分组\n维护集群范围中的主题订阅者列表（所以我们可知道哪些节点对哪个Event Bus地址感兴趣）\n分布式Map的支持\n分布式锁\n分布式计数器\n\n集群管理器不处理Event Bus节点之间的传输，这是由 Vert.x 直接通过TCP连接完成。\nVert.x发行版中使用的默认集群管理器是使用的Hazelcast集群管理器，但是它可以轻松被替换成实现了Vert.x集群管理器接口的不同实现，因为Vert.x集群管理器可替换的。\n集群管理器必须实现ClusterManager接口，Vert.x在运行时使用Java的服务加载器（Service Loader）功能查找集群管理器，以便在类路径中查找ClusterManager的实例。\n若您在命令行中使用Vert.x并要使用集群，则应确保Vert.x安装的lib目录包含您的集群管理器jar。\n若您在 Maven/Gradle 项目使用Vert.x，则只需将集群管理器jar作为项目依赖添加。\n您也可以以编程的方式在嵌入Vert.x 时使用 setClusterManager 指定集群管理器。\n日志记录\nVert.x使用内置的日志API进行记录日志，默认实现使用JDK（JUL）日志，不需要额外的依赖项。\n配置JUL日志记录\n一个JUL日志记录配置文件可以使用普通的JUL方式指定——通过提供一个名为java.util.logging.config.file的系统属性值为您的配置文件。更多关于此部分以及JUL配置文件结构的内容，请参阅JUL日志记录文档。\nVert.x还提供了一种更方便的方式指定配置文件，无需设置系统属性。您只需在您的类路径中提供名为vertx-default-jul-logging.properties的JUL配置文件（例如在您的fatjar中），Vert.x将使用该配置文件配置JUL。\n使用另一个日志框架\n如果您不希望Vert.x使用JUL记录日志，您可以为其配置另一个日志记录框架，例如Log4J或SLF4J。\n为此，您应该设置一个名为vertx.logger-delegate-factory-class-name的系统属性，该属性的值是一个实现了 LogDelegateFactory 接口的Java 类名。我们为Log4J（版本1）、Log4J 2和SLF4J提供了预设的实现，类名为：io.vertx.core.logging.Log4jLogDelegateFactory，io.vertx.core.logging.Log4j2LogDelegateFactory和io.vertx.core.logging.SLF4JLogDelegateFactory。如您要使用这些实现，还应确保相关的Log4J或SLF4J的jar在您的类路径上。\n请注意，提供的Log4J 1代理不支持参数化消息。Log4J 2的代理使用了像SLF4J代理这样的{}语法，JUL代理使用如{x}语法。\n应用中记录日志\nVert.x本身只是一个库，您可以在自己的应用程序使用任何日志库的API来记录日志。\n但是，若您愿意，也可以使用上述的Vert.x日志记录工具为应用程序记录日志。\n为此，您需要使用LoggerFactory获取一个Logger对象以记录日志：\nLogger logger = LoggerFactory.getLogger(className);\n\nlogger.info(\"something happened\");\nlogger.error(\"oops!\", exception);\nNetty日志记录\n配置日志记录时，您也应该关心配置Netty日志记录。\nNetty不依赖于外部日志配置（例如系统属性），而是根据Netty类可见的日志记录库来实现日志记录：\n\n如SLF4J可见，则优先使用该库\n否则若Log4j可见，再使用该库\n否则退回使用java.util.logging\n\n可通过设置io.netty.util.internal.logging.InternalLoggerFactory强制Netty使用某个特定实现。\n// 强制使用Log4j日志记录\nInternalLoggerFactory.setDefaultFactory(Log4JLoggerFactory.INSTANCE);\n故障排除\nSLF4J启动警告\n若您在启动应用程序时看到以下信息：\nSLF4J: Failed to load class \"org.slf4j.impl.StaticLoggerBinder\".\nSLF4J: Defaulting to no-operation (NOP) logger implementation\nSLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.\n这意味着您的类路径中有SLF4J-API却没绑定。SLF4J记录的消息将会丢失。您应该将绑定加入您的类路径。参考 SLF4J user manual - Binding with a logging framework at deployment time 选择绑定并配置。\n请注意，Netty会寻找SLF4-API的jar，并在缺省情况下使用它。\n对等连接重置\n若您的日志显示一堆：\nio.vertx.core.net.impl.ConnectionBase\nSEVERE: java.io.IOException: Connection reset by peer\n这意味着客户端正在重置HTTP连接，而不是关闭它。此消息还可能表示您没有读取完整的有效负荷（连接在读取完全之前被切断）。\n\n译者注：通常情况下，这是正常的，无需担心，如果您打开浏览器，按快捷键不停滴刷新页面，就能看到该SEVERE日志。\n\n主机名解析\nVert.x使用地址解析器将主机名解析为IP地址，而不是JVM内置的阻塞解析器。\n主机名使用以下方式解析为IP地址：\n\n操作系统的hosts文件\nDNS查询服务器列表\n\n默认情况下，它将使用环境中系统DNS服务器地址的列表，若该列表无法检索，将使用Google的公共DNS服务器 8.8.8.8 和 8.8.4.4。\n创建 Vertx 实例时也可配置DNS 服务器：\nVertx vertx = Vertx.vertx(new VertxOptions().\n setAddressResolverOptions(\n new AddressResolverOptions().\n addServer(\"192.168.0.1\").\n addServer(\"192.168.0.2:40000\"))\n);\n\nDNS 服务器的默认端口为53，当服务器使用不同的端口时，可以使用冒号分隔符设置该端口：192.168.0.2:40000。\n\n请注意：有时可能需要使用JVM内置解析器。可以在启动的时候加上JVM系统属性 -Dvertx.disableDnsResolver=true 激活该行为。\n\n故障转移\n当服务器没有及时回应时，尝试从列表中选择下一个解析器，搜索（数量）的限制由setMaxQueries设置（默认值是4个查询）\n若解析器在getQueryTimeout毫秒内没有收到正确答案（默认为5秒），DNS查询被视为失败。\n服务器列表轮询\n默认情况下，DNS服务器选择使用第一个，其余的服务器用于故障转移。\n您可以配置 setRotateServers 为 true，让解析器使用轮询选择。它会在服务器之间传播查询负载，并避免所有的查找都找到列表中的第一个服务器。\n故障转移仍然适用，并将使用列表中的下一个服务器。\n主机映射\n操作系统的hosts文件用于对ipaddress执行主机名查找。\n可替换主机文件：\nVertx vertx = Vertx.vertx(new VertxOptions().\n setAddressResolverOptions(\n new AddressResolverOptions().\n setHostsPath(\"/path/to/hosts\"))\n);\n\n搜索域名\n默认情况下，解析器将使用环境中的系统DNS搜索域，或者，可提供明确的显示搜索域列表：\nVertx vertx = Vertx.vertx(new VertxOptions().\n setAddressResolverOptions(\n new AddressResolverOptions().addSearchDomain(\"foo.com\").addSearchDomain(\"bar.com\"))\n);\n\n当使用搜索域列表时，点数的阈值为1，或从Linux上的/etc/resolv.conf加载，也可使用 setNdots 方法配置特定值。\n高可用/故障转移\nVert.x允许您运行支持高可用（HA，High Availability）的Verticle。这种情况下，当运行Verticle的Vert.x实例突然挂掉时，该Veritlce将迁移到另一个Vert.x 实例。这个Vert.x 实例必须在同一个集群中。\n自动故障转移\n当Vert.x启用HA运行时，若一个运行了Verticle的Vert.x 实例失败或挂掉，则此Verticle将自动重新部署到集群中的另一个Vert.x 实例中。我们称这个为 Verticle 故障转移（failover）。\n若要启用HA模式，在启动 Vert.x 应用的时候需要添加-ha参数到命令行：\nvertx run my-verticle.js -ha\n现在开启了HA环境，在集群中需要多添加一个Vert.x 实例，所以假设您已经有另一个已经启动的Vert.x 实例，例如：\nvertx run my-other-verticle.js -ha\n如果运行了my-verticle.js的Vert.x 实例现在死了（您可以通过执行kill -9杀死进程来测试），运行my-other-verticle.js的Vert.x 实例将自动重新部署my-verticle.js，所以现在这个Vert.x 实例正在运行两个Verticle。\n\n请注意：只有当第二个Vert.x 实例可访问对应的 verticle 文件（这里是 my-verticle.js）时，迁移才是可能的。\n重要提示：请注意，干净地关闭Vert.x实例不会导致故障转移发生，例如：CTRL-C 或 kill -SIGNINT。\n\n您也可以启动裸的Vert.x 实例 —— 即最初不运行任何Verticle的实例，它们也将为集群中的节点进行故障转移。要启动一个裸实例，您只需做：\nvertx run -ha\n当使用-ha开关时，您不需要提供-cluster开关，因为若要使用HA就假定是集群。\n\n请注意： 根据您的集群配置，可能需要自定义集群管理器配置（默认为Hazelcast）和/或添加集群主机 cluster-host 和集群端口 cluster-port 参数。\n\nHA组\n当使用Vert.x运行实例时，还可以选择指定的HA组。HA组表示集群中的逻辑节点组。只有具有相同HA组的节点能执行故障转移。若不指定HA组，则使用默认组__DEFAULT__。\n要指定一个HA组，您可以在运行该Verticle时使用-hagroup开关。\nvertx run my-verticle.js -ha -hagroup my-group\n我们来看一个例子：\n在第一个终端运行：\nvertx run my-verticle.js -ha -hagroup g1\n在第二个终端中，让我们使用相同组运行另一个Verticle：\nvertx run my-other-verticle.js -ha -hagroup g1\n最后，在第三个终端中，使用不同组启动另一个Verticle：\nvertx run yet-another-verticle.js -ha -hagroup g2\n如果终端1中的实例被杀掉，则它将故障转移到终端2中的实例，而不是具有不同组的终端3中的实例。\n若终端3中的实例被杀掉，因为这个组中没有其他Vert.x实例，则它不会故障转移。\n处理网络分区 - Quora\n高可用HA实现同样支持 Quora（多数派机制）。Quorum 是分布式事务必须获得的最小票数才能被允许在分布式系统中执行操作的一个参数。\n在启动 Vert.x 实例时，您可以指示它在部署任何HA部署之前需要一个quorum。该上下文环境中，一个 quorum 是集群中特定组的最小节点数。通常您选择 quorum 大小为Q = 1 + N / 2，其中N是组中节点数。若集群中的Q节点少于HA节点，HA部署将被撤销。如果/当 quorum 重新获取时，他们将重新部署。通过这样做您可以防止网络分区，也就是脑裂（split brain）。\n更多关于Quorum（多数派机制）的信息，请参考 这里。\n若要使用 quorum 运行Vert.x实例，您可以在命令行中指定-quorum，例如：\n在第一个终端：\nvertx run my-verticle.js -ha -quorum 3\n此时，Vert.x实例将启动但不部署模块（尚未）因为目前集群中只有1个节点，而不是3个。\n在第二个终端：\nvertx run my-other-verticle.js -ha -quorum 3\n此时，Vert.x实例将启动但不部署模块（尚未）因为目前集群中只有2个节点，而不是3个。\n在第三个控制台，您可以启动另一个Vert.x的实例：\nvertx run yet-another-verticle.js -ha -quorum 3\n妙极！—— 我们有三个节点，这是 quorum 设置的值，此时，模块将自动部署在所有实例上。\n若我们现在关闭或杀死其中一个节点，那么这些模块将在其他节点上自动撤销，因为不再满足 quorum（法定人数）。\nQuora 也可以与HA组合使用，在这种情况下，每个特定组会解决 Quora。\n安全注意事项\nVert.x 是一个工具包，而不是来强迫您以某种方式做事情的框架。这赋予了开发人员以更强大的能力，同时也伴随着更大的责任（译者注：能力越大，责任越大，小蜘蛛他叔叔说的）。\n搭配其它工具包，使得编写不安全的应用程序成为可能，因此在开发时需谨慎，尤其是当您将其对公众发布的时候（如在互联网上发布）。\nWeb 应用\n如果编写Web 应用程序，强烈建议您直接使用Vert.x Web而非直接使用Vert.x Core以提供资源或处理文件上传。\nVert.x Web对请求中的路径进行了规范，以防止恶意客户端通过伪造URL来访问Web根目录以外的资源。\n类似地，对于文件上传Vert.x Web提供上传到磁盘上已知位置的功能，且不依赖客户端提供的文件名，客户端提供的文件名可被恶意伪装成上传到硬盘上的不同位置。\nVert.x Core 本身不提供这样的检查，所以这取决于开发者您自身如何实现了。\n集群模式 Event Bus 流量\n当在网络上的不同Vert.x 节点之间创建集群模式下的 Event Bus 时，流量将通过未加密报文发送，因此若您有要发送的机密数据，而您的Vert.x 节点不在授信的网络上，请勿使用。\n标准安全最佳实践\n任何服务都可能存在潜在的漏洞，无论是使用Vert.x还是任何其他工具包，因此始终遵循安全最佳实践，特别是当您的服务面向公众。\n例如，您应该始终在DMZ中运行它们，并使用具有受限权限的用户账户，以限制服务受到损害的程度。\nVert.x 命令行接口API\nVert.x Core提供了一个用于解析传递给程序的命令行参数API。\n它还可以打印帮助信息——详细说明命令行工具可用的选项。即使这些功能远离Vert.x Core主题，该API也可在 Launcher 类中使用，可以在 fat-jar 和 vertx 命令行工具中使用。另外，它支持多语言（可用于任何支持的语言），并可在Vert.x Shell中使用。\nVert.x CLI提供了一个描述命令行界面的模型，同时也是一个解析器，这个解析器可支持不同的语法：\n\n类似POSIX选项（即tar -zxvf foo.tar.gz）\n类似GNU选项（即du --human-readable --max-depth=1）\n类似Java属性（即java -Djava.awt.headless=true -Djava.net.useSystemProxies=true Foo）\n具有附加值的短选项（即gcc -O2 foo.c）\n单个连字符的长选项（即ant -projecthelp）\n\n使用CLI API的三个步骤如下：\n\n定义命令行接口\n解析用户命令行\n查询/审问\n\n定义阶段\n每个命令行界面必须定义将要使用的选项和参数集合。它也需要一个名字。CLI API使用 Option 和 Argument 类来描述选项和参数：\nCLI cli = CLI.create(\"copy\")\n .setSummary(\"A command line interface to copy files.\")\n .addOption(new Option()\n .setLongName(\"directory\")\n .setShortName(\"R\")\n .setDescription(\"enables directory support\")\n .setFlag(true))\n .addArgument(new Argument()\n .setIndex(0)\n .setDescription(\"The source\")\n .setArgName(\"source\"))\n .addArgument(new Argument()\n .setIndex(1)\n .setDescription(\"The destination\")\n .setArgName(\"target\"));\n\n您可以看到，您可以使用CLI.create创建一个新的CLI。传递的字符串是CLI的名称。创建后，您可以设置摘要和描述，摘要的目的是简短（一行），而描述可以包含更多细节。每个选项和参数也使用addArgument和addOption方法添加到CLI对象上。\n选项\nOption 是由用户命令行中存在的 键 标识的命令行参数。选项至少必须有一个长名或一个短名。长名称通常使用 -- 前缀，而短名称与单个 - 一起使用。选项可以获取用法中显示的描述（见下文）。选项可以接受0、1或几个值。接受0值的选项是一个标志(flag)，必须使用 setFlag 声明。默认情况下，选项会接受一个值，但是您可以使用 setMultiValued 方法配置该选项接收多个值：\nCLI cli = CLI.create(\"some-name\")\n .setSummary(\"A command line interface illustrating the options valuation.\")\n .addOption(new Option()\n .setLongName(\"flag\").setShortName(\"f\").setFlag(true).setDescription(\"a flag\"))\n .addOption(new Option()\n .setLongName(\"single\").setShortName(\"s\").setDescription(\"a single-valued option\"))\n .addOption(new Option()\n .setLongName(\"multiple\").setShortName(\"m\").setMultiValued(true)\n .setDescription(\"a multi-valued option\"));\n\n选项可以标记为必填项，在用户命令行中未设置必填选项在解析阶段会引发异常：\nCLI cli = CLI.create(\"some-name\")\n .addOption(new Option()\n .setLongName(\"mandatory\")\n .setRequired(true)\n .setDescription(\"a mandatory option\"));\n\n非必填选项可以具有默认值，如果用户没有在命令行中设置该选项，即将使用该值：\nCLI cli = CLI.create(\"some-name\")\n .addOption(new Option()\n .setLongName(\"optional\")\n .setDefaultValue(\"hello\")\n .setDescription(\"an optional option with a default value\"));\n\n可以使用 setHidden 方法隐藏选项，隐藏选项不在用法中列出，但仍可在用户命令行中使用（针对高级用户）。\n如果选项值被限制为一个固定集合，您可以设置不同的可接受选项：\nCLI cli = CLI.create(\"some-name\")\n .addOption(new Option()\n .setLongName(\"color\")\n .setDefaultValue(\"green\")\n .addChoice(\"blue\").addChoice(\"red\").addChoice(\"green\")\n .setDescription(\"a color\"));\n\n也可以从JSON表单中实例化选项。\n参数\n和选项不同，参数不具有 键 并由其索引标识。例如，在java com.acme.Foo中，com.acme.Foo是一个参数。\n参数没有名称，使用基于 0 的索引进行标识。第一个参数的索引为 0：\nCLI cli = CLI.create(\"some-name\")\n .addArgument(new Argument()\n .setIndex(0)\n .setDescription(\"the first argument\")\n .setArgName(\"arg1\"))\n .addArgument(new Argument()\n .setIndex(1)\n .setDescription(\"the second argument\")\n .setArgName(\"arg2\"));\n\n如果不设置参数索引，则基于声明顺序会自动计算。\nCLI cli = CLI.create(\"some-name\")\n // 索引为0\n .addArgument(new Argument()\n .setDescription(\"the first argument\")\n .setArgName(\"arg1\"))\n // 索引为1\n .addArgument(new Argument()\n .setDescription(\"the second argument\")\n .setArgName(\"arg2\"));\n\nargName 是可选的，并在消息中使用。\n相比选项，Argument可以：\n\n使用setHidden隐藏\n使用setRequired设置必填\n使用setDefaultValue设置默认值\n使用setMultiValued设置接收多个值——只有最后一个参数可以是多值的。\n\n参数也可以从JSON表单中实例化。\n生成 usage 信息\n一旦您的CLI实例配置好后，您可以生成 usage 信息：\nCLI cli = CLI.create(\"copy\")\n .setSummary(\"A command line interface to copy files.\")\n .addOption(new Option()\n .setLongName(\"directory\")\n .setShortName(\"R\")\n .setDescription(\"enables directory support\")\n .setFlag(true))\n .addArgument(new Argument()\n .setIndex(0)\n .setDescription(\"The source\")\n .setArgName(\"source\"))\n .addArgument(new Argument()\n .setIndex(0)\n .setDescription(\"The destination\")\n .setArgName(\"target\"));\n\nStringBuilder builder = new StringBuilder();\ncli.usage(builder);\n\n上边生成的 usage 信息如下：\nUsage: copy [-R] source target\n\nA command line interface to copy files.\n\n -R,--directory enables directory support\n若需要调整 usage 信息，请查阅 UsageMessageFormatter 类的文档。\n解析阶段\n一旦您的 CLI 实例配置好后，您可以解析用户命令行来解析每个选项和参数：\nCommandLine commandLine = cli.parse(userCommandLineArguments);\n\nparse解析方法返回包含值的CommandLine对象。默认情况下，它验证用户命令行，并检查每个必填选项和参数的设置以及每个选项接收的值的数量。您可以通过传递 false 作为parse的第二个参数来禁用验证。如果要检查参数或选项，即使解析的命令行无效，这也是有用的。\n您可以使用isValid来检查CommandLine是否有效。\n查询/审问阶段\n解析后，您可以从解析方法返回的CommandLine对象中读取选项和参数的值：\nCommandLine commandLine = cli.parse(userCommandLineArguments);\nString opt = commandLine.getOptionValue(\"my-option\");\nboolean flag = commandLine.isFlagEnabled(\"my-flag\");\nString arg0 = commandLine.getArgumentValue(0);\n\n您的一个选项可以被标记为“帮助”。如果用户命令行启用“帮助”选项，验证将不会失败，但是可以让您有机会检查用户是否需要帮助：\nCLI cli = CLI.create(\"test\")\n .addOption(\n new Option().setLongName(\"help\").setShortName(\"h\").setFlag(true).setHelp(true))\n .addOption(\n new Option().setLongName(\"mandatory\").setRequired(true));\n\nCommandLine line = cli.parse(Collections.singletonList(\"-h\"));\n\n// 解析不会失败，您可以做：\nif (!line.isValid() && line.isAskingForHelp()) {\n StringBuilder builder = new StringBuilder();\n cli.usage(builder);\n stream.print(builder.toString());\n}\n\n有类型选项和参数\n描述Option和Argument类是无类型的，这意味着仅读取String值。\nTypedOption和TypedArgument可以指定一个类型，因此（String）原始值将转换为指定的类型。\n在CLI定义中使用TypedOption和TypedArgument，而不是Option和Argument。\nCLI cli = CLI.create(\"copy\")\n .setSummary(\"A command line interface to copy files.\")\n .addOption(new TypedOption()\n .setType(Boolean.class)\n .setLongName(\"directory\")\n .setShortName(\"R\")\n .setDescription(\"enables directory support\")\n .setFlag(true))\n .addArgument(new TypedArgument()\n .setType(File.class)\n .setIndex(0)\n .setDescription(\"The source\")\n .setArgName(\"source\"))\n .addArgument(new TypedArgument()\n .setType(File.class)\n .setIndex(0)\n .setDescription(\"The destination\")\n .setArgName(\"target\"));\n\n然后，您可以按下边方式获取转换的值：\nCommandLine commandLine = cli.parse(userCommandLineArguments);\nboolean flag = commandLine.getOptionValue(\"R\");\nFile source = commandLine.getArgumentValue(\"source\");\nFile target = commandLine.getArgumentValue(\"target\");\n\nVert.x CLI可以转换的类：\n\n具有单个String参数的构造函数，例如File或JsonObject\n使用静态的from或fromString方法\n使用静态valueOf方法，如基础类型和枚举\n\n此外，您可以实现自己的转换器（Converter）并指定CLI使用此转换器：\nCLI cli = CLI.create(\"some-name\")\n .addOption(new TypedOption()\n .setType(Person.class)\n .setConverter(new PersonConverter())\n .setLongName(\"person\"));\n\n对于布尔值，布尔值将被评定为true:on，yes，1，true。\n若您的一个选项是 enum 类型，则（系统）会自动计算一组选项。\n使用注解\n您还可以使用注解定义CLI。在类和 setter 方法上使用注解来定义：\n@Name(\"some-name\")\n@Summary(\"some short summary.\")\n@Description(\"some long description\")\npublic class AnnotatedCli {\n\n private boolean flag;\n private String name;\n private String arg;\n\n @Option(shortName = \"f\", flag = true)\n public void setFlag(boolean flag) {\n this.flag = flag;\n }\n\n @Option(longName = \"name\")\n public void setName(String name) {\n this.name = name;\n }\n\n @Argument(index = 0)\n public void setArg(String arg) {\n this.arg = arg;\n }\n}\n\n注解后，您可以使用以下命令来定义CLI并注入值：\nCLI cli = CLI.create(AnnotatedCli.class);\nCommandLine commandLine = cli.parse(userCommandLineArguments);\nAnnotatedCli instance = new AnnotatedCli();\nCLIConfigurator.inject(commandLine, instance);\n\nVert.x Launcher\nVert.x Launcher 在 fat-jar 中作为主类，由 vertx 命令行实用程序调用。它可执行一组命令，如run、bare 和 start等\n扩展 Vert.x 启动器\n您可以通过实现自己的 Command 类来扩展命令集（仅限于Java）：\n@Name(\"my-command\")\n@Summary(\"A simple hello command.\")\npublic class MyCommand extends DefaultCommand {\n\n private String name;\n\n @Option(longName = \"name\", required = true)\n public void setName(String n) {\n this.name = n;\n }\n\n @Override\n public void run() throws CLIException {\n System.out.println(\"Hello \" + name);\n }\n}\n\n您还需要实现一个 CommandFactory：\npublic class HelloCommandFactory extends DefaultCommandFactory {\n public HelloCommandFactory() {\n super(HelloCommand.class);\n }\n}\n\n然后创建 src/main/resources/META-INF/services/io.vertx.core.spi.launcher.CommandFactory 并且添加一行表示工厂类的完全限定名称：\nio.vertx.core.launcher.example.HelloCommandFactory\n构建包含命令的jar。确保包含了SPI文件（META-INF/services/io.vertx.core.spi.launcher.CommandFactory）。\n然后，将包含该命令的jar放入fat-jar（或包含在其中）的类路径中，或放在Vert.x发行版的lib目录中，您将可以执行：\nvertx hello vert.x\njava -jar my-fat-jar.jar hello vert.x\n\n在 fat-jar 中使用启动器\n要在 fat-jar 中使用 Launcher 类，只需要将 MANIFEST 的 Main-Class 设置为 io.vertx.core.Launcher。另外，将 MANIFEST 中 Main-Verticle 条目设置为您的Main Verticle的名称。\n默认情况下，它会执行 run 命令。但是，您可以通过设置 MANIFEST 的Main-Command条目来配置默认命令。若在没有命令的情况下启动 fat-jar，则使用默认命令。\n启动器子类\n您还可以创建 Launcher 的子类来启动您的应用程序。这个类被设计成易于扩展的。\n一个 Launcher 子类可以：\n\n在 beforeStartingVertx 中自定义 Vert.x 配置\n通过覆盖 afterStartingVertx 来读取由“run”或“bare”命令创建的Vert.x实例\n使用 getMainVerticle 和 getDefaultCommand 方法配置默认的Verticle和命令\n使用 register 和 unregister 方法添加/删除命令\n\n启动器和退出代码\n当您使用 Launcher 类作为主类时，它使用以下退出代码：\n\n若进程顺利结束，或抛出未捕获的错误：0\n用于通用错误：1\n若Vert.x无法初始化：11\n若生成的进程无法启动、发现或停止：12，该错误代码一般由start和stop命令使用\n若系统配置不符合系统要求（如找不到 java 命令）：14\n若主Verticle不能被部署：15\n\n配置 Vert.x 缓存\n当 Vert.x 需要从类路径中读取文件（嵌入在 fat-jar 中，类路径中jar文件或其他文件）时，它会把文件复制到缓存目录。背后原因很简单：从 jar 或从输入流读取文件是阻塞的。所以为了避免每次都付出代价，Vert.x 会将文件复制到其缓存目录中，并随后读取该文件。这个行为也可配置。\n首先，默认情况下，Vert.x 使用 $CWD/.vertx 作为缓存目录，它在此之间创建一个唯一的目录，以避免冲突。可以使用 vertx.cacheDirBase 系统属性配置该位置。如，若当前工作目录不可写（例如在不可变容器上下文环境中），请使用以下命令启动应用程序：\nvertx run my.Verticle -Dvertx.cacheDirBase=/tmp/vertx-cache\n# 或者\njava -jar my-fat.jar vertx.cacheDirBase=/tmp/vertx-cache\n\n\n重要提示： 该目录必须是可写的。\n\n当您编辑资源（如HTML、CSS或JavaScript）时，这种缓存机制可能令人讨厌，因为它仅仅提供文件的第一个版本（因此，若您想重新加载页面，则不会看到您的编辑改变）。要避免此行为，请使用 -Dvertx.disableFileCaching=true 启动应用程序。使用此设置，Vert.x 仍然使用缓存，但始终使用原始源刷新存储在缓存中的版本。因此，如果您编辑从类路径提供的文件并刷新浏览器，Vert.x 会从类路径读取它，将其复制到缓存目录并从中提供。不要在生产环境使用这个设置，它很有可能影响性能。\n最后，您可以使用-Dvertx.disableFileCPResolving=true完全禁用高速缓存。这个设置不是没有后果的。Vert.x将无法从类路径中读取任何文件（仅从文件系统）。使用此设置时要非常小心。\n\n结语\n\n\n原文档更新于2017-03-15 15:54:14 CET\n\n"},"web/Web.html":{"url":"web/Web.html","title":"Web","keywords":"","body":"Vert.x Web\n中英对照表\n\nContainer：容器\nMicro-service：微服务\nBridge：桥接\nRouter：路由器\nRoute：路由\nSub-Route: 子路由\nHandler：处理器，某些特定的地方未翻译\nBlocking：阻塞式\nContext：上下文。非特别说明指代路由的上下文 routing context，不同于 Vert.x core 的 Context\nApplication：应用\nHeader：消息头\nBody：消息体\nMIME types：互联网媒体类型\nLoad-Balancer：负载均衡器\nSocket：套接字\nMount：挂载\n\n组件介绍\nVert.x Web 是一系列用于基于 Vert.x 构建 Web 应用的构建模块。\n可以把它想象成一把构建现代的、可伸缩的 Web 应用的瑞士军刀。\nVert.x Core 提供了一系列底层的功能用于操作 HTTP，对于一部分应用来是足够的。\nVert.x Web 基于 Vert.x Core，提供了一系列更丰富的功能以便更容易地开发实际的 Web 应用。\n它继承了 Vert.x 2.x 里的 Yoke 的特点，灵感来自于 Node.js 的框架 Express 和 Ruby 的框架 Sinatra 等等。\nVert.x Web 的设计是强大的，非侵入式的，并且是完全可插拔的。Vert.x Web 不是一个容器，您可以只使用您需要的部分。\n您可以使用 Vert.x Web 来构建经典的服务端 Web 应用、RESTful 应用、实时的（服务端推送）Web 应用，或任何类型的您所能想到的 Web 应用。应用类型的选择取决于您，而不是 Vert.x Web。\nVert.x Web 非常适合编写 RESTful HTTP 微服务，但我们不强制您必须把应用实现成这样。\nVert.x Web 的一部分关键特性有：\n\n路由（基于方法(1)、路径等）\n基于正则表达式的路径匹配\n从路径中提取参数\n内容协商(2)\n处理消息体\n消息体的长度限制\n接收和解析 Cookie\nMultipart 表单\nMultipart 文件上传\n子路由\n支持本地会话和集群会话\n支持 CORS（跨域资源共享）\n错误页面处理器\nHTTP基本认证\n基于重定向的认证\n授权处理器\n基于 JWT 的授权\n用户/角色/权限授权\n网页图标处理器\n支持服务端模板渲染，包括以下开箱即用的模板引擎：\nHandlebars\nJade\nMVEL\nThymeleaf\nApache FreeMarker\nPebble\n\n\n响应时间处理器\n静态文件服务，包括缓存逻辑以及目录监听\n支持请求超时\n支持 SockJS\n桥接 Event-bus\nCSRF 跨域请求伪造\n虚拟主机\n\nVert.x Web 的大多数特性被实现为了处理器（Handler），因此您随时可以实现您自己的处理器。我们预计随着时间的推移会有更多的处理器被实现。\n我们会在本手册里讨论所有上述的特性。\n使用 Vert.x Web\n在使用 Vert.x Web 之前，需要为您的构建工具在描述文件中添加依赖项：\n\nMaven（在 pom.xml 文件中）：\n\n\n io.vertx\n vertx-web\n 3.4.1\n\n\n\nGradle（在 build.gradle 文件中）：\n\ndependencies {\n compile 'io.vertx:vertx-web:3.4.1'\n}\n\n回顾 Vert.x Core 的 HTTP 服务端\nVert.x Web 使用了 Vert.x Core 暴露的 API，所以熟悉基于 Vert.x Core 编写 HTTP 服务端的基本概念是很有价值的。\nVert.x Core 的 HTTP 文档 有很多关于这方面的细节。\n下面是一个使用 Vert.x Core 编写的 Hello World Web 服务器，暂不涉及 Vert.x Web：\nHttpServer server = vertx.createHttpServer();\n\nserver.requestHandler(request -> {\n\n // 所有的请求都会调用这个处理器处理\n HttpServerResponse response = request.response();\n response.putHeader(\"content-type\", \"text/plain\");\n\n // 写入响应并结束处理\n response.end(\"Hello World!\");\n});\n\nserver.listen(8080);\n\n我们创建了一个 HTTP 服务端，并设置了一个请求处理器。所有的请求都会调用这个处理器处理。\n当请求到达时，我们设置了响应的 Content Type 为 text/plain 并写入了 Hello World! 然后结束了处理。\n之后，我们告诉服务器监听 8080 端口（默认的主机名是 localhost）。\n您可以执行这段代码，并打开浏览器访问 http://localhost:8080 来验证它是否如预期的一样工作。\nVert.x Web 的基本概念\nRouter 是 Vert.x Web 的核心概念之一。它是一个维护了零或多个 Route 的对象。\nRouter 接收 HTTP 请求，并查找首个匹配该请求的 Route，然后将请求传递给这个 Route。\nRoute 可以持有一个与之关联的处理器用于接收请求。您可以通过这个处理器对请求做一些事情，然后结束响应或者把请求传递给下一个匹配的处理器。\n以下是一个简单的路由示例：\nHttpServer server = vertx.createHttpServer();\n\nRouter router = Router.router(vertx);\n\nrouter.route().handler(routingContext -> {\n\n // 所有的请求都会调用这个处理器处理\n HttpServerResponse response = routingContext.response();\n response.putHeader(\"content-type\", \"text/plain\");\n\n // 写入响应并结束处理\n response.end(\"Hello World from Vert.x-Web!\");\n});\n\nserver.requestHandler(router::accept).listen(8080);\n\n它做了和上文使用 Vert.x Core 实现的 HTTP 服务器基本相同的事情，只是这一次换成了 Vert.x Web。\n和上文一样，我们创建了一个 HTTP 服务器，然后创建了一个 Router。在这之后，我们创建了一个没有匹配条件的 Route，这个 route 会匹配所有到达这个服务器的请求。\n之后，我们为这个 route 指定了一个处理器，所有的请求都会调用这个处理器处理。\n调用处理器的参数是一个 RoutingContext 对象。它不仅包含了 Vert.x 中标准的 HttpServerRequest 和\nHttpServerResponse，还包含了各种用于简化 Vert.x Web 使用的东西。\n每一个被路由的请求对应一个唯一的 RoutingContext，这个实例会被传递到所有处理这个请求的处理器上。\n当我们创建了处理器之后，我们设置了 HTTP 服务器的请求处理器，使所有的请求都通过 accept(3)处理。\n这些是最基本的，下面我们来看一下更多的细节：\n处理请求并调用下一个处理器\n当 Vert.x Web 决定路由一个请求到匹配的 route 上，它会使用一个 RoutingContext 调用对应处理器。\n如果您不在处理器里结束这个响应，您需要调用 next 方法让其他匹配的 Route 来处理请求（如果有）。\n您不需要在处理器执行完毕时调用 next 方法。您可以在之后您需要的时间点调用它：\nRoute route1 = router.route(\"/some/path/\").handler(routingContext -> {\n\n HttpServerResponse response = routingContext.response();\n // 由于我们会在不同的处理器里写入响应，因此需要启用分块传输\n // 仅当需要通过多个处理器输出响应时才需要\n response.setChunked(true);\n\n response.write(\"route1\\n\");\n\n // 5 秒后调用下一个处理器\n routingContext.vertx().setTimer(5000, tid -> routingContext.next());\n});\n\nRoute route2 = router.route(\"/some/path/\").handler(routingContext -> {\n\n HttpServerResponse response = routingContext.response();\n response.write(\"route2\\n\");\n\n // 5 秒后调用下一个处理器\n routingContext.vertx().setTimer(5000, tid -> routingContext.next());\n});\n\nRoute route3 = router.route(\"/some/path/\").handler(routingContext -> {\n\n HttpServerResponse response = routingContext.response();\n response.write(\"route3\");\n\n // 结束响应\n routingContext.response().end();\n});\n\n在上述的例子中，route1 向响应里写入了数据，5秒之后 route2 向响应里写入了数据，再5秒之后 route3 向响应里写入了数据并结束了响应。\n注意，所有发生的这些没有线程阻塞。\n使用阻塞式处理器\n某些时候您可能需要在处理器里执行一些需要阻塞 Event Loop 的操作，比如调用某个传统的阻塞式 API 或者执行密集计算。\n您不能在普通的处理器里执行这些操作，所以我们提供了向 Route 设置阻塞式处理器的能力。\n阻塞式处理器和普通处理器的区别是 Vert.x 会使用 Worker Pool 中的线程而不是 Event Loop 线程来处理请求。\n您可以使用 blockingHandler 方法来设置阻塞式处理器。下面是一个例子：\nrouter.route().blockingHandler(routingContext -> {\n\n // 执行某些同步的耗时操作\n service.doSomethingThatBlocks();\n\n // 调用下一个处理器\n routingContext.next();\n\n});\n\n默认情况下在一个 Context（Vert.x Core 的 Context，例如同一个 Verticle 实例） 上执行的所有阻塞式处理器的执行是顺序的，也就意味着只有一个处理器执行完了才会继续执行下一个。\n如果您不关心执行的顺序，并且不介意阻塞式处理器以并行的方式执行，您可以在调用 blockingHandler 方法时将 ordered 设置为 false。\n注意，如果您需要在一个阻塞处理器中处理一个 multipart 类型的表单数据，您需要首先使用一个非阻塞的处理器来调用 setExpectMultipart(true)。 下面是一个例子：\nrouter.post(\"/some/endpoint\").handler(ctx -> {\n ctx.request().setExpectMultipart(true);\n ctx.next();\n}).blockingHandler(ctx -> {\n // 执行某些阻塞操作\n});\n\n基于精确路径的路由\n可以将 Route 设置为只匹配指定的 URI。在这种情况下它只会匹配路径和该路径一致的请求。\n在下面这个例子中会被路径为 /some/path/ 的请求调用。我们会忽略结尾的 /，所以路径 /some/path 或者 /some/path// 的请求也是匹配的：\nRoute route = router.route().path(\"/some/path/\");\n\nroute.handler(routingContext -> {\n // 所有以下路径的请求都会调用这个处理器:\n\n // `/some/path`\n // `/some/path/`\n // `/some/path//`\n //\n // 但不包括：\n // `/some/path/subdir`\n});\n\n基于路径前缀的路由\n您经常需要为所有以某些路径开始的请求设置 Route。您可以使用正则表达式来实现，但更简单的方式是在声明 Route 的路径时使用一个 * 作为结尾。\n在下面的例子中处理器会匹配所有 URI 以 /some/path 开头的请求。\n例如 /some/path/foo.html 和 /some/path/otherdir/blah.css 都会匹配。\nRoute route = router.route().path(\"/some/path/*\");\n\nroute.handler(routingContext -> {\n // 所有路径以 `/some/path/` 开头的请求都会调用这个处理器处理，例如：\n\n // `/some/path`\n // `/some/path/`\n // `/some/path/subdir`\n // `/some/path/subdir/blah.html`\n //\n // 但不包括：\n // `/some/bath`\n});\n\n也可以在创建 Route 的时候指定任意的路径：\nRoute route = router.route(\"/some/path/*\");\n\nroute.handler(routingContext -> {\n // 这个路由器的调用规则和上面的例子一样\n});\n\n捕捉路径参数\n可以通过占位符声明路径参数并在处理请求时通过 params 方法获取：\n以下是一个例子：\nRoute route = router.route(HttpMethod.POST, \"/catalogue/products/:producttype/:productid/\");\n\nroute.handler(routingContext -> {\n\n String productType = routingContext.request().getParam(\"producttype\");\n String productID = routingContext.request().getParam(\"productid\");\n\n // 执行某些操作...\n});\n\n占位符由 : 和参数名构成。参数名由字母、数字和下划线构成。\n在上述的例子中，如果一个 POST 请求的路径为 /catalogue/products/tools/drill123/，那么会匹配这个 Route，并且会接收到参数 productType 的值为 tools，参数 productID 的值为 drill123。\n基于正则表达式的路由\n正则表达式同样也可用于在路由时匹配 URI 路径。\nRoute route = router.route().pathRegex(\".*foo\");\n\nroute.handler(routingContext -> {\n\n // 以下路径的请求都会调用这个处理器:\n\n // /some/path/foo\n // /foo\n // /foo/bar/wibble/foo\n // /bar/foo\n\n // 但不包括:\n // /bar/wibble\n});\n\n或者在创建 Route 时指定正则表达式：\nRoute route = router.routeWithRegex(\".*foo\");\n\nroute.handler(routingContext -> {\n\n // 这个路由器的调用规则和上面的例子一样\n\n});\n\n通过正则表达式捕捉路径参数\n您也可以捕捉通过正则表达式声明的路径参数，下面是一个例子：\nRoute route = router.routeWithRegex(\".*foo\");\n\n// 这个正则表达式可以匹配路径类似于 `/foo/bar` 的请求\n// `foo` 可以通过参数 param0 获取，`bar` 可以通过参数 param1 获取\nroute.pathRegex(\"\\\\/([^\\\\/]+)\\\\/([^\\\\/]+)\").handler(routingContext -> {\n\n String productType = routingContext.request().getParam(\"param0\");\n String productID = routingContext.request().getParam(\"param1\");\n\n // 执行某些操作\n});\n\n在上面的例子中，如果一个请求的路径为 /tools/drill123/，那么会匹配这个 route，并且会接收到参数 productType 的值为 tools，参数 productID 的值为 drill123。\n基于 HTTP Method 的路由\n默认的，Route 会匹配所有 HTTP Method。\n如果您需要 Route 只匹配指定的 HTTP Method，您可以使用 method 方法。\nRoute route = router.route().method(HttpMethod.POST);\n\nroute.handler(routingContext -> {\n\n // 所有的 POST 请求都会调用这个处理器\n\n});\n\n或者可以在创建这个 Route 时和路径一起指定：\nRoute route = router.route(HttpMethod.POST, \"/some/path/\");\n\nroute.handler(routingContext -> {\n\n // 所有路径为 `/some/path/` 的 POST 请求都会调用这个处理器\n\n});\n\n如果您想让 Route 指定的 HTTP Method ，您也可以使用对应的 get、post、put 等方法。下面是一个例子：\nrouter.get().handler(routingContext -> {\n\n // 所有 GET 请求都会调用这个处理器\n\n});\n\nrouter.get(\"/some/path/\").handler(routingContext -> {\n\n // 所有路径为 `/some/path/` 的 GET 请求都会调用这个处理器\n\n});\n\nrouter.getWithRegex(\".*foo\").handler(routingContext -> {\n\n // 所有路径以 `foo` 结尾的 GET 请求都会调用这个处理器\n\n});\n\n如果您想要让一个路由匹配不止一个 HTTP Method，您可以调用 method 方法多次：\nRoute route = router.route().method(HttpMethod.POST).method(HttpMethod.PUT);\n\nroute.handler(routingContext -> {\n\n // 所有 GET 或 POST 请求都会调用这个处理器\n\n});\n\n路由顺序\n默认的路由的匹配顺序与添加到 Router 的顺序一致。\n当一个请求到达时，Router 会一步一步检查每一个 Route 是否匹配，如果匹配则对应的处理器会被调用。\n如果处理器随后调用了 next，则下一个匹配的 Route 对应的处理器（如果有）会被调用，以此类推。\n下面的例子展示了这个过程：\nRoute route1 = router.route(\"/some/path/\").handler(routingContext -> {\n\n HttpServerResponse response = routingContext.response();\n // 由于我们会在不同的处理器里写入响应，因此需要启用分块传输\n // 仅当需要通过多个处理器输出响应时才需要\n response.setChunked(true);\n\n response.write(\"route1\\n\");\n\n // 调用下一个匹配的 route\n routingContext.next();\n});\n\nRoute route2 = router.route(\"/some/path/\").handler(routingContext -> {\n\n HttpServerResponse response = routingContext.response();\n response.write(\"route2\\n\");\n\n // 调用下一个匹配的 route\n routingContext.next();\n});\n\nRoute route3 = router.route(\"/some/path/\").handler(routingContext -> {\n\n HttpServerResponse response = routingContext.response();\n response.write(\"route3\");\n\n // 结束响应\n routingContext.response().end();\n});\n\n在上面的例子里，响应中会包含：\nroute1\nroute2\nroute3\n对于任意以 /some/path 开头的请求，Route会被依次调用。\n如果您想覆盖路由默认的顺序，您可以通过 order 方法为每一个路由指定一个 integer 值。\n当 Route 被创建时 order 会被赋值为其被添加到 Router 时的序号，例如第一个 Route 是 0，第二个是 1，以此类推。\n您可以使用特定的顺序值覆盖默认的顺序。如果您需要确保一个 Route 在顺序 0 的 Route 之前执行，可以将其指定为负值。\n让我们改变 route2 的值使其能在 route1 之前执行：\nRoute route1 = router.route(\"/some/path/\").handler(routingContext -> {\n\n HttpServerResponse response = routingContext.response();\n response.write(\"route1\\n\");\n\n // 调用下一个匹配的 route\n routingContext.next();\n});\n\nRoute route2 = router.route(\"/some/path/\").handler(routingContext -> {\n\n HttpServerResponse response = routingContext.response();\n // 由于我们会在不同的处理器里写入响应，因此需要启用分块传输\n // 仅当需要通过多个处理器输出响应时才需要\n response.setChunked(true);\n\n response.write(\"route2\\n\");\n\n // 调用下一个匹配的 route\n routingContext.next();\n});\n\nRoute route3 = router.route(\"/some/path/\").handler(routingContext -> {\n\n HttpServerResponse response = routingContext.response();\n response.write(\"route3\");\n\n // 结束响应\n routingContext.response().end();\n});\n\n// 更改 route2 的顺序使其可以在 route1 之前执行\nroute2.order(-1);\n\n此时响应内容会是：\nroute2\nroute1\nroute3\n\n如果两个匹配的 Route 有相同的顺序值，则会按照添加它们的顺序来调用。\n您也可以通过 last 方法来指定 Route 最后执行。\n基于请求媒体类型（MIME types）的路由\n您可以使用 consumes 方法指定 Route 匹配对应 MIME 类型的请求。\n在这种情况下，如果请求中包含了消息头 content-type 声明了消息体的 MIME 类型。则它会与通过 consumes 方法声明的值进行比较。\n一般来说，consumes 描述了处理器能够处理的 MIME 类型。\nMIME Type 的匹配过程是精确的：\nrouter.route().consumes(\"text/html\").handler(routingContext -> {\n\n // 所有 `content-type` 消息头的值为 `text/html` 的请求会调用这个处理器\n\n});\n\n也可以匹配多个精确的值（MIME 类型）：\nrouter.route().consumes(\"text/html\").consumes(\"text/plain\").handler(routingContext -> {\n\n // 所有 `content-type` 消息头的值为 `text/html` 或 `text/plain` 的请求会调用这个处理器\n\n});\n\n基于通配符的子类型匹配也是支持的：\nrouter.route().consumes(\"text/*\").handler(routingContext -> {\n\n // 所有 `content-type` 消息头的顶级类型为 `text` 的请求会调用这个处理器\n // 例如 `content-type` 消息头设置为 `text/html` 或 `text/plain` 都会匹配\n\n});\n\n您也可以用通配符匹配顶级的类型（top level type）：\nrouter.route().consumes(\"*/json\").handler(routingContext -> {\n\n // 所有 `content-type` 消息头的子类型为 `json` 的请求会调用这个处理器\n // 例如 `content-type` 消息头设置为 `text/json` 或 `application/json` 都会匹配\n\n});\n\n如果您没有在 consumers 中包含 /，则意味着是一个子类型（sub-type）。\n基于客户端可接受媒体类型（MIME types acceptable）的路由\nHTTP 的 accept 消息头用于表示哪些 MIME 类型的响应是客户端可接受的。\n一个 accept 消息头可以包含多个用 , 分隔的 MIME 类型。\n如果在 accept 消息头中匹配了不止一个 MIME 类型，则可以为每一个 MIME 类型追加一个 q 值来表示权重。q 的取值范围由 0 到 1.0。缺省值为 1.0。\n例如，下面的 accept 消息头表示客户端只接受 text/plain 类型的响应。\nAccept: text/plain\n以下 accept 表示客户端会无偏好地接受 text/plain 或 text/html。\nAccept: text/plain, text/html\n以下 accept 表示客户端会接受 text/plain 或 text/html，但会更倾向于 text/html，因为其具有更高的 q 值（默认值为 1.0）。\nAccept: text/plain; q=0.9, text/html\n在这种情况下，如果服务器可以同时提供 text/plain 和 text/html，它需要提供 text/html。\n您可以使用 produces 来定义 Route 可以提供哪些 MIME 类型。例如以下处理器可以提供 MIME 类型为 application/json 的响应。\nrouter.route().produces(\"application/json\").handler(routingContext -> {\n\n HttpServerResponse response = routingContext.response();\n response.putHeader(\"content-type\", \"application/json\");\n response.write(someJSON).end();\n\n});\n\n在这种情况下这个 Route 会匹配任何 accept 消息头匹配 application/json 的请求。例如：\nAccept: application/json\nAccept: application/*\nAccept: application/json, text/html\nAccept: application/json;q=0.7, text/html;q=0.8, text/plain\n您也可以标记您的 Route 提供不止一种 MIME 类型。在这种情况下，您可以使用 getAcceptableContentType 方法来找出真正被接受的 MIME 类型。\nrouter.route().produces(\"application/json\").produces(\"text/html\").handler(routingContext -> {\n\n HttpServerResponse response = routingContext.response();\n\n // 获取最终匹配到的 MIME type\n String acceptableContentType = routingContext.getAcceptableContentType();\n\n response.putHeader(\"content-type\", acceptableContentType);\n response.write(whatever).end();\n});\n\n在上述例子中，如果您发送一个包含如下 accept 消息头的请求：\nAccept: application/json; q=0.7, text/html\n那么会匹配上面的 Route，并且 acceptableContentType 的值会是 text/html 因为其具有更高的 q 值。\n组合路由规则\n您可以用不同的方式来组合上述的路由规则，例如：\nRoute route = router.route(HttpMethod.PUT, \"myapi/orders\")\n .consumes(\"application/json\")\n .produces(\"application/json\");\n\nroute.handler(routingContext -> {\n\n // 这会匹配所有路径以 `/myapi/orders` 开头，`content-type` 值为 `application/json` 并且 `accept` 值为 `application/json` 的 PUT 请求\n\n});\n\n启用和停用 Route\n您可以通过 disable 方法来停用一个 Route。停用的 Route 在匹配时会被忽略。\n您可以用 enable 方法来重新启用它。\n上下文数据\n在请求的生命周期中，您可以通过路由上下文 RoutingContext 来维护任何您希望在处理器之间共享的数据。\n以下是一个例子，一个处理器设置了一些数据，另一个处理器获取它：\n您可以使用 put 方法向上下文设置任何对象，使用 get 方法从上下文中获取任何对象。\n一个路径为 /some/path/other 的请求会同时匹配两个 Route:\nrouter.get(\"/some/path/*\").handler(routingContext -> {\n\n routingContext.put(\"foo\", \"bar\");\n routingContext.next();\n\n});\n\nrouter.get(\"/some/path/other\").handler(routingContext -> {\n\n String bar = routingContext.get(\"foo\");\n // 执行某些操作\n routingContext.response().end();\n\n});\n\n另一种您可以访问上下文数据的方式是使用 data 方法。\n转发\n(4) 到目前为止，通过上述的路由机制您可以顺序地处理您的请求，但某些情况下您可能需要回退。由于处理器的顺序是动态的，路由上下文并没有暴露出任何关于前一个或后一个处理器的信息。唯一的方式是在当前的 Router 里重启 Route的流程。\nrouter.get(\"/some/path\").handler(routingContext -> {\n\n routingContext.put(\"foo\", \"bar\");\n routingContext.next();\n\n});\n\nrouter.get(\"/some/path/B\").handler(routingContext -> {\n routingContext.response().end();\n});\n\nrouter.get(\"/some/path\").handler(routingContext -> {\n routingContext.reroute(\"/some/path/B\");\n});\n\n从代码中可以看到，如果一个到达的请求包含路径 /some/path，首先第一个处理器向上下文添加了值，然后路由到了下一个处理器。第二个处理器转发到了路径 /some/path/B，该处理器最后结束了响应。\n您可以使用路径或者同时使用路径和方法来转发。注意，基于方法的重定向可能会带来安全问题，例如将一个通常安全的 GET 请求可能会成为 DELETE。\n也可以在失败处理器中转发。由于转发的性质，在这种情况下，当前的状态码和失败原因也会被重置。因此在转发后的处理器应该根据需要生成正确的状态码，例如：\nrouter.get(\"/my-pretty-notfound-handler\").handler(ctx -> {\n ctx.response()\n .setStatusCode(404)\n .end(\"NOT FOUND fancy html here!!!\");\n});\n\nrouter.get().failureHandler(ctx -> {\n if (ctx.statusCode() == 404) {\n ctx.reroute(\"/my-pretty-notfound-handler\");\n } else {\n ctx.next();\n }\n});\n\n子路由\n当您有很多处理器的情况下，合理的方式是将它们分隔为多个 Router。这也有利于您在多个不用的应用中通过设置不同的根路径来复用处理器。\n您可以通过将一个 Router 挂载到另一个 Router 的挂载点上来实现。挂载的 Router 被称为子路由（Sub Router）。Sub router 上也可以挂载其他的 sub router。因此，您可以包含若干级别的 sub router。\n让我们看一个 sub router 挂载到另一个 Router 上的例子：\n这个 sub router 维护了一系列处理器，对应了一个虚构的 REST API。我们会将它挂载到另一个 Router 上。\n例子忽略了 REST API 的具体实现：\nRouter restAPI = Router.router(vertx);\n\nrestAPI.get(\"/products/:productID\").handler(rc -> {\n\n // TODO 查找产品信息\n rc.response().write(productJSON);\n\n});\n\nrestAPI.put(\"/products/:productID\").handler(rc -> {\n\n // TODO 添加新的产品\n rc.response().end();\n\n});\n\nrestAPI.delete(\"/products/:productID\").handler(rc -> {\n\n // TODO 删除产品\n rc.response().end();\n\n});\n\n如果这个 Router 是一个顶级的 Router，那么例如 /products/product1234 这种 URL 的 GET/PUT/DELETE 请求都会调用这个 API。\n如果我们已经有了一个网站包含以下的 Router：\nRouter mainRouter = Router.router(vertx);\n\n// 处理静态资源\nmainRouter.route(\"/static/*\").handler(myStaticHandler);\n\nmainRouter.route(\".*\\\\.templ\").handler(myTemplateHandler);\n\n我们可以将这个 sub router 通过一个挂载点挂载到主 router 上，这个例子使用了 /preoductAPI：\nmainRouter.mountSubRouter(\"/productsAPI\", restAPI);\n\n这意味着这个 REST API 现在可以通过这种路径访问：/productsAPI/products/product1234。\n本地化\nVert.x Web 解析 Accept-Language 消息头并提供了一些识别客户端偏好的语言，以及提供通过 quality 排序的语言偏好列表的方法。\nRoute route = router.get(\"/localized\").handler( rc -> {\n //虽然通过一个 switch 循环有点奇怪，我们必须按顺序选择正确的本地化方式\n for (LanguageHeader language : rc.acceptableLanguages()) {\n switch (language.tag()) {\n case \"en\":\n rc.response().end(\"Hello!\");\n return;\n case \"fr\":\n rc.response().end(\"Bonjour!\");\n return;\n case \"pt\":\n rc.response().end(\"Olá!\");\n return;\n case \"es\":\n rc.response().end(\"Hola!\");\n return;\n }\n }\n // 我们不知道用户的语言，因此返回这个信息：\n rc.response().end(\"Sorry we don't speak: \" + rc.preferredLocale());\n});\n\n方法 acceptableLocales 会返回客户端能够理解的排序好的语言列表。\n如果您只关心用户偏好的语言，那么使用 preferredLocale 会返回列表的第一个元素。\n如果用户没有提供，则返回空。\n默认的 404 处理器\n如果没有为请求匹配到任何路由，Vert.x Web 会声明一个 404 错误。\n这可以被您自己实现的处理器处理，或者被我们提供的专用错误处理器（failureHandler）处理。\n如果没有提供错误处理器，Vert.x Web 会发送一个基本的 404 (Not Found) 响应。\n错误处理\n和设置处理器处理请求一样，您可以设置处理器处理路由过程中的失败。\n失败处理器和普通的处理器具有完全一样的路由匹配规则。\n例如您可以提供一个失败处理器只处理在某个路径上发生的失败，或某个 HTTP 方法。\n这允许您在应用的不同部分设置不同的失败处理器。\n下面例子中的失败处理器只会在路由路径为 /somepath/ 的 GET 请求失败时被调用：\nRoute route = router.get(\"/somepath/*\");\n\nroute.failureHandler(frc -> {\n\n // 如果在处理路径以 `/somepath/` 开头的请求过程中发生错误，会调用这个处理器\n\n});\n\n当一个处理器抛出异常，或者一个处理器通过了 fail 方法指定了 HTTP 状态码时，会执行路由的失败处理。\n从一个处理器捕捉到异常时会标记一个状态码为 500 的错误。\n在处理这个错误时，RoutingContext 会被传递到失败处理器里，失败处理器可以通过获取到的错误或错误编码来构造失败的响应内容。\nRoute route1 = router.get(\"/somepath/path1/\");\n\nroute1.handler(routingContext -> {\n\n // 这里抛出一个 RuntimeException\n throw new RuntimeException(\"something happened!\");\n\n});\n\nRoute route2 = router.get(\"/somepath/path2\");\n\nroute2.handler(routingContext -> {\n // 这里故意将请求处理为失败状态\n // 例如 403 - 禁止访问\n routingContext.fail(403);\n\n});\n\n// 定义一个失败处理器，上述的处理器发生错误时会调用这个处理器\nRoute route3 = router.get(\"/somepath/*\");\n\nroute3.failureHandler(failureRoutingContext -> {\n\n int statusCode = failureRoutingContext.statusCode();\n\n // 对于 RuntimeException 状态码会是 500，否则是 403\n HttpServerResponse response = failureRoutingContext.response();\n response.setStatusCode(statusCode).end(\"Sorry! Not today\");\n\n});\n\n某些情况下失败处理器会由于使用了不支持的字符集作为状态消息而导致错误。在这种情况下，Vert.x Web 会将状态消息替换为状态码的默认消息。\n这是为了保证 HTTP 协议的语义，而不至于崩溃并断开 socket 导致协议运行的不完整。\n处理请求消息体\n您可以使用消息体处理器 BodyHandler 来获取请求的消息体，限制消息体大小，或者处理文件上传。\n您需要保证消息体处理器能够匹配到所有您需要这个功能的请求。\n由于它需要在所有异步执行之前处理请求的消息体，因此这个处理器要尽可能早地设置到 router 上。\nrouter.route().handler(BodyHandler.create());\n\n获取请求的消息体\n如果您知道消息体的类型是 JSON，您可以使用 getBodyAsJson；如果您知道它的类型是字符串，您可以使用 getBodyAsString；否则可以通过 getBody 作为 Buffer 来处理。\n限制消息体大小\n如果要限制请求消息体的大小，可以在创建消息体处理器时使用 setBodyLimit 来指定消息体的最大字节数。这对于规避由于过大的消息体导致的内存溢出的问题很有用。\n如果尝试发送一个大于最大值的消息体，则会得到一个 HTTP 状态码 413 - Request Entity Too Large 的响应。\n默认的没有消息体大小限制。\n合并表单属性\n消息体处理器默认地会合并表单属性到请求的参数里。\n如果您不需要这个行为，可以通过 setMergeFormAttributes 来禁用。\n处理文件上传\n消息体处理器也可以用于处理 Multipart 的文件上传。\n当消息体处理器匹配到请求时，所有上传的文件会被自动地写入到上传目录中，默认的该目录为 file-uploads。\n每一个上传的文件会被自动生成一个文件名，并可以通过 RoutingContext 的 fileUploads 来获得。\n以下是一个例子：\nrouter.route().handler(BodyHandler.create());\n\nrouter.post(\"/some/path/uploads\").handler(routingContext -> {\n\n Set uploads = routingContext.fileUploads();\n\n // 执行上传处理\n\n});\n\n每一个上传的文件通过一个 FileUpload 对象来描述，通过这个对象可以获得名称、文件名、大小等属性。\n处理 Cookie\nVert.x Web 通过 Cookie 处理器 CookieHandler 来支持 cookie。\n您需要保证 cookie 处理器器能够匹配到所有您需要这个功能的请求。\nrouter.route().handler(CookieHandler.create());\n\n操作 Cookie\n您可以使用 getCookie 来通过名称获取 cookie 值，或者使用 cookies 获取整个集合。\n使用 removeCookie 来删除 cookie。\n使用 addCookie 来添加 cookie。\n当向响应中写入响应消息头时，cookie 的集合会自动被回写到响应里，这样浏览器就可以存储下来。\ncookie 是使用 Cookie 对象来表述的。您可以通过它来获取名称、值、域名、路径或 cookie 的其他属性。\n以下是一个查询和添加 cookie 的例子：\nrouter.route().handler(CookieHandler.create());\n\nrouter.route(\"some/path/\").handler(routingContext -> {\n\n Cookie someCookie = routingContext.getCookie(\"mycookie\");\n String cookieValue = someCookie.getValue();\n\n // 使用 cookie 执行某些操作\n\n // 添加一个 cookie，会自动回写到响应里\n routingContext.addCookie(Cookie.cookie(\"othercookie\", \"somevalue\"));\n});\n\n处理会话\nVert.x Web 提供了开箱即用的会话(session)支持。\n会话维持了 HTTP 请求和浏览器会话之间的关系，并提供了可以设置会话范围的信息的能力，例如一个购物篮。\nVert.x Web 使用会话 cookie(5) 来标示一个会话。会话 cookie 是临时的，当浏览器关闭时会被删除。\n我们不会在会话 cookie 中设置实际的会话数据，这个 cookie 只是在服务器上查找实际的会话数据时使用的标示。这个标示是一个通过安全的随机过程生成的 UUID，因此它是无法推测的(6)。\nCookie 会在 HTTP 请求和响应之间传递。因此通过 HTTPS 来使用会话功能是明智的。如果您尝试直接通过 HTTP 使用会话，Vert.x Web 会给于警告。\n您需要在匹配的 Route 上注册会话处理器 SessionHandler 来启用会话功能，并确保它能够在应用逻辑之前执行。\n会话处理器会创建会话 Cookie 并查找会话信息，您不需要自己来实现。\n会话存储\n您需要提供一个会话存储对象来创建会话处理器。会话存储用于维持会话数据。\n会话存储持有一个伪随机数生成器（PRNG）用于安全地生成会话标示。PRNG 是独立于存储的，这意味着对于给定的存储 A 的会话标示是不能够派发出存储 B 的会话标示的，因为他们具有不同的种子和状态。\nPRNG 默认使用混合模式，阻塞式地刷新种子，非阻塞式地生成随机数(7)。PRNG 会每隔 5 分钟使用一个新的 64 位的熵作为种子。这个策略可以通过系统属性来设置：\n\nio.vertx.ext.auth.prng.algorithm e.g.: SHA1PRNG\nio.vertx.ext.auth.prng.seed.interval e.g.: 1000 (every second)\nio.vertx.ext.auth.prng.seed.bits e.g.: 128\n\n大多数用户并不需要配置这些值，除非您发现应用的性能被 PRNG 的算法所影响。\nVert.x Web 提供了两种开箱即用的会话存储实现，您也可以编写您自己的实现。\n本地会话存储\n该存储将会话保存在内存中，并只在当前实例中有效。\n这个存储适用于您只有一个 Vert.x 实例的情况，或者您正在使用粘性会话。也就是说您可以配置您的负载均衡器来确保所有请求（来自同一用户的）永远被派发到同一个 Vert.x 实例上。\n如果您不能够保证这一点，那么就不要使用这个存储。这会导致请求被派发到无法识别这个会话的服务器上。\n本地会话存储基于本地的共享 Map来实现，并包含了一个用于清理过期会话的回收器。\n回收的周期可以通过 LocalSessionStore.create 来配置。\n以下是一些创建 LocalSessionStore 的例子：\nSessionStore store1 = LocalSessionStore.create(vertx);\n\n// 通过指定的 Map 名称创建了一个本地会话存储\n// 这适用于您在同一个 Vert.x 实例中有多个应用，并且希望不同的应用使用不同的 Map 的情况\nSessionStore store2 = LocalSessionStore.create(vertx, \"myapp3.sessionmap\");\n\n// 通过指定的 Map 名称创建了一个本地会话存储\n// 设置了会话的过期时间为 10 秒\nSessionStore store3 = LocalSessionStore.create(vertx, \"myapp3.sessionmap\", 10000);\n\n集群会话存储\n该存储将会话保存在分布式 Map 中，该 Map 可以在 Vert.x 集群中共享访问。\n这个存储适用于您没有使用粘性会话的情况。比如您的负载均衡器会将来自同一个浏览器的不同请求转发到不同的服务器上。\n通过这个存储，您的会话可以被集群中的任何节点访问。\n如果要使用集群会话存储，您需要确保您的 Vert.x 实例是集群模式的。\n以下是一些创建 ClusteredSessionStore 的例子：\nVertx.clusteredVertx(new VertxOptions().setClustered(true), res -> {\n\n Vertx vertx = res.result();\n\n // 创建了一个默认的集群会话存储\n SessionStore store1 = ClusteredSessionStore.create(vertx);\n\n // 通过指定的 Map 名称创建了一个集群会话存储\n // 这适用于您在集群中有多个应用，并且希望不同的应用使用不同的 Map 的情况\n SessionStore store2 = ClusteredSessionStore.create(vertx, \"myclusteredapp3.sessionmap\");\n});\n\n创建会话处理器\n当您创建会话存储之后，您可以创建一个会话处理器，并添加到 Route 上。您需要确保会话处理器在您的应用处理器之前被执行。\n由于会话处理器需要使用 Cookie 来查找会话，因此您还需要包含一个 Cookie 处理器。这个 Cookie 处理器需要在会话处理器之前被执行。\n以下是例子：\nRouter router = Router.router(vertx);\n\n// 我们首先需要一个 cookie 处理器\nrouter.route().handler(CookieHandler.create());\n\n// 用默认值创建一个集群会话存储\nSessionStore store = ClusteredSessionStore.create(vertx);\n\nSessionHandler sessionHandler = SessionHandler.create(store);\n\n// 确保所有请求都会经过 session 处理器\nrouter.route().handler(sessionHandler);\n\n// 您自己的应用处理器\nrouter.route(\"/somepath/blah/\").handler(routingContext -> {\n\n Session session = routingContext.session();\n session.put(\"foo\", \"bar\");\n // etc\n\n});\n\n会话处理器会自动从会话存储中查找会话（如果没有则创建），并在您的应用处理器执行之前设置在上下文中。\n使用会话\n在您的处理器中，您可以通过 session 方法来访问会话对象。\n您可以通过 put 方法来向会话中设置数据，通过 get 方法来获取数据，通过 remove 方法来删除数据。\n会话中的键的类型必须是字符串。本地会话存储的值可以是任何类型；集群会话存储的值类型可以是基本类型，或者 Buffer、JsonObject、JsonArray 或可序列化对象。因为这些值需要在集群中进行序列化。\n以下是操作会话数据的例子：\nrouter.route().handler(CookieHandler.create());\nrouter.route().handler(sessionHandler);\n\n// 您的应用处理器\nrouter.route(\"/somepath/blah\").handler(routingContext -> {\n\n Session session = routingContext.session();\n\n // 向会话中设置值\n session.put(\"foo\", \"bar\");\n\n // 从会话中获取值\n int age = session.get(\"age\");\n\n // 从会话中删除值\n JsonObject obj = session.remove(\"myobj\");\n\n});\n\n在响应完成后会话会自动回写到存储中。\n您可以使用 destroy 方法来销毁一个会话。这会将这个会话同时从上下文和存储中删除。注意，在删除会话之后，下一次通过浏览器访问并经过会话处理器处理时，会自动创建新的会话。\n会话超时\n如果会话在指定的周期内没有被访问，则会超时。\n当请求到达，访问了会话，并且在响应完成向会话存储回写会话时，会话会被标记为被访问的。\n您也可以通过 setAccessed 来人工指定会话被访问。\n可以在创建会话处理器时配置超时时间。默认的超时时间是 30 分钟。\n认证/授权\nVert.x Web 提供了若干开箱即用的处理器来处理认证和授权。\n创建认证处理器\n您需要一个 AuthProvider 实例来创建认证处理器。Auth Provider 用于为用户提供认证和授权。Vert.x 在 vertx-auth 项目中提供了若干开箱即用的 Auth Provider。完整的 Auth Provider 的配置和用法请参考 Vertx Auth 的文档。\n以下是一个使用 Auth Provider 来创建认证处理器的例子：\nrouter.route().handler(CookieHandler.create());\nrouter.route().handler(SessionHandler.create(LocalSessionStore.create(vertx)));\n\nAuthHandler basicAuthHandler = BasicAuthHandler.create(authProvider);\n\n在您的应用中处理认证\n我们来假设您希望所有路径为 /private 的请求都需要认证控制。为了实现这个，您需要确保您的认证处理器匹配这个路径，并在您的应用处理器之前执行：\nrouter.route().handler(CookieHandler.create());\nrouter.route().handler(SessionHandler.create(LocalSessionStore.create(vertx)));\nrouter.route().handler(UserSessionHandler.create(authProvider));\n\nAuthHandler basicAuthHandler = BasicAuthHandler.create(authProvider);\n\n// 所有路径以 `/private` 开头的请求会被保护\nrouter.route(\"/private/*\").handler(basicAuthHandler);\n\nrouter.route(\"/someotherpath\").handler(routingContext -> {\n\n // 此处是公开的，不需要登录\n\n});\n\nrouter.route(\"/private/somepath\").handler(routingContext -> {\n\n // 此处需要登录\n\n // 这个值会返回 true\n boolean isAuthenticated = routingContext.user() != null;\n\n});\n\n如果认证处理器完成了授权和认证，它会向 RoutingContext 中注入一个 User 对象。您可以通过 user 方法在您的处理器中获取到该对象。\n如果您希望在回话中存储用户对象，以避免对所有的请求都执行认证过程，您需要使用会话处理器。确保它匹配了对应的路径，并且会在认证处理器之前执行。\n一旦您获取到了 user 对象，您可以通过编程的方式来使用它的相关方法为用户授权。\n如果您希望用户登出，您可以调用上下文的 clearUser 方法。\nHTTP 基础认证\nHTTP基础认证是适用于简单应用的简单认证手段。\n在这种认证方式下， 证书会以非加密的形式在 HTTP 请求中传输。因此，使用 HTTPS 而非 HTTP 来实现您的应用是非常必要的。\n当用户请求一个需要授权的资源，基础认证处理器会返回一个包含 WWW-Authenticate 消息头的 401 响应。浏览器会显示一个登录窗口并提示用户输入他们的用户名和密码。\n在这之后，浏览器会重新发送这个请求，并将用户名和密码以 Base64 编码的形式包含在请求的 Authorization 消息头里。\n当基础认证处理器收到了这些信息，它会使用用户名和密码调用配置的 AuthProvider 来认证用户。如果认证成功则该处理器会尝试用户授权，如果也成功了则允许这个请求路由到后续的处理器里处理。否则，会返回一个 403 的响应拒绝访问。\n在设置认证处理器时可以指定一系列访问资源时需要的权限。\n重定向认证处理器\n重定向认证处理器用于当未登录的用户尝试访问受保护的资源时将他们重定向到登录页上。\n当用户提交登录表单，服务器会处理用户认证。如果成功，则将用户重定向到原始的资源上。\n则您可以配置一个 RedirectAuthHandler 对象来使用重定向处理器。\n您还需要配置用于处理登录页面的处理器，以及实际处理登录的处理器。我们提供了一个内置的处理器 FormLoginHandler 来处理登录的问题。\n这里是一个简单的例子，使用了一个重定向认证处理器并使用默认的重定向 url /loginpage。\nrouter.route().handler(CookieHandler.create());\nrouter.route().handler(SessionHandler.create(LocalSessionStore.create(vertx)));\nrouter.route().handler(UserSessionHandler.create(authProvider));\n\nAuthHandler redirectAuthHandler = RedirectAuthHandler.create(authProvider);\n\n// 所有路径以 `/private` 开头的请求会被保护\nrouter.route(\"/private/*\").handler(redirectAuthHandler);\n\n// 处理登录请求\n// 您的登录页需要 POST 登录表单数据\nrouter.post(\"/login\").handler(FormLoginHandler.create(authProvider));\n\n// 处理静态资源，例如您的登录页\nrouter.route().handler(StaticHandler.create());\n\nrouter.route(\"/someotherpath\").handler(routingContext -> {\n // 此处是公开的，不需要登录\n});\n\nrouter.route(\"/private/somepath\").handler(routingContext -> {\n\n // 此处需要登录\n\n // 这个值会返回 true\n boolean isAuthenticated = routingContext.user() != null;\n\n});\n\nJWT 授权\nJWT 授权通过权限来保护资源不被未为授权的用户访问。\n使用这个处理器涉及 2 个步骤：\n\n配置一个处理器用于颁发令牌（或依靠第三方）\n配置授权处理器来过滤请求\n\n注意，这两个处理器应该只能通过 HTTPS 访问。否则可能会引起由流量嗅探引起的会话劫持。\n这里是一个派发令牌的例子：\nRouter router = Router.router(vertx);\n\nJsonObject authConfig = new JsonObject().put(\"keyStore\", new JsonObject()\n .put(\"type\", \"jceks\")\n .put(\"path\", \"keystore.jceks\")\n .put(\"password\", \"secret\"));\n\nJWTAuth authProvider = JWTAuth.create(vertx, authConfig);\n\nrouter.route(\"/login\").handler(ctx -> {\n // 这是一个例子，认证会由另一个 provider 执行\n if (\"paulo\".equals(ctx.request().getParam(\"username\")) && \"secret\".equals(ctx.request().getParam(\"password\"))) {\n ctx.response().end(authProvider.generateToken(new JsonObject().put(\"sub\", \"paulo\"), new JWTOptions()));\n } else {\n ctx.fail(401);\n }\n});\n\n注意，对于持有令牌的客户端，唯一需要做的是在 所有 后续的的 HTTP 请求中包含消息头 Authoriztion 并写入 Bearer ，例如：\nRouter router = Router.router(vertx);\n\nJsonObject authConfig = new JsonObject().put(\"keyStore\", new JsonObject()\n .put(\"type\", \"jceks\")\n .put(\"path\", \"keystore.jceks\")\n .put(\"password\", \"secret\"));\n\nJWTAuth authProvider = JWTAuth.create(vertx, authConfig);\n\nrouter.route(\"/protected/*\").handler(JWTAuthHandler.create(authProvider));\n\nrouter.route(\"/protected/somepage\").handler(ctx -> {\n // 一些处理过程\n});\n\nJWT 允许您向令牌中添加任何您需要的信息，只需要在创建令牌时向 JsonObject 参数中添加数据即可。这样做服务器上不存在任何的会话状态，您可以在不依赖集群会话数据的情况下对应用进行扩展。\nJsonObject authConfig = new JsonObject().put(\"keyStore\", new JsonObject()\n .put(\"type\", \"jceks\")\n .put(\"path\", \"keystore.jceks\")\n .put(\"password\", \"secret\"));\n\nJWTAuth authProvider = JWTAuth.create(vertx, authConfig);\n\nauthProvider.generateToken(new JsonObject().put(\"sub\", \"paulo\").put(\"someKey\", \"some value\"), new JWTOptions());\n\n在消费时用同样的方式：\nHandler handler = rc -> {\n String theSubject = rc.user().principal().getString(\"sub\");\n String someKey = rc.user().principal().getString(\"someKey\");\n};\n\n配置所需的权限\n您可以对认证处理器配置访问资源所需的权限。\n默认的，如果不配置权限，那么只要登录了就可以访问资源。否则，用户不仅需要登录，而且需要具有所需的权限。\n以下的例子定义了一个应用，该应用的不同部分需要不同的权限。注意，权限的含义取决于您使用的的 Auth Provider。例如一些支持角色/权限的模型，另一些可能是其他的模型。\nAuthHandler listProductsAuthHandler = RedirectAuthHandler.create(authProvider);\nlistProductsAuthHandler.addAuthority(\"list_products\");\n\n// 需要 `list_products` 权限来列举产品\nrouter.route(\"/listproducts/*\").handler(listProductsAuthHandler);\n\nAuthHandler settingsAuthHandler = RedirectAuthHandler.create(authProvider);\nsettingsAuthHandler.addAuthority(\"role:admin\");\n\n// 只有 `admin` 可以访问 `/private/settings`\nrouter.route(\"/private/settings/*\").handler(settingsAuthHandler);\n\n静态资源服务\nVert.x Web 提供了一个开箱即用的处理器来提供静态的 Web 资源。您可以非常容易地编写静态的 Web 服务器。\n您可以使用静态资源处理器 StaticHandler 来提供诸如 .html、.css、.js 或其他类型的静态资源。\n每一个被静态资源处理器处理的请求都会返回文件系统的某个目录或 classpath 里的文件。文件的根目录是可以配置的，默认为 webroot。\n在以下的例子中，所有路径以 /static 开头的请求都会对应到 webroot 目录：\nrouter.route(\"/static/*\").handler(StaticHandler.create());\n\n例如，对于一个路径为 /static/css/mystyles.css 的请求，静态处理器会在该路径中查找文件 webroot/css/mystyle.css。\n它也会在 classpath 中查找文件 webroot/css/mystyle.css。这意味着您可以将所有的静态资源打包到一个 jar 文件（或 fat-jar）里进行分发。\n当 Vert.x 在 classpath 中第一次找到一个资源时，会将它提取到一个磁盘的缓存目录中以避免每一次都重新提取。\n这个处理器能够处理范围请求。当客户端请求静态资源时，该处理器会添加一个范围单位的说明到响应的消息头 Accept-Ranges 里来通知客户端它支持范围请求。如果后续请求的消息头 Range 里包含了正确的单位以及起始、终止位置，则客户端将收到包含了的 Content-Range 消息头的部分响应。\n配置缓存\n默认的，为了让浏览器有效地缓存文件，静态处理器会设置缓存消息头。\nVert.x Web 会在响应里设置这些消息头：cache-control、last-modified、date。\ncache-control 的默认值为 max-age=86400，也就是一天。可以通过 setMaxAgeSeconds 方法来配置。\n当浏览器发送了携带消息头 if-modified-since 的 GET 或 HEAD 请求时，如果对应的资源在该日期之后没有修改过，则会返回一个 304 状态码通知浏览器使用本地的缓存资源。\n如果不需要缓存的消息头，可以通过 setCachingEnabled 方法将其禁用。\n如果启用了缓存处理，则 Vert.x Web 会将资源的最后修改日期缓存在内存里，以此来避免频繁地访问取磁盘来检查修改时间。\n缓存有过期时间，在这个时间之后，会重新访问磁盘检查文件并更新缓存。\n默认的，如果您的文件永远不会发生变化，则缓存内容会永远有效。\n如果您的文件在服务器运行过程中可能发生变化，您可以通过 setFilesReadOnly 方法设置文件的只读属性为 false。\n您可以通过 setMaxCacheSize 方法来设置内存缓存的最大数量。通过 setCacheEntryTimeout 方法来设置缓存的过期时间。\n配置索引页\n所有访问根路径 / 的请求会被定位到索引页。默认的该文件为 index.html。可以通过 setIndexPage 方法来设置。\n配置跟目录\n默认的，所有资源都以 webroot 作为根目录。可以通过 setWebRoot 方法来配置。\n隐藏文件\n默认的，处理器会为隐藏文件提供服务（文件名以 . 开头的文件）。\n如果您不需要为隐藏文件提供服务，可以通过 setIncludeHidden 方法来配置。\n列举目录\n静态资源处理器可以用于列举目录的文件。默认情况下该功能是关闭的。可以通过 setDirectoryListing 方法来启用。\n当该功能启用时，会根据客户端请求的消息头 accept 所表示的类型来返回相应的结果。\n例如对于 text/html 标示的请求，会使用通过 setDirectoryTemplate 方法设置的模板来渲染文件列表。\n禁用磁盘文件缓存\n默认情况下，Vert.x 会使用当前工作目录的子目录 .vertx 来在磁盘上缓存通过 classpath 服务的静态资源。这对于在生产环境中通过 fat-jar 来部署的服务是很重要的。因为每一次都通过 classpath 来提取文件是低效的。\n这在开发时会导致一个问题，例如当您通过 IDE 的运行配置来启动您的应用时，如果您修改了文件，缓存的文件时不会被更新的。\n您可以通过设置系统属性 vertx.disableFileCaching 为 false 来禁用文件缓存。\n处理跨域资源共享\n跨域资源共享（CORS，Cross Origin Resource Sharing）是一个安全机制。该机制允许了浏览器在一个域名下访问另一个域名的资源。\nVert.x Web 提供了一个处理器 CorsHandler 来为您处理 CORS 协议。\n这是一个例子：\nrouter.route().handler(CorsHandler.create(\"vertx\\\\.io\").allowedMethod(HttpMethod.GET));\n\nrouter.route().handler(routingContext -> {\n\n // 您的应用处理\n\n});\n\n模板引擎\nVert.x Web 为若干流行的模板引擎提供了开箱即用的支持，通过这种方式来提供生成动态页面的能力。您也可以很容易地添加您自己的实现。\n模板引擎 TemplateEngine 定义了使用模板引擎的接口，当渲染模板时会调用 render 方法。\n最简单的使用模板的方式不是直接调用模板引擎，而是使用模板处理器 TemplateHandler。这个处理器会根据 HTTP 请求的路径来调用模板引擎。\n默认的，模板处理器会在 templates 目录中查找模板文件。这是可以配置的。\n该处理器会返回渲染的结果，并默认设置 Content-Type 消息头为 text/html。这也是可以配置的。\n您需要在创建模板处理器时提供您需要使用的模板引擎的实例。\n模板引擎的实现没有内嵌在 Vert.x Web 里，您需要配置您的项目来访问它们。Vert.x Web 提供了每一种模板引擎的配置。\n以下是一个例子：\nTemplateEngine engine = HandlebarsTemplateEngine.create();\nTemplateHandler handler = TemplateHandler.create(engine);\n\n// 这会将所有以 `/dynamic` 开头的请求路由到模板处理器上\n// 例如 /dynamic/graph.hbs 会查找模板 /templates/graph.hbs\nrouter.get(\"/dynamic/*\").handler(handler);\n\n// 将所有以 `.hbs` 结尾的请求路由到模板处理器上\nrouter.getWithRegex(\".+\\\\.hbs\").handler(handler);\n\nMVEL 模板引擎\n您需要在您的项目中添加这些依赖来使用 MVEL 模板引擎：io.vertx:vertx-web-templ-mvel:3.4.1。通过这个方法来创建 MVEL 模板引擎的实例：io.vertx.ext.web.templ.MVELTemplateEngine#create()。\n在使用 MVEL 模板引擎时，如果不指定模板文件的扩展名，则默认会查找扩展名为 .templ 的文件。\n在 MVEL 模板中可以通过 context 变量来访问路由上下文 RoutingContext 对象。这也意味着您可以基于上下文里的任何信息来渲染模板，包括请求、响应、会话或者上下文数据。\n这是一个例子：\nThe request path is @{context.request().path()}\n\nThe variable 'foo' from the session is @{context.session().get('foo')}\n\nThe value 'bar' from the context data is @{context.get('bar')}\n\n关于如何编写 MVEL 模板，请参考 MVEL 模板文档。\nJade 模板引擎\n\n译者注：Jade 已更名为 Pug。\n\n您需要在您的项目中添加这些依赖来使用 Jade 模板引擎：io.vertx:vertx-web-templ-jade:3.4.1。通过这个方法来创建 Jade 模板引擎的实例：io.vertx.ext.web.templ.JadeTemplateEngine#create()。\n在使用 Jade 模板引擎时，如果不指定模板文件的扩展名，则默认会查找扩展名为 .jade 的文件。\n在 Jade 模板中可以通过 context 变量来访问路由上下文 RoutingContext 对象。这也意味着您可以基于上下文里的任何信息来渲染模板，包括请求、响应、会话或者上下文数据。\n这是一个例子：\n!!! 5\nhtml\n head\n title= context.get('foo') + context.request().path()\n body\n\n关于如何编写 Jade 模板，请参考 Jade4j 文档。\nHandlebars 模板引擎\n您需要在您的项目中添加这些依赖来使用 Handlebars：io.vertx:vertx-web-templ-handlebars:3.4.1。通过这个方法来创建 Handlebars 模板引擎的实例：io.vertx.ext.web.templ.HandlebarsTemplateEngine#create()。\n在使用 Handlebars 模板引擎时，如果不指定模板文件的扩展名，则默认会查找扩展名为 .hbs 的文件。\nHandlebars 不允许在模板中随意地调用对象的方法，因此我们不能像对待其他模板引擎一样将路由上下文传递到引擎里并让模板来识别它。\n替代方案是，可以使用 data 来访问上下文数据。\n如果您要访问某些上下文数据里不存在的信息，比如请求的路径、请求参数或者会话等，您需要在模板处理器执行之前将他们添加到上下文数据里，例如：\nTemplateHandler handler = TemplateHandler.create(engine);\n\nrouter.get(\"/dynamic\").handler(routingContext -> {\n\n routingContext.put(\"request_path\", routingContext.request().path());\n routingContext.put(\"session_data\", routingContext.session().data());\n\n routingContext.next();\n});\n\nrouter.get(\"/dynamic/\").handler(handler);\n\n关于如何编写 Handlebars 模板，请参考 Handlebars Java 文档。\nThymeleaf 模板引擎\n您需要在您的项目中添加这些依赖来使用 Thymeleaf：io.vertx:vertx-web-templ-thymeleaf:3.4.1。通过这个方法来创建 Thymeleaf 模板引擎的实例：io.vertx.ext.web.templ.ThymeleafTemplateEngine#create()。\n在使用 Thymeleaf 模板引擎时，如果不指定模板文件的扩展名，则默认会查找扩展名为 .html 的文件。\n在 Thymeleaf 模板中可以通过 context 变量来访问路由上下文 RoutingContext 对象。这也意味着您可以基于上下文里的任何信息来渲染模板，包括请求、响应、会话或者上下文数据。\n这是一个例子：\n[snip]\n\n\n\n\n\n[snip]\n\n关于如何编写 Thymeleaf 模板，请参考 Thymeleaf 文档。\nApache FreeMarker 模板引擎\n您需要在您的项目中添加这些依赖来使用 Apache FreeMarker：io.vertx:vertx-web-templ-freemarker:3.4.1。通过这个方法来创建 Apache FreeMarker 模板引擎的实例：io.vertx.ext.web.templ.FreeMarkerTemplateEngine#create()。\n在使用 Apache FreeMarker 模板引擎时，如果不指定模板文件的扩展名，则默认会查找扩展名为 .ftl 的文件。\n在 Apache FreeMarker 模板中可以通过 context 变量来访问路由上下文 RoutingContext 对象。这也意味着您可以基于上下文里的任何信息来渲染模板，包括请求、响应、会话或者上下文数据。\n这是一个例子：\n[snip]\n\n\n\n\n\n[snip]\n\n关于如何编写 Apache FreeMarker 模板，请参考 Apache FreeMarker 文档。\nPebble 模板引擎\n您需要在您的项目中添加这些依赖来使用 Pebble：io.vertx:vertx-web-templ-pebble:3.4.0-SNAPSHOT。通过这个方法来创建 Pebble 模板引擎的实例：io.vertx.ext.web.templ.PebbleTemplateEngine#create()。\n在使用 Pebble 模板引擎时，如果不指定模板文件的扩展名，则默认会查找扩展名为 .peb 的文件。\n在 Pebble 模板中可以通过 context 变量来访问路由上下文 RoutingContext 对象。这也意味着您可以基于上下文里的任何信息来渲染模板，包括请求、响应、会话或者上下文数据。\n这是一个例子：\n[snip]\n\n\n\n\n\n[snip]\n\n关于如何编写 Pebble 模板，请参考 Pebble 文档。\n错误处理\n您可以用模板处理器来渲染错误信息，或者使用 Vert.x Web 内置的一个 ”漂亮“ 的、开箱即用的错误处理器来渲染错误页面。\n这个处理器是 ErrorHandler。您只需要在需要覆盖到的路径上将它设置为失败处理器(9)来使用它。\n请求日志\nVert.x Web 提供了一个用于记录 HTTP 请求的处理器 LoggerHandler。\n默认的，请求会通过 Vert.x 日志来记录，或者也可以配置为 jul 日志、log4j 或 slf4j。详见 LoggerFormat。\n提供网页图标\nVert.x Web 通过内置的处理器 FaviconHandler 来提供网页图标。\n图标可以指定为文件系统上的某个路径，否则 Vert.x Web 默认会在 classpath 上寻找 favicon.ico 文件。这意味着您可以将图标打包到您的应用的 jar 包里。\n超时处理器\nVert.x Web 提供了一个超时处理器，可以在处理时间过长时将请求超时。\n通过 TimeoutHandler 对象来进行配置。\n如果一个请求在响应之前超时，则会给客户端返回一个 503 的响应。\n下面的例子设置了一个超时处理器。对于所有以 /foo 路径开头的请求，都会在执行 5 秒后自动超时。\nrouter.route(\"/foo/\").handler(TimeoutHandler.create(5000));\n\n响应时间处理器\n该处理器会将从接收到请求到写入响应的消息头之间的毫秒数写入到响应的 x-response-time 里，例如：\nx-response-time: 1456ms\nContent Type 处理器\n该处理器 ResponseContentTypeHandler 会自动设置响应的 Content-Type 消息头。假设我们要构建一个 RESTful 的 Web 应用，我们需要在所有处理器里设置 Content-Type：\nrouter.get(\"/api/books\").produces(\"application/json\").handler(rc -> {\n findBooks(ar -> {\n if (ar.succeeded()) {\n rc.response().putHeader(\"Content-Type\", \"application/json\").end(toJson(ar.result()));\n } else {\n rc.fail(ar.cause());\n }\n });\n});\n\n随着 API 接口数量的增长，设置 Content-Type 会变得很麻烦。可以通过在 Route 上添加 ResponseContentTypeHandler 来避免这个问题：\nrouter.route(\"/api/*\").handler(ResponseContentTypeHandler.create());\nrouter.get(\"/api/books\").produces(\"application/json\").handler(rc -> {\n findBooks(ar -> {\n if (ar.succeeded()) {\n rc.response().end(toJson(ar.result()));\n } else {\n rc.fail(ar.cause());\n }\n });\n});\n\n这个处理器会通过 getAcceptableContentType 方法来选择适当的 Content-Type。因此，您可以很容易地使用同一个处理器来提供不同类型的数据：\nrouter.route(\"/api/*\").handler(ResponseContentTypeHandler.create());\nrouter.get(\"/api/books\").produces(\"text/xml\").produces(\"application/json\").handler(rc -> {\n findBooks(ar -> {\n if (ar.succeeded()) {\n if (rc.getAcceptableContentType().equals(\"text/xml\")) {\n rc.response().end(toXML(ar.result()));\n } else {\n rc.response().end(toJson(ar.result()));\n }\n } else {\n rc.fail(ar.cause());\n }\n });\n});\n\nSockJS\nSockJS 是一个客户端的 JavaScript 库。它提供了类似 WebSocket 的接口为您和 SockJS 服务端建立连接。您不必关注浏览器或网络是否真的是 WebSocket。\n它提供了若干不同的传输方式，并在运行时根据浏览器和网络的兼容性来选择使用哪种传输方式处理。\n所有这些对您是透明的，您只需要简单地使用类似 WebSocket 的接口。\n请访问 SockJS 官方网站 来获取 SockJS 的详细信息。\nSockJS 处理器\nVert.x Web 提供了一个开箱即用的处理器 SockJSHandler 来让您在 Vert.x Web 应用中使用 SockJS。\n您需要通过 SockJSHandler.create 方法为每一个 SockJS 的应用创建这个处理器。您也可以在创建处理器时通过 SockJSHandlerOptions 对象来指定配置选项。\nRouter router = Router.router(vertx);\n\nSockJSHandlerOptions options = new SockJSHandlerOptions().setHeartbeatInterval(2000);\n\nSockJSHandler sockJSHandler = SockJSHandler.create(vertx, options);\n\nrouter.route(\"/myapp/*\").handler(sockJSHandler);\n\n处理 SockJS 套接字\n您可以在服务器端设置一个处理器，这个处理器会在每次客户端创建连接时被调用：\n调用这个处理器的参数是一个 SockJSSocket 对象。这是一个类似套接字的接口，您可以向使用 NetSocket 和 WebSocket 那样通过它来读写数据。它实现了 ReadStream 和 WriteStream 接口，因此您可以将它套用（pump）到其他的读写流上。\n下面的例子中的 SockJS 处理器直接使用了它读取到的数据进行回写：\nRouter router = Router.router(vertx);\n\nSockJSHandlerOptions options = new SockJSHandlerOptions().setHeartbeatInterval(2000);\n\nSockJSHandler sockJSHandler = SockJSHandler.create(vertx, options);\n\nsockJSHandler.socketHandler(sockJSSocket -> {\n\n // 将数据回写\n sockJSSocket.handler(sockJSSocket::write);\n});\n\nrouter.route(\"/myapp/*\").handler(sockJSHandler);\n\nSockJS 客户端\n在客户端 JavaScript 环境里您需要通过 SockJS 的客户端库来建立连接。\nSockJS 客户端的地址\n完整的细节可以在 SockJS 的网站 中找到，简单来说您会像这样使用：\nvar sock = new SockJS('http://mydomain.com/myapp');\n\nsock.onopen = function() {\n console.log('open');\n};\n\nsock.onmessage = function(e) {\n console.log('message', e.data);\n};\n\nsock.onclose = function() {\n console.log('close');\n};\n\nsock.send('test');\n\nsock.close();\n\n配置 SockJS 处理器\n可以通过 SockJSHandlerOptions 对象来配置这个处理器的若干选项。\n\ninsertJSESSIONID\n\n在 cookie 中插入一个 JSESSIONID，这样负载均衡器可以保证 SockJS 会话永远转发到正确的服务器上。默认值为 true。\n\nsessionTimeout\n\n对于一个正在接收响应的客户端连接，如果一段时间内没有动作，则服务端会发出一个 close 事件。延时时间由这个配置决定。默认的服务端会在 5 秒之后发出这个 close 事件。(10)\n\nheartbeatInterval\n\n我们会每隔一段时间发送一个心跳包，用来避免由于请求时间过长导致连接被代理和负载均衡器关闭。默认的每隔 25 秒发送一个心跳包，可以通过这个设置来控制频率。\n\nmaxBytesStreaming\n\n大多数流式传输方式会在客户端保存响应的内容并且不会释放派发消息所使用的内存。这些传输方式需要定期执行垃圾回收。max_bytes_streaming 设置了每一个 http 流式请求所需要发送的最小字节数。超过这个值则客户端需要打开一个新的请求。将这个值设置得过小会失去流式的处理能力，使这个流式的传输方式表现得像一个轮训的传输方式一样。默认值是 128K。\n\nlibraryURL\n\n对于没有提供原生的跨域通信支持的浏览器，会使用 iframe 来进行通信。SockJS 服务器会提供一个简单的页面（在目标域名上）并放置在一个不可见的 iframe 里。在 iframe 里运行的代码和 SockJS 服务器运行在同一个域名下，因此不用担心跨域的问题。这个 iframe 也需要加载 SockJS 的客户端 JavaScript 库，这个配置就是用于指定这个 URL 的。默认情况下会使用最新发布的压缩版本 http://cdn.jsdelivr.net/sockjs/0.3.4/sockjs.min.js。\n\ndisabledTransports\n\n这个参数用于禁用某些传输方式。可能的值包括 WEBSOCKET、EVENT_SOURCE、HTML_FILE、JSON_P、XHR。\nSockJS 桥接 Event Bus\nVert.x Web 提供了一个内置的叫做 Event Bus Bridge 的 SockJS 套接字处理器。该处理器用于将服务器端的 Vert.x 的 Event Bus 扩展到客户端的 JavaScript 运行环境里。\n这将创建一个分布式的 Event Bus。这个 Event Bus 不仅可以在多个 Vert.x 实例中使用，还可以通过运行在浏览器里的 JavaScript 访问。\n由此，我们可以围绕浏览器和服务器构建一个庞大的分布式 Event Bus。只要服务器之间的链接存在，浏览器不需要每一次都与同一个服务器建立链接。\n这些是通过 Vert.x 提供的一个简单的客户端 JavaScript 库 vertx-eventbus.js 来实现的。它提供了一系列和服务器端的 Vert.x Event Bus 类似的 API。通过这些 API 可以发送或发布消息，或注册处理器来接收消息。\n一个 SockJS 套接字处理器会被安装到 SockJSHandler 上。这个处理器用于处理 SockJS 的数据并把它桥接到服务器端的 event bus 上。\nRouter router = Router.router(vertx);\n\nSockJSHandler sockJSHandler = SockJSHandler.create(vertx);\nBridgeOptions options = new BridgeOptions();\nsockJSHandler.bridge(options);\n\nrouter.route(\"/eventbus/*\").handler(sockJSHandler);\n\n在客户端通过使用 vertx-eventbus.js 库来和 Event Bus 建立连接，并发送/接收消息：\n\n\n\n\n\nvar eb = new EventBus('http://localhost:8080/eventbus');\n\neb.onopen = function() {\n\n // 设置了一个接收数据的处理器\n eb.registerHandler('some-address', function(error, message) {\n console.log('received a message: ' + JSON.stringify(message));\n });\n\n // 发送消息\n eb.send('some-address', {name: 'tim', age: 587});\n\n}\n\n\n\n这个例子做的第一件事是创建了一个 Event Bus 实例：\nvar eb = new EventBus('http://localhost:8080/eventbus');\n\n构造函数中的参数是连接到 Event Bus 使用的 URI。由于我们创建的桥接器是以 eventbus 作为前缀的，因此我们需要将 URI 指向这里。\n在连接打开之前，我们什么也做不了。当它打开后，会回调 onopen 函数处理。\n您可以通过依赖管理器来获取客户端库：\n\nMaven （在您的 pom.xml 文件里）\n\n\n io.vertx\n vertx-web\n 3.4.1\n client\n js\n\n\n\nGradle（在您的 build.gradle 文件里）\n\ncompile 'io.vertx:vertx-web:3.4.1:client'\n\n这个库也可以通过 NPM 和 Bower 来获取。\n注意， 这个 API 在 3.0.0 和 3.1.0 版本之间发生了变化，请检查变更日志。老版本的客户端仍然兼容，但新版本提供了更多的特性，并且更接近服务端的 Vert.x Event Bus API。\n安全的桥接\n如果您像上面的例子一样启动一个桥接器，并试图发送消息，您会发现您的消息神秘地失踪了。发生了什么？\n对于大多数的应用，您应该不希望客户端的 JavaScript 代码可以发送任何消息到任何的服务端处理器或其他所有浏览器上。\n例如，您可能在Event Bus 上注册了一个服务，用于访问和删除数据。但我们并不希望恶意的客户端能够通过这个服务来操作数据库中的数据。并且，我们也不希望客户端能够监听所有 event bus 上的地址。\n为了解决这个问题，SockJS 默认的会拒绝所有的消息。您需要告诉桥接器哪些消息是可以通过的。（例外情况是，所有的回复消息都是可以通过的）。\n换句话说，桥接器的行为像是配置了 deny-all 策略的防火墙。\n为桥接器配置哪些消息允许通过是很容易的。\n您可以通过调用桥接器时传入的 BridgeOptions 来配置匹配规则，指定哪些输入和输出的流量是允许通过的。\n每一个匹配规则对应一个 PermittedOptions 对象：\nsetAddress\n这个配置精确地定义了消息可以被发送到哪些地址。如果您需要通过精确的地址来控制消息的话，使用这个选项。\nsetAddressRegex\n这个配置通过正则表达式来定义消息可以被发送到哪些地址。如果您需要通过正则表达式来控制消息的话，使用这个选项。如果指定了 address，这个选项会被忽略。\nsetMatch\n这个配置通过消息的接口来控制消息是否可以发送。这个配置中定义的每一个字段必须在消息中存在，并且值一致。这个配置只能用于 JSON 格式的消息。\n对于一个输入的消息（例如通过客户端 JavaScript 发送到服务器），当消息到达时，Vert.x Web 会检查每一条输入许可。如果存在匹配，则消息可以通过。\n对于一个输出的消息（例如通过服务器端发送给客户端 JavaScript），当消息发送时，Vert.x Web 会检查每一条输出许可。如果存在匹配，则消息可以通过。\n实际的匹配过程如下：\n如果指定了 address 字段，并且消息的目标地址与 address 精确匹配，则匹配成功。\n如果没有指定 address 而是指定了 addressRegex 字段，并且消息的目标地址匹配了这个正则表达式，则匹配成功。\n如果指定了 match 字段，并且消息中包含了 match 对象中的所有键值对，则匹配成功。\n以下是例子：\nRouter router = Router.router(vertx);\n\nSockJSHandler sockJSHandler = SockJSHandler.create(vertx);\n\n\n// 允许客户端向地址 `demo.orderMgr` 发送消息\nPermittedOptions inboundPermitted1 = new PermittedOptions().setAddress(\"demo.orderMgr\");\n\n// 允许客户端向地址 `demo.orderMgr` 发送消息\n// 并且 `action` 的值为 `find`、`collecton` 的值为 `albums` 消息。\nPermittedOptions inboundPermitted2 = new PermittedOptions().setAddress(\"demo.persistor\")\n .setMatch(new JsonObject().put(\"action\", \"find\")\n .put(\"collection\", \"albums\"));\n\n// 允许 `wibble` 值为 `foo` 的消息.\nPermittedOptions inboundPermitted3 = new PermittedOptions().setMatch(new JsonObject().put(\"wibble\", \"foo\"));\n\n// 下面定义了如何允许服务端向客户端发送消息\n\n// 允许向客户端发送地址为 `ticker.mystock` 的消息\nPermittedOptions outboundPermitted1 = new PermittedOptions().setAddress(\"ticker.mystock\");\n\n// 允许向客户端发送地址以 `news.` 开头的消息（例如 news.europe, news.usa, 等）\nPermittedOptions outboundPermitted2 = new PermittedOptions().setAddressRegex(\"news\\\\..+\");\n\n// 将规则添加到 BridgeOptions 里\nBridgeOptions options = new BridgeOptions().\n addInboundPermitted(inboundPermitted1).\n addInboundPermitted(inboundPermitted1).\n addInboundPermitted(inboundPermitted3).\n addOutboundPermitted(outboundPermitted1).\n addOutboundPermitted(outboundPermitted2);\n\nsockJSHandler.bridge(options);\n\nrouter.route(\"/eventbus/*\").handler(sockJSHandler);\n\n消息授权\nEvent Bus 桥接器可以使用 Vert.x Web 的授权功能来配置消息的访问授权。同时支持输入和输出。\n这可以通过向上文所述的匹配规则中加入额外的字段来指定该匹配需要哪些权限。\n通过 setRequiredAuthority 方法来指定对于一个登录用户，需要具有哪些权限才允许访问这个消息。\n这是一个例子：\nPermittedOptions inboundPermitted = new PermittedOptions().setAddress(\"demo.orderService\");\n\n// 仅当用户已登录并且拥有权限 `place_orders`\ninboundPermitted.setRequiredAuthority(\"place_orders\");\n\nBridgeOptions options = new BridgeOptions().addInboundPermitted(inboundPermitted);\n\n用户需要登录，并被授权才能够访问消息。因此，您需要配置一个 Vert.x 认证处理器来处理登录和授权。例如：\nRouter router = Router.router(vertx);\n\n// 允许客户端向地址 `demo.orderService` 发送消息\nPermittedOptions inboundPermitted = new PermittedOptions().setAddress(\"demo.orderService\");\n\n// 仅当用户已经登录并且包含 `place_orders` 权限\ninboundPermitted.setRequiredAuthority(\"place_orders\");\n\nSockJSHandler sockJSHandler = SockJSHandler.create(vertx);\nsockJSHandler.bridge(new BridgeOptions().\n addInboundPermitted(inboundPermitted));\n\n// 设置基础认证处理器\n\nrouter.route().handler(CookieHandler.create());\nrouter.route().handler(SessionHandler.create(LocalSessionStore.create(vertx)));\n\nAuthHandler basicAuthHandler = BasicAuthHandler.create(authProvider);\n\nrouter.route(\"/eventbus/*\").handler(basicAuthHandler);\n\n\nrouter.route(\"/eventbus/*\").handler(sockJSHandler);\n\n处理 Event Bus 桥接器事件\n如果您需要在在桥接器发生事件的时候得到通知，您需要在调用 bridge 方法时提供一个处理器。\n任何发生的事件都会被传递到这个处理器。事件由对象 BridgeEvent 来描述。\n事件可能是以下的某一种类型：\n\nSOCKET_CREATED\n当新的 SockJS 套接字创建时会发生该事件。\n\nSOCKET_IDLE\n当 SockJS 的套接字的空闲事件超过出事设置会发生该事件。\n\nSOCKET_PING\n当 SockJS 的套接字的 ping 时间戳被更新时会发生该事件。\n\nSOCKET_CLOSED\n当 SockJS 的套接字关闭时会发生该事件。\n\nSEND\n当试图将一个客户端消息发送到服务端时会发生该事件。\n\nPUBLISH\n当试图将一个客户端消息发布到服务端时会发生该事件。\n\nRECEIVE\n当试图将一个服务器端消息发布到客户端时会发生该事件。\n\nREGISTER\n当客户端试图注册一个处理器时会发生该事件。\n\nUNREGISTER\n当客户端试图注销一个处理器时会发生该事件。\n\n\n您可以通过 type 方法来获得事件的类型，通过 getRawMessage 方法来获得消息原始内容。\n消息的原始内容是一个如下结构的 JSON 对象：\n{\n \"type\": \"send\"|\"publish\"|\"receive\"|\"register\"|\"unregister\",\n \"address\": the event bus address being sent/published/registered/unregistered\n \"body\": the body of the message\n}\n\n事件对象同时是一个 Future 实例。当您完成了对消息的处理，您可以用参数 true 来完成这个 Future 以执行后续的处理。\n如果您不希望事件继续处理，您可以用参数 false 来结束这个 Future。这个特性可以用于定制您自己的消息过滤器、细粒度的授权或指标收集。\n在下面的例子里，我们拒绝掉了所有经过桥接器并且包含 “Armadillos” 一词的消息：\nRouter router = Router.router(vertx);\n\n// 允许客户端向地址 `demo.orderMgr` 发送消息\nPermittedOptions inboundPermitted = new PermittedOptions().setAddress(\"demo.someService\");\n\nSockJSHandler sockJSHandler = SockJSHandler.create(vertx);\nBridgeOptions options = new BridgeOptions().addInboundPermitted(inboundPermitted);\n\nsockJSHandler.bridge(options, be -> {\n if (be.type() == BridgeEventType.PUBLISH || be.type() == BridgeEventType.RECEIVE) {\n if (be.getRawMessage().getString(\"body\").equals(\"armadillos\")) {\n // 拒绝该消息\n be.complete(false);\n return;\n }\n }\n be.complete(true);\n});\n\nrouter.route(\"/eventbus\").handler(sockJSHandler);\n\n下面的例子展示了如何配置并处理 SOCKET_IDDLE 事件。注意，setPingTimeout(5000) 的作用是当 ping 消息在 5 秒内没有从客户端返回时触发 SOCKET_IDLE 事件。\n// 初始化 SockJS 处理器\nRouter router = Router.router(vertx);\n\nSockJSHandler sockJSHandler = SockJSHandler.create(vertx);\nBridgeOptions options = new BridgeOptions().addInboundPermitted(inboundPermitted).setPingTimeout(5000);\n\nsockJSHandler.bridge(options, be -> {\n if (be.type() == BridgeEventType.SOCKET_IDLE) {\n // 执行某些处理\n }\n\n be.complete(true);\n});\n\nrouter.route(\"/eventbus\").handler(sockJSHandler);\n\n在客户端 JavaScript 环境里您使用 vertx-eventbus.js 来创建到 Event Bus 的连接并发送和接收消息：\n\n\n\n\n\nvar eb = new EventBus('http://localhost:8080/eventbus', {\"vertxbus_ping_interval\": 300000}); // sends ping every 5 minutes.\n\neb.onopen = function() {\n\n // 设置一个接收消息的回调函数\n eb.registerHandler('some-address', function(error, message) {\n console.log('received a message: ' + JSON.stringify(message));\n });\n\n // 发送消息\n eb.send('some-address', {name: 'tim', age: 587});\n}\n\n\n\n在这个例子中，第一件事是创建了一个 Event Bus 实例：\nvar eb = new EventBus('http://localhost:8080/eventbus', {\"vertxbus_ping_interval\": 300000});\n\n构造函数的第二个参数是告诉 SockJS 的库每隔 5 分钟发送一个 ping 消息。由于服务器端配置了期望每隔 5 秒收到一条 ping 消息，因此会在服务器端触发 SOCKET_IDLE 事件。\n 您也可以在处理事件时修改原始的消息内容，例如修改消息体。对于从客户端发送来的消息，您也可以修改消息的消息头，下面是一个例子：\nRouter router = Router.router(vertx);\n\n// 允许客户端向地址 `demo.orderService` 发送消息\nPermittedOptions inboundPermitted = new PermittedOptions().setAddress(\"demo.orderService\");\n\nSockJSHandler sockJSHandler = SockJSHandler.create(vertx);\nBridgeOptions options = new BridgeOptions().addInboundPermitted(inboundPermitted);\n\nsockJSHandler.bridge(options, be -> {\n if (be.type() == BridgeEventType.PUBLISH || be.type() == BridgeEventType.SEND) {\n // 添加消息头\n JsonObject headers = new JsonObject().put(\"header1\", \"val\").put(\"header2\", \"val2\");\n JsonObject rawMessage = be.getRawMessage();\n rawMessage.put(\"headers\", headers);\n be.setRawMessage(rawMessage);\n }\n be.complete(true);\n});\n\nrouter.route(\"/eventbus\").handler(sockJSHandler);\n\nCSRF 跨站点请求伪造\nCSRF 某些时候也被称为 XSRF。它是一种可以再未授权的网站获取用户隐私数据的技术。Vet.x-Web 提供了一个处理器 CSRFHandler 是您可以避免跨站点的伪造请求。\n这个处理器会向所有的 GET 请求的响应里加一个独一无二的令牌作为 Cookie。客户端会在消息头里包含这个令牌。由于令牌基于 Cookie，因此需要在 Router 上启用 Cookie 处理器。\n当开发非单页面应用，并依赖客户端来发送 POST 请求时，这个消息头没办法在 HTML 表单里指定。为了解决这个问题，这个令牌的值也会通过表单属性来检查。这只会发生在请求中不存在这个消息头，并且表单中包含同名属性时。例如：\n\n\n\n\n您需要将表单的属性设置为正确的值。填充这个值唯一的办法是通过上下文来获取键 X-XSRF-TOKEN 的值。这个键的名称也可以在初始化 CSRFHandler 时指定。\nrouter.route().handler(CookieHandler.create());\nrouter.route().handler(CSRFHandler.create(\"abracadabra\"));\nrouter.route().handler(rc -> {\n\n});\n\n虚机主机处理器\n虚机主机处理器会验证请求的主机名。如果匹配成功，则转发这个请求到注册的处理器上。否则，继续在原先的处理器链中执行。\n处理器通过请求的消息头 Host 来进行匹配，并支持基于通配符的模式匹配。例如 *.vertx.io 或完整的域名 www.vertx.io。\nrouter.route().handler(VirtualHostHandler.create(\"*.vertx.io\", routingContext -> {\n // 如果请求访问虚机主机 `*.vertx.io` ，执行某些处理\n}));\n\nOAuth2 认证处理器\nOAuth2AuthHandler 帮助您快速地配置基于 OAuth2 协议的安全路由。这个处理器简化了获取 authCode 的流程。下面的例子用这个处理器实现了保护资源并通过 GitHub 来授权：\nOAuth2Auth authProvider = GithubAuth.create(vertx, \"CLIENT_ID\", \"CLIENT_SECRET\");\n\n// 在服务器上创建 oauth2 处理器\n// 第二个参数是您提供给您的提供商的回调 URL\nOAuth2AuthHandler oauth2 = OAuth2AuthHandler.create(authProvider, \"https://myserver.com/callback\");\n\n// 配置回调处理器来接收 GitHub 的回调\noauth2.setupCallback(router.route());\n\n// 保护 `/protected` 路径下的资源\nrouter.route(\"/protected/*\").handler(oauth2);\n// 在 `/protected` 路径下挂载某些处理器\nrouter.route(\"/protected/somepage\").handler(rc -> {\n rc.response().end(\"Welcome to the protected resource!\");\n});\n\n// 欢迎页\nrouter.get(\"/\").handler(ctx -> {\n ctx.response().putHeader(\"content-type\", \"text/html\").end(\"HelloProtected by Github\");\n});\n\nOAuth2AuthHandler 会配置一个正确的 OAuth2 回调，因此您不需要处理授权服务器的响应。一个很重要的事情是，来自授权服务器的响应只有一次有效。也就是说如果客户端对回调 URL 发起了重载操作，则会因为验证错误而请求失败。\n经验法则是：当有效的回调执行时，通知客户端跳转到受保护的资源上。\n就 OAuth2 规范的生态来看，使用其他的 OAuth2 提供商需要作出少许的修改。为此，Vertx Auth 提供了若干开箱即用的实现：\n\nAzure Active Directory AzureADAuth\nBox.com BoxAuth\nDropbox DropboxAuth\nFacebook FacebookAuth\nFoursquare FoursquareAuth\nGithub GithubAuth\nGoogle GoogleAuth\nInstagram InstagramAuth\nKeycloak KeycloakAuth\nLinkedIn LinkedInAuth\nMailchimp MailchimpAuth\nSalesforce SalesforceAuth\nShopify ShopifyAuth\nSoundcloud SoundcloudAuth\nStripe StripeAuth\nTwitter TwitterAuth\n\n如果您需要使用一个上述未列出的提供商，您也可以使用基本的 API 来实现，例如：\nOAuth2Auth authProvider = OAuth2Auth.create(vertx, OAuth2FlowType.AUTH_CODE, new OAuth2ClientOptions()\n .setClientID(\"CLIENT_ID\")\n .setClientSecret(\"CLIENT_SECRET\")\n .setSite(\"https://accounts.google.com\")\n .setTokenPath(\"https://www.googleapis.com/oauth2/v3/token\")\n .setAuthorizationPath(\"/o/oauth2/auth\"));\n\n// 在域名 `http://localhost:8080` 上创建 oauth2 处理器\nOAuth2AuthHandler oauth2 = OAuth2AuthHandler.create(authProvider, \"http://localhost:8080\");\n\n// 配置需要的权限\noauth2.addAuthority(\"profile\");\n\n// 配置回调处理器来接收 Google 的回调\noauth2.setupCallback(router.get(\"/callback\"));\n\n// 保护 `/protected` 路径下的资源\nrouter.route(\"/protected/*\").handler(oauth2);\n// 在 `/protected` 路径下挂载某些处理器\nrouter.route(\"/protected/somepage\").handler(rc -> {\n rc.response().end(\"Welcome to the protected resource!\");\n});\n\n// 欢迎页\nrouter.get(\"/\").handler(ctx -> {\n ctx.response().putHeader(\"content-type\", \"text/html\").end(\"HelloProtected by Google\");\n});\n\n您需要手工提供所有关于您所使用的提供商的细节，但结果是一样的。\n这个处理器会在您的应用上绑定回调的 URL。用法很简单，只需要为这个处理器提供一个路由(Route)，其他的配置都会自动完成。一个典型的情况是您的 OAuth2 提供商会需要您来提供您的应用的 callback url，则您的输入类似于 https://myserver.com/callback。这是您的处理器的第二个参数。至此，您完成所有必须的配置，只需要通过 setupCallback 方法来启动它即可。\n以上就是如何在您的服务器上绑定处理器 https://myserver.com:8447/callback。注意，端口号可以不使用默认值。\nOAuth2AuthHandler oauth2 = OAuth2AuthHandler.create(provider, \"https://myserver.com:8447/callback\");\n// 允许该处理器为您处理回调地址\noauth2.setupCallback(router.route());\n\n在这个例子中，Route 对象通过 Router.route() 创建。如果您需要完整的控制处理器的执行顺序（例如您期望它在处理链中首先被执行），您也可以先创建这个 Route 对象，然后将引用传进这个方法里。\n混合 OAuth2 和 JWT\n 一些 OAuth2 的提供商参考了 RFC6750 规范，使用 JWT 令牌来作为访问令牌。这对于需要混合基于客户端的授权和基于 API 的授权很有用。例如您的应用提供了一些受保护的 HTML 文档，同时您又希望他可以作为 API 被消费。在这种情况下，一个 API 不能够很容易的处理 OAuth2 需要的重定向握手，但可以提供令牌(11)。\n只要提供商被配置为支持 JWT，OAuth 处理器会自动处理这个问题。\n这意味着您的 API 可以通过提供值为 Bearer BASE64_ACCESS_TOKEN 的消息头 Authorization 来访问受保护的资源。\n注释\n\n指 HTTP 协议的 Method\n内容协商 指允许同一个 URI 可以根据请求中的 Accept 字段来提供资源的不同版本。\naccept 指 Router 的 accept 方法。示例代码使用了 Java 8 Lambda 的 方法引用 语法。\nReroute 一词没有找到合适的方式来描述，译为了 转发。此处有别于 HTTP 的 Redirect 或 Proxy 等概念，只是进程内的逻辑跳转。\n会话 Cookie 也即 Session Cookie，特指有效期为 session 的 Cookie。可参考 MSDN。\n或可称之为不可枚举的。可防止碰撞攻击。\n指通过 vertx.executeBlocking 方法来定期刷新生成器的种子，在 Event Loop 线程中同步执行生成随机数的过程。\n即 Route.failureHandler。\n实际上不同的 transport 具有不同的会话处理机制。sessionTimeout 主要针对轮询方式的 transport，例如 xhr。服务器端返回一个响应之后，客户端一旦接受了响应，会立刻再发一个 request 出来继续等下一个消息。如果超过了默认的 5 秒该会话没有收到新的请求，则会认为客户端断开了连接，会话过期。\n关于 OAuth2 如何通过 JWT 来进行授权，可以 参考这里。\n\n结语\nroute 一词同时具有名词和动词的含义。为了避免混淆，原文中所有使用名词的地方都统一按照专有名词 Route / route 处理。原文中的动词统一译为 路由。原文的最后几部分关于 SockJS 和 OAuth2 的内容写作风格明显和前文不同，而且有些地方描述的很简略（例如 OAuth 流程的细节、SockJS 的不同 Transport 之间的差异等）。本着翻译准确的原则，本译文没有进一步展开描述。\n"},"webclient/WebClient.html":{"url":"webclient/WebClient.html","title":"Web Client","keywords":"","body":"Vert.x Web Client\n\n原文档\n组件源码\n组件示例\n\n中英对照表\n\nPump：泵（平滑流式数据读入内存的机制，防止一次性将大量数据读入内存导致内存溢出）\nResponse Codec：响应编解码器（编码及解码工具）\nBody Codec：响应体编解码器\n\n组件介绍\nVert.x Web Client（Web客户端）是一个异步的 HTTP 和 HTTP/2 客户端。\nWeb Client使得发送 HTTP 请求以及从 Web 服务器接收 HTTP 响应变得更加便捷，同时提供了额外的高级功能，例如：\n\nJSON体的编码和解码\n\n请求和响应泵\n\n请求参数的处理\n\n统一的错误处理\n\n提交表单\n\n\n制作Web Client的目的并非为了替换Vert.x Core中的 HttpClient，而是基于该客户端，扩展并保留其便利的设置和特性，例如请求连接池（Pooling），HTTP/2的支持，流水线／管线的支持等。当您需要对 HTTP 请求和响应做细微粒度控制时，您应当使用 HttpClient。\n另外Web Client并未提供 WebSocket API，此时您应当使用 HttpClient。\n使用Web Client\n如需使用Vert.x Web Client，请先加入以下依赖：\n\nMaven（在 pom.xml文件中）：\n\n io.vertx\n vertx-web-client\n 3.4.1\n\n\n\nGradle（在build.gradle文件中）：\ndependencies {\n compile 'io.vertx:vertx-web-client:3.4.1'\n}\n\n\n\n对Vert.x Core HTTP Client的回顾\nVert.x Web Client使用Vert.x Core的API，如您对此还不熟悉，请先熟悉 HttpClient 的一些基本概念。\n创建Web Client\n您可使用缺省设置创建一个 WebClient：\nWebClient client = WebClient.create(vertx);\n\n您亦可使用配置选项来创建客户端：\nWebClientOptions options = new WebClientOptions()\n .setUserAgent(\"My-App/1.2.3\");\noptions.setKeepAlive(false);\nWebClient client = WebClient.create(vertx, options);\n\nWeb Client配置选项继承自 HttpClient 配置选项，使用时可根据实际情况选择。\n如已在程序中创建 HttpClient，可用以下方式复用：\nWebClient client = WebClient.wrap(httpClient);\n\n发送请求\n无请求体的简单请求\n一般情况下，HTTP GET，OPTIONS以及HEAD请求没有请求体，可用以下方式发送无请求体的HTTP Requests（HTTP请求）：\nWebClient client = WebClient.create(vertx);\n\n// 发送GET请求\nclient\n .get(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .send(ar -> {\n if (ar.succeeded()) {\n // 获取响应\n HttpResponse response = ar.result();\n\n System.out.println(\"Received response with status code\" + response.statusCode());\n } else {\n System.out.println(\"Something went wrong \" + ar.cause().getMessage());\n }\n });\n\n//发送HEAD请求\nclient\n .head(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .send(ar -> {\n if (ar.succeeded()) {\n // 获取响应\n HttpResponse response = ar.result();\n\n System.out.println(\"Received response with status code\" + response.statusCode());\n } else {\n System.out.println(\"Something went wrong \" + ar.cause().getMessage());\n }\n });\n\n您可用以下链式方式向请求URI添加查询参数\nclient\n .get(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .addQueryParam(\"param\", \"param_value\")\n .send(ar -> {});\n\n在请求URI中的参数将会被预填充\nHttpRequest request = client.get(8080, \"myserver.mycompany.com\", \"/some-uri?param1=param1_value¶m2=param2_value\");\n\n// 添加param3（参数3）\nrequest.addQueryParam(\"param3\", \"param3_value\");\n\n// 覆盖param2（参数2）\nrequest.setQueryParam(\"param2\", \"another_param2_value\");\n\n设置请求URI将会自动清除已有的查询参数\nHttpRequest request = client.get(8080, \"myserver.mycompany.com\", \"/some-uri\");\n\n// 添加param1（参数1）\nrequest.addQueryParam(\"param1\", \"param1_value\");\n\n// 覆盖param1（参数1）同时新增param2（参数2）\nrequest.uri(\"/some-uri?param1=param1_value¶m2=param2_value\");\n\n填充请求体\n如需要发送请求体，可使用相同的API并在最后加上 sendXXX 方法发送相应的请求体。\n例如用 sendBuffer 方法发送一个缓冲体：\nclient\n .post(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .sendBuffer(buffer, ar -> {\n if (ar.succeeded()) {\n // Ok\n }\n });\n\n有时候我们并不希望将所有数据一次性全部读入内存，因为文件太大或希望同时处理多个请求，希望每个请求仅使用最小的内存。出于此目的，Web Client可用 sendStream 方法发送流式数据 ReadStream（例如 AsyncFile 便是一个 ReadStream）：\nclient\n .post(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .sendStream(stream, resp -> {});\n\nWeb Client会为您设置好传输泵以平滑传输流。如果流长度未知则使用分块传输（chunked transfer）。\n如已知流的大小，可在HTTP协议头中设置 content-length 属性\nfs.open(\"content.txt\", new OpenOptions(), fileRes -> {\n if (fileRes.succeeded()) {\n ReadStream fileStream = fileRes.result();\n\n String fileLen = \"1024\";\n\n // 用POST方法发送文件\n client\n .post(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .putHeader(\"content-length\", fileLen)\n .sendStream(fileStream, ar -> {\n if (ar.succeeded()) {\n // Ok\n }\n });\n }\n});\n\n此时POST方法不会使用分块传输。\nJSON体\n有时您需要在请求体中使用JSON格式，可使用 sendJsonObject 方法发送 JsonObject：\nclient\n .post(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .sendJsonObject(new JsonObject()\n .put(\"firstName\", \"Dale\")\n .put(\"lastName\", \"Cooper\"), ar -> {\n if (ar.succeeded()) {\n // Ok\n }\n });\n\n在Java，Groovy以及Kotlin语言中，您亦可使用 sendJson 方法发送POJO（Plain Old Java Object），该方法会自动调用 Json.encode 方法将 POJO 映射为 JSON：\nclient\n .post(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .sendJson(new User(\"Dale\", \"Cooper\"), ar -> {\n if (ar.succeeded()) {\n // Ok\n }\n });\n\n\n请注意： Json.encode 方法使用Jackson的 mapper将 POJO 映射成 JSON。\n\n表单提交\n您可使用 sendForm 方法发送HTTP表单。\nMultiMap form = MultiMap.caseInsensitiveMultiMap();\nform.set(\"firstName\", \"Dale\");\nform.set(\"lastName\", \"Cooper\");\n\n// 用URL编码方式提交表单\nclient\n .post(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .sendForm(form, ar -> {\n if (ar.succeeded()) {\n // Ok\n }\n });\n\n缺省情况下，提交表单的请求头中的 content-type 属性值为 application/x-www-form-urlencoded，您亦可将其设置为 multipart/form-data：\nMultiMap form = MultiMap.caseInsensitiveMultiMap();\nform.set(\"firstName\", \"Dale\");\nform.set(\"lastName\", \"Cooper\");\n\n// 用分块方式编码提交表单\nclient\n .post(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .putHeader(\"content-type\", \"multipart/form-data\")\n .sendForm(form, ar -> {\n if (ar.succeeded()) {\n // Ok\n }\n });\n\n\n请注意：当前版本并不支持分块文件编码（multipart files，即文件上传），该功能可能在将来版本中予以支持。\n\n填充请求头\n您可使用以下方式填充请求头：\nHttpRequest request = client.get(8080, \"myserver.mycompany.com\", \"/some-uri\");\nMultiMap headers = request.headers();\nheaders.set(\"content-type\", \"application/json\");\nheaders.set(\"other-header\", \"foo\");\n\n此处 Headers 是一个 MultiMap 对象，提供了增加、设置以及删除头属性操作的入口。HTTP头的某些特定属性允许设置多个值。\n您亦可通过 putHeader 方法写入头属性：\nHttpRequest request = client.get(8080, \"myserver.mycompany.com\", \"/some-uri\");\nrequest.putHeader(\"content-type\", \"application/json\");\nrequest.putHeader(\"other-header\", \"foo\");\n\n重用请求\nsend 方法可被重复多次调用，这使得配置以及重用 HttpRequest 对象变得更加便捷：\nHttpRequest get = client.get(8080, \"myserver.mycompany.com\", \"/some-uri\");\nget.send(ar -> {\n if (ar.succeeded()) {\n // Ok\n }\n});\n\n// 再次发送同样的请求\nget.send(ar -> {\n if (ar.succeeded()) {\n // Ok\n }\n});\n\n当您需要更改请求时，可用 copy 方法复制一份请求的拷贝：\nHttpRequest get = client.get(8080, \"myserver.mycompany.com\", \"/some-uri\");\nget.send(ar -> {\n if (ar.succeeded()) {\n // Ok\n }\n});\n\n// 获取同样的请求\nget.copy()\n .putHeader(\"an-header\", \"with-some-value\")\n .send(ar -> {\n if (ar.succeeded()) {\n // Ok\n }\n\n超时\n您可通过 timeout 方法设置超时时间。\nclient\n .get(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .timeout(5000)\n .send(ar -> {\n if (ar.succeeded()) {\n // Ok\n } else {\n // 此处可填入超时处理部分代码\n }\n });\n\n若请求在设定时间内没返回任何数据，则一个超时异常将会传递给响应处理代码。\n处理HTTP响应\nWeb Client请求发送之后，返回的结果将会被包装在异步结果 HttpResponse 中。\n当响应被成功接收到之后，相应的回调函数将会被触发。\nclient\n .get(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .send(ar -> {\n if (ar.succeeded()) {\n\n HttpResponse response = ar.result();\n\n System.out.println(\"Received response with status code\" + response.statusCode());\n } else {\n System.out.println(\"Something went wrong \" + ar.cause().getMessage());\n }\n });\n\n\n警告：缺省状况下，响应会被完全缓冲读入内存，请用 BodyCodec.pipe 方法将响应写入流。\n\n响应编解码器\n缺省状况下，响应以缓冲形式提供，并不提供任何形式的解码。\n可用 BodyCodec 将响应定制成以下类型：\n\n普通字符串\nJSON对象\n将JSON映射成POJO\nWriteStream\n\n响应体编解码器对二进制数据流解码，以节省您在响应处理中的代码。\n使用 BodyCodec.jsonObject 将结果解码为JSON对象：\nclient\n .get(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .as(BodyCodec.jsonObject())\n .send(ar -> {\n if (ar.succeeded()) {\n HttpResponse response = ar.result();\n\n JsonObject body = response.body();\n\n System.out.println(\"Received response with status code\" + response.statusCode() + \" with body \" + body);\n } else {\n System.out.println(\"Something went wrong \" + ar.cause().getMessage());\n }\n });\n\n在Java，Groovy以及Kotlin语言中，JSON对象可被解码映射成POJO：\nclient\n .get(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .as(BodyCodec.json(User.class))\n .send(ar -> {\n if (ar.succeeded()) {\n HttpResponse response = ar.result();\n\n User user = response.body();\n\n System.out.println(\"Received response with status code\" + response.statusCode() + \" with body \" +\n user.getFirstName() + \" \" + user.getLastName());\n } else {\n System.out.println(\"Something went wrong \" + ar.cause().getMessage());\n }\n });\n\n当响应结果较大时，请使用 BodyCodec.pipe 方法。响应体编解码器将响应结果压入 WriteStream 并在最后发出成功或失败的信号。\nclient\n .get(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .as(BodyCodec.pipe(writeStream))\n .send(ar -> {\n if (ar.succeeded()) {\n\n HttpResponse response = ar.result();\n\n System.out.println(\"Received response with status code\" + response.statusCode());\n } else {\n System.out.println(\"Something went wrong \" + ar.cause().getMessage());\n }\n });\n\n最后，如您对响应结果不感兴趣，可用 BodyCodec.none 废弃响应体。\nclient\n .get(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .as(BodyCodec.none())\n .send(ar -> {\n if (ar.succeeded()) {\n\n HttpResponse response = ar.result();\n\n System.out.println(\"Received response with status code\" + response.statusCode());\n } else {\n System.out.println(\"Something went wrong \" + ar.cause().getMessage());\n }\n });\n\n若无法预知响应内容类型，您依旧可以在获取结果之后，用 bodyAsXXX() 方法将其转换成特定的类型\nclient\n .get(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .send(ar -> {\n if (ar.succeeded()) {\n\n HttpResponse response = ar.result();\n\n // 将结果解码为Json对象\n JsonObject body = response.bodyAsJsonObject();\n\n System.out.println(\"Received response with status code\" + response.statusCode() + \" with body \" + body);\n } else {\n System.out.println(\"Something went wrong \" + ar.cause().getMessage());\n }\n });\n\n\n警告：这种方式仅对响应结果为缓冲体有效。\n\n处理30x重定向\n缺省状况下，客户端将会依照30x状态码自动重定向，您可使用 WebClientOptions 予以配置：\nWebClient client = WebClient.create(vertx, new WebClientOptions().setFollowRedirects(false));\n\n客户端将会执行最多达16次重定向，该参数亦可在 WebClientOptions 配置：\nWebClient client = WebClient.create(vertx, new WebClientOptions().setMaxRedirects(5));\n\n使用HTTPS\nVert.x Web Client可用与 HttpClient 相同方式配置HTTPS协议。\n您可对每个请求单独设置：\nclient\n .get(443, \"myserver.mycompany.com\", \"/some-uri\")\n .ssl(true)\n .send(ar -> {\n if (ar.succeeded()) {\n // 获取响应\n HttpResponse response = ar.result();\n\n System.out.println(\"Received response with status code\" + response.statusCode());\n } else {\n System.out.println(\"Something went wrong \" + ar.cause().getMessage());\n }\n });\n\n或使用绝对路径：\nclient\n .getAbs(\"https://myserver.mycompany.com:4043/some-uri\")\n .send(ar -> {\n if (ar.succeeded()) {\n // 获取响应\n HttpResponse response = ar.result();\n\n System.out.println(\"Received response with status code\" + response.statusCode());\n } else {\n System.out.println(\"Something went wrong \" + ar.cause().getMessage());\n }\n });\n\nRxJava API\nRxJava的 HttpRequest 提供了原版API的响应式版本，rxSend 方法返回一个可被订阅的 Single>，故单个 Single 可被多次订阅。\nSingle> single = client\n .get(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .rxSend();\n\n// 发送一次请求，并处理其响应，rx通常通过订阅触发各种响应\nsingle.subscribe(response -> {\n System.out.println(\"Received 1st response with status code\" + response.statusCode());\n}, error -> {\n System.out.println(\"Something went wrong \" + error.getMessage());\n});\n\n// 再次发送请求\nsingle.subscribe(response -> {\n System.out.println(\"Received 2nd response with status code\" + response.statusCode());\n}, error -> {\n System.out.println(\"Something went wrong \" + error.getMessage());\n});\n\n获取到的 Single 可与其它RxJava API自然组合成链式处理\nSingle url = client\n .get(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .rxSend()\n .map(HttpResponse::bodyAsString);\n\n// 用flatMap将返回值内的链接作为参数传入lambda，在lambda中将其设置成发送请求，并返回Single，在下一步订阅中予以触发\nurl\n .flatMap(u -> client.getAbs(u).rxSend())\n .subscribe(response -> {\n System.out.println(\"Received response with status code\" + response.statusCode());\n }, error -> {\n System.out.println(\"Something went wrong \" + error.getMessage());\n });\n\n之前的例子可写成\nSingle> single = client\n .get(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .putHeader(\"some-header\", \"header-value\")\n .addQueryParam(\"some-param\", \"param value\")\n .as(BodyCodec.jsonObject())\n .rxSend();\nsingle.subscribe(resp -> {\n System.out.println(resp.statusCode());\n System.out.println(resp.body());\n});\n\n当发送请求体为 Observable 时，应使用 sendStream：\nObservable body = getPayload();\n\nSingle> single = client\n .post(8080, \"myserver.mycompany.com\", \"/some-uri\")\n .rxSendStream(body);\nsingle.subscribe(resp -> {\n System.out.println(resp.statusCode());\n System.out.println(resp.body());\n});\n\n当订阅时，body 将会被订阅，其内容将会被用于请求中。\n\n\n原文上次编辑于2017-03-15 15:54:14 欧洲中部时间\n\n"},"data/Data.html":{"url":"data/Data.html","title":"Data Access","keywords":"","body":"Vert.x Data Access\n"},"data/MongoDBClient.html":{"url":"data/MongoDBClient.html","title":"MongoDB Client","keywords":"","body":"Vert.x MongoDB Client\n\n原文档：Vert.x MongoDB Client\n\n组件介绍\n您的 Vert.x 应用可以使用 Vert.x MongoDB Client（以下简称客户端）来与 MongoDB 进行交互，包括保存，获取，搜索和删除文档。\nMongoDB 是在 Vert.x 应用进行数据持久化时的最佳选择，因为 MongoDB 天生就是处理 JSON（BSON）格式的文档数据库。\n特点\n\n完全非阻塞\n支持自定义编解码器，从而实现 Vert.x JSON 快速序列化和反序列化\n支持 MongoDB Java 驱动大部分配置项\n\n本客户端基于 MongoDB Async Driver。\n使用 Vert.x MongoDB Client\n使用此客户端，需要添加下列依赖：\n\nMaven (在 pom.xml 文件中):\n\n\n io.vertx\n vertx-mongo-client\n 3.4.1\n\n\n\nGradle (在 build.gradle 文件中):\n\ncompile 'io.vertx:vertx-mongo-client:3.4.1'\n\n创建客户端\n您有以下几种方式来创建客户端：\n默认使用共享的连接池\n大部分情况下，您希望不同的客户端之间共享一个连接池。\n例如：我们在部署 Verticle 时，设置了 Verticle 拥有多个实例化的对象，但是我们希望每个 Verticle 实例能够共享同一个数据源，而不是单独为每个 Verticle 实例设置不同的数据源。\n要解决上面的问题，我们可以这么做：\nMongoClient client = MongoClient.createShared(vertx, config);\n\n只有在第一次调用 MongoClient.createShared 方法的时候，才会真正的根据 config 参数创建一个数据源。\n之后再调用此方法，只会返回一个新的客户端对象，但使用的是相同的数据源。这时 config 参数也就不再有作用。\n指定数据源名称\n您还可以像下面这样，在创建一个客户端的时候指定数据源的名称：\nMongoClient client = MongoClient.createShared(vertx, config, \"MyPoolName\");\n\n如果不同的客户端对象使用了相同的 Vert.x 对象和相同的数据源名称，那么它们将共享数据源。\n同样的（与默认使用共享的数据源），只有在第一次调用MongoClient.createShared方法的时候，才会真正的根据 config 参数创建一个数据源。\n之后再调用此方法，只会返回一个新的客户端对象，但使用的是相同的数据源。这时 config 参数也就不再有作用。\n当我们希望不同含义的客户端对象拥有不同的数据源时，可以采用这种方式来创建它的对象。比如它们要与不同的数据源进行交互。\n创建不共享数据源的客户端对象\n在大部分情况下，我们会希望在不同的客户端对象之间共享数据源。但有时候，却恰恰相反。\n这时，可以调用 MongoClient.createNonShared 方法：\nMongoClient client = MongoClient.createNonShared(vertx, config);\n\n每次调用此方法，就相当于在调用 MongoClient.createShared 方法时加上了具有唯一名称的数据源参数。\n使用客户端 API\nMongoClient 接口定义了操作客户端的API 方法。您可以使用 MongoClient 来使用调用 API 方法。\n保存文档\n您可以使用 save 方法来保存文档。\n如果文档中没有 _id 字段，文档会被保存。若有，将执行 upserted。Upserted 意思是，如果此文档不存在，就保存此文档，此文档存在就更新。\n如果文档没有 _id 字段，回调方法中可以获得保存后生成的 id 。\n例如：\nJsonObject document = new JsonObject().put(\"title\", \"The Hobbit\");\n\nmongoClient.save(\"books\", document, res -> {\n\n if (res.succeeded()) {\n\n String id = res.result();\n System.out.println(\"Saved book with id \" + id);\n\n } else {\n res.cause().printStackTrace();\n }\n\n});\n\n下面的例子，文档已有 _id ：\nJsonObject document = new JsonObject().put(\"title\", \"The Hobbit\").put(\"_id\", \"123244\");\n\nmongoClient.save(\"books\", document, res -> {\n\n if (res.succeeded()) {\n\n // ...\n\n } else {\n res.cause().printStackTrace();\n }\n\n});\n\n插入文档\n您可以使用 insert 方法来插入文档。\n如果被插入的文档没有包含 id，回调方法中可以获得保存后生成的 id 。\nJsonObject document = new JsonObject().put(\"title\", \"The Hobbit\");\n\nmongoClient.insert(\"books\", document, res -> {\n\n if (res.succeeded()) {\n\n String id = res.result();\n System.out.println(\"Inserted book with id \" + id);\n\n } else {\n res.cause().printStackTrace();\n }\n\n});\n\n如果被插入的文档包含 id，但是此 id 代表的文档已经存在，插入就会失败：\nJsonObject document = new JsonObject().put(\"title\", \"The Hobbit\").put(\"_id\", \"123244\");\n\nmongoClient.insert(\"books\", document, res -> {\n\n if (res.succeeded()) {\n\n //...\n\n } else {\n\n // Will fail if the book with that id already exists.\n }\n\n});\n\n更新文档\n您可以使用 update 方法来更新文档（译者注：建议使用 updateCollection 方法或者 updateCollectionWithOptions 方法）。\n此方法可以更新集合（译者注：MongoDB 中的集合概念对应 SQL 中的数据库表）中的一个或多个文档。其中 update 参数的 JSON 对象，必须包含 Update Operators ，因为由它决定更新的方式。\n其中 query 参数决定更新集合中的哪个文档。\n例如更新 books 集合中的一个文档：\nJsonObject query = new JsonObject().put(\"title\", \"The Hobbit\");\n\n// Set the author field\nJsonObject update = new JsonObject().put(\"$set\", new JsonObject().put(\"author\", \"J. R. R. Tolkien\"));\n\nmongoClient.update(\"books\", query, update, res -> {\n\n if (res.succeeded()) {\n\n System.out.println(\"Book updated !\");\n\n } else {\n\n res.cause().printStackTrace();\n }\n\n});\n\n您可以使用 updateWithOptions 方法。\n如果要指定 update 操作到底是 upsert（upsert 意思是，如果此文档不存在，就保存此文档；此文档存在就更新）或者仅仅只更新，请使用 updateWithOptions 方法并传递参数 UpdateOptions.\n参数 UpdateOptions 有以下选项：\n\nmulti\n若设置为 true，则可以更新多个文档\n\nupsert\n若设置为 true，则可以在没有查询到要更新的文档时，新增该文档\n\nwriteConcern\n写操作的可靠性（译者注：源码中是用 writeOption 枚举类型来代表的）\n\n\n//译者注：MongoDB 默认写操作级别是 WriteOption.ACKNOWLEDGED\n\nJsonObject query = new JsonObject().put(\"title\", \"The Hobbit\");\n\n// Set the author field\nJsonObject update = new JsonObject().put(\"$set\", new JsonObject().put(\"author\", \"J. R. R. Tolkien\"));\n\nUpdateOptions options = new UpdateOptions().setMulti(true);\n\nmongoClient.updateWithOptions(\"books\", query, update, options, res -> {\n\n if (res.succeeded()) {\n\n System.out.println(\"Book updated !\");\n\n } else {\n\n res.cause().printStackTrace();\n }\n\n});\n\n替换文档\n您可以使用 replace 方法来替换文档\nreplace 方法和 update 方法类似，但是并不需要 update 中的 UpdateOptions 参数。因为 replace 方法替换的是 query 参数找到的整个文档。\n例如替换 books 集合中的一个文档：\nJsonObject query = new JsonObject().put(\"title\", \"The Hobbit\");\n\nJsonObject replace = new JsonObject().put(\"title\", \"The Lord of the Rings\").put(\"author\", \"J. R. R. Tolkien\");\n\nmongoClient.replace(\"books\", query, replace, res -> {\n\n if (res.succeeded()) {\n\n System.out.println(\"Book replaced !\");\n\n } else {\n\n res.cause().printStackTrace();\n\n }\n\n});\n\n查找文档\n您可以使用 find 方法查找文档。\n其中 query 参数用来匹配集合中的文档。\n例如匹配所有文档：\nJsonObject query = new JsonObject();\n\nmongoClient.find(\"books\", query, res -> {\n\n if (res.succeeded()) {\n\n for (JsonObject json : res.result()) {\n\n System.out.println(json.encodePrettily());\n\n }\n\n } else {\n\n res.cause().printStackTrace();\n\n }\n\n});\n\n又例如匹配 books 集合中某一个作者的所有文档：\nJsonObject query = new JsonObject().put(\"author\", \"J. R. R. Tolkien\");\n\nmongoClient.find(\"books\", query, res -> {\n\n if (res.succeeded()) {\n\n for (JsonObject json : res.result()) {\n\n System.out.println(json.encodePrettily());\n\n }\n\n } else {\n\n res.cause().printStackTrace();\n\n }\n\n});\n\n查询的结果包装成了 JSON 对象的 List 集合。\n如果您需要指定返回哪些域，又或者需要指定返回的数据条数，可以使用 findWithOptions 方法，在参数 FindOptions 中指定这些查询要求。\nFindOptions 中可以设置以下参数：\n\nfields\n指定返回哪些域。默认值为 null ，意味着返回所有域。\n\nsort\n指定排序字段。默认为 null。\n\nlimit\n指定返回的数据条数。默认值为 -1，意味着返回所有数据。\n\nskip\n表示返回的结果，跳过的数据行数。默认值为 0 。\n\n\nJsonObject query = new JsonObject().put(\"author\", \"J. R. R. Tolkien\");\n\nmongoClient.findBatch(\"book\", query, res -> {\n\n if (res.succeeded()) {\n\n if (res.result() == null) {\n\n System.out.println(\"End of research\");\n\n } else {\n\n System.out.println(\"Found doc: \" + res.result().encodePrettily());\n\n }\n\n } else {\n\n res.cause().printStackTrace();\n\n }\n});\n\n所有返回的结果，都可以在回调方法中得到。\n查询单个文档\n要查询单个文档，您可以使用 findOne 方法。\n这有点类似 find 方法，但是仅仅返回 find 方法查询到的第一条数据。\n删除文档\n您可以使用 removeDocuments 方法来删除文档。\n其中 query 参数决定了要删除集合中的哪些文档。\n例如删除作者为 Tolkien 的所有文档：\nJsonObject query = new JsonObject().put(\"author\", \"J. R. R. Tolkien\");\n\nmongoClient.remove(\"books\", query, res -> {\n\n if (res.succeeded()) {\n\n System.out.println(\"Never much liked Tolkien stuff!\");\n\n } else {\n\n res.cause().printStackTrace();\n\n }\n});\n\n删除单个文档\n您可以使用 removeDocument 方法来删除单个文档。\n这有点类似 removeDocuments 方法，但是 removeDocument 方法只返回匹配到的第一个文档。\n文档计数\n您可以使用 count 方法来计算文档数量。\n例如计算作者为 Tolkien 的书的数量，结果包装在回调方法中。\nJsonObject query = new JsonObject().put(\"author\", \"J. R. R. Tolkien\");\n\nmongoClient.count(\"books\", query, res -> {\n\n if (res.succeeded()) {\n\n long num = res.result();\n\n } else {\n\n res.cause().printStackTrace();\n\n }\n});\n\n管理 MongoDB 集合\nMongoDB 的所有文档数据都存储在集合中。\n您可以使用 getCollections 方法来获得所有的集合：\nmongoClient.getCollections(res -> {\n\n if (res.succeeded()) {\n\n List collections = res.result();\n\n } else {\n\n res.cause().printStackTrace();\n\n }\n});\n\n您也可以使用 createCollection 方法来创建一个新的集合：\nmongoClient.createCollection(\"mynewcollectionr\", res -> {\n\n if (res.succeeded()) {\n\n // Created ok!\n\n } else {\n\n res.cause().printStackTrace();\n\n }\n});\n\n您也可以使用 dropCollection 方法来删除文档\n\n请注意：删除一个集合将会删除集合中所有的文档！\n\nmongoClient.dropCollection(\"mynewcollectionr\", res -> {\n\n if (res.succeeded()) {\n\n // Dropped ok!\n\n } else {\n\n res.cause().printStackTrace();\n\n }\n});\n\n执行 MongoDB 其他命令\n您可以使用 runCommand 方法来执行任何 MongoDB 命令。\n使用这种方式，可以发挥出 MongoDB 更多优点，比如使用 MapReduce。更多详情，请参考说明文档 Commands。\n例如执行 aggregate（译者注：聚合）命令。请注意，命令的名称要做为 runCommand 方法的一个参数，并且同时也必须包含在包装命令的 JSON 参数中。这么做是因为 JSON 不是有序的，但 BSON 却是，而且 MongoDB 期望 BSON 参数的第一个键值对是命令的名称。所以，为了明确 JSON 中的哪个键值对是命令名称，我们也就必须把命令名称单独设置为一个参数：\nJsonObject command = new JsonObject()\n .put(\"aggregate\", \"collection_name\")\n .put(\"pipeline\", new JsonArray());\n\nmongoClient.runCommand(\"aggregate\", command, res -> {\n if (res.succeeded()) {\n JsonArray resArr = res.result().getJsonArray(\"result\");\n // etc\n } else {\n res.cause().printStackTrace();\n }\n});\n\nMongoDB 扩展的 JSON 支持\n目前，MongoDB 只支持 date，oid 和 binary 类型（请参考：http://docs.mongodb.org/manual/reference/mongodb-extended-json ）\n例如插入含有 date 类型字段的文档：\nJsonObject document = new JsonObject().put(\"title\", \"The Hobbit\")\n //ISO-8601 date\n .put(\"publicationDate\", new JsonObject().put(\"$date\", \"1937-09-21T00:00:00+00:00\"));\n\nmongoService.save(\"publishedBooks\", document, res -> {\n\n if (res.succeeded()) {\n\n String id = res.result();\n\n mongoService.findOne(\"publishedBooks\", new JsonObject().put(\"_id\", id), null, res2 -> {\n if (res2.succeeded()) {\n\n System.out.println(\"To retrieve ISO-8601 date : \"\n + res2.result().getJsonObject(\"publicationDate\").getString(\"$date\"));\n\n } else {\n res2.cause().printStackTrace();\n }\n });\n\n } else {\n res.cause().printStackTrace();\n }\n\n});\n\n例如插入含有 binary 类型字段的文档以及读取这个字段\nbyte[] binaryObject = new byte[40];\n\nJsonObject document = new JsonObject()\n .put(\"name\", \"Alan Turing\")\n .put(\"binaryStuff\", new JsonObject().put(\"$binary\", binaryObject));\n\nmongoService.save(\"smartPeople\", document, res -> {\n\n if (res.succeeded()) {\n\n String id = res.result();\n\n mongoService.findOne(\"smartPeople\", new JsonObject().put(\"_id\", id), null, res2 -> {\n if(res2.succeeded()) {\n\n byte[] reconstitutedBinaryObject = res2.result().getJsonObject(\"binaryStuff\").getBinary(\"$binary\");\n //This could now be de-serialized into an object in real life\n } else {\n res2.cause().printStackTrace();\n }\n });\n\n } else {\n res.cause().printStackTrace();\n }\n\n});\n\n例如保存一个 base 64 编码的字符串，将这个字符串作为 binary 字段插入。并且读取这个字段：\nString base64EncodedString = \"a2FpbHVhIGlzIHRoZSAjMSBiZWFjaCBpbiB0aGUgd29ybGQ=\";\n\nJsonObject document = new JsonObject()\n .put(\"name\", \"Alan Turing\")\n .put(\"binaryStuff\", new JsonObject().put(\"$binary\", base64EncodedString));\n\nmongoService.save(\"smartPeople\", document, res -> {\n\n if (res.succeeded()) {\n\n String id = res.result();\n\n mongoService.findOne(\"smartPeople\", new JsonObject().put(\"_id\", id), null, res2 -> {\n if(res2.succeeded()) {\n\n String reconstitutedBase64EncodedString = res2.result().getJsonObject(\"binaryStuff\").getString(\"$binary\");\n //This could now converted back to bytes from the base 64 string\n } else {\n res2.cause().printStackTrace();\n }\n });\n\n } else {\n res.cause().printStackTrace();\n }\n\n});\n\n例如插入一个 object ID 并且读取它：\nString individualId = new ObjectId().toHexString();\n\nJsonObject document = new JsonObject()\n .put(\"name\", \"Stephen Hawking\")\n .put(\"individualId\", new JsonObject().put(\"$oid\", individualId));\n\nmongoService.save(\"smartPeople\", document, res -> {\n\n if (res.succeeded()) {\n\n String id = res.result();\n\n mongoService.findOne(\"smartPeople\", new JsonObject().put(\"_id\", id), null, res2 -> {\n if(res2.succeeded()) {\n String reconstitutedIndividualId = res2.result().getJsonObject(\"individualId\").getString(\"$oid\");\n } else {\n res2.cause().printStackTrace();\n }\n });\n\n } else {\n res.cause().printStackTrace();\n }\n\n});\n\n例如获取 distinct 后的值：\nJsonObject document = new JsonObject().put(\"title\", \"The Hobbit\");\n\nmongoClient.save(\"books\", document, res -> {\n\n if (res.succeeded()) {\n\n mongoClient.distinct(\"books\", \"title\", String.class.getName(), res2 -> {\n System.out.println(\"Title is : \" + res2.result().getJsonArray(0));\n });\n\n } else {\n res.cause().printStackTrace();\n }\n\n});\n\n例如获取批量模式下 distinct 的值：\nJsonObject document = new JsonObject().put(\"title\", \"The Hobbit\");\n\nmongoClient.save(\"books\", document, res -> {\n\n if (res.succeeded()) {\n\n mongoClient.distinctBatch(\"books\", \"title\", String.class.getName(), res2 -> {\n System.out.println(\"Title is : \" + res2.result().getString(\"title\"));\n });\n\n } else {\n res.cause().printStackTrace();\n }\n\n});\n\n客户端参数配置\n此客户端把配置参数放在 JSON 对象中。\n此客户端支持以下这些参数：\n\ndb_name\n使用的 mongoDB 实例的数据库名称。默认是 default_db\n\nuseObjectId\n此参数用来支持 ObjectId 的持久化和检索。如果设置为 true ，将会在集合的文档中，以 16 进制的字符串来保存 MongoDB 的 ObjectId 类型的字段。而且在设置为 true 后，可以让文档基于创建时间排序（译者注：前4个字节用来存储创建的时的时间戳，精确到秒）。您也可以通过使用 ObjectId::getDate() 方法，从这个 16进制的字符串中导出创建时间。若您选择其他类型作为 _id ，则设置此参数为 false 。如果您保存的文档中，没有设置 _id 字段的值，将会默认的生成 16进制的字符串作为 _id 。此参数默认为 false。\n\n\n此客户端尝试着支持驱动所支持的大多数参数配置。有两种配置方式，一种是连接字符串，另一种是驱动配置选项。\n\n请注意：如果使用了字符串连接的方式，此客户端将会忽略所有配置选项。\n\n\nconnection_string\n连接字符串，指的是创建客户端的字符串，例如：mongodb://localhost:27017 。有关连接字符串格式的更多信息，请参考驱动程序文档。\n\n\n驱动配置的具体选项\n{\n // Single Cluster Settings\n \"host\" : \"127.0.0.1\", // string\n \"port\" : 27017, // int\n\n // Multiple Cluster Settings\n \"hosts\" : [\n {\n \"host\" : \"cluster1\", // string\n \"port\" : 27000 // int\n },\n {\n \"host\" : \"cluster2\", // string\n \"port\" : 28000 // int\n },\n ...\n ],\n \"replicaSet\" : \"foo\", // string\n \"serverSelectionTimeoutMS\" : 30000, // long\n\n // Connection Pool Settings\n \"maxPoolSize\" : 50, // int\n \"minPoolSize\" : 25, // int\n \"maxIdleTimeMS\" : 300000, // long\n \"maxLifeTimeMS\" : 3600000, // long\n \"waitQueueMultiple\" : 10, // int\n \"waitQueueTimeoutMS\" : 10000, // long\n \"maintenanceFrequencyMS\" : 2000, // long\n \"maintenanceInitialDelayMS\" : 500, // long\n\n // Credentials / Auth\n \"username\" : \"john\", // string\n \"password\" : \"passw0rd\", // string\n \"authSource\" : \"some.db\" // string\n // Auth mechanism\n \"authMechanism\" : \"GSSAPI\", // string\n \"gssapiServiceName\" : \"myservicename\", // string\n\n // Socket Settings\n \"connectTimeoutMS\" : 300000, // int\n \"socketTimeoutMS\" : 100000, // int\n \"sendBufferSize\" : 8192, // int\n \"receiveBufferSize\" : 8192, // int\n \"keepAlive\" : true // boolean\n\n // Heartbeat socket settings\n \"heartbeat.socket\" : {\n \"connectTimeoutMS\" : 300000, // int\n \"socketTimeoutMS\" : 100000, // int\n \"sendBufferSize\" : 8192, // int\n \"receiveBufferSize\" : 8192, // int\n \"keepAlive\" : true // boolean\n }\n\n // Server Settings\n \"heartbeatFrequencyMS\" : 1000 // long\n \"minHeartbeatFrequencyMS\" : 500 // long\n}\n\n驱动参数说明\n\nhost\nmongoDB 实例运行的地址。默认是 127.0.0.1。 如果设置了 hosts 参数，就会忽略host 参数\n\nport\nmongoDB 实例监听的端口。默认是 27017。如果设置了 hosts 参数，就会忽略 port 参数\n\nhosts\n表示支持 MongoDB 集群（分片／复制）的一组地址和端口\n\nhost\n集群中某个运行实例的地址\n\nport\n集群中某个运行实例监听的端口\n\nreplicaSet\n某个 mongoDB 实例作为副本集的名称\n\nserverSelectionTimeoutMS\n驱动选择服务器的最大时间，单位毫秒\n\nmaxPoolSize\n连接池最大连接数。默认为 100\n\nminPoolSize\n连接池最小连接数。默认为 100\n\nmaxIdleTimeMS\n连接池的连接最大空闲时间。默认为 0，表示一直存在\n\nmaxLifeTimeMS\n连接池的连接最大存活时间。默认为 0，表示永远存活。\n\nwaitQueueMultiple\n连接池中最大等待连接数。默认为 500\n\nwaitQueueTimeoutMS\n线程等待作为连接的最长等待时间。默认为 120000（2分钟）\n\nmaintenanceFrequencyMS\n维护任务进行循环检查连接的时间间隔（译者注：维护任务会定时检查连接的状态，直到连接池剩下最小连接数）。默认为 0\n\nmaintenanceInitialDelayMS\n连接池启动后，维护任务第一次启动的时间。默认为 0。\n\nusername\n授权的用户名。默认为 null（意味着不需要授权）\n\npassword\n授权的密码\n\nauthSource\n与授权用户关联的数据库名称。默认值为 db_name\n\nauthMechanism\n所使用的授权认证机制。请参考 Authentication 来获取更多信息。\n\ngssapiServiceName\n当使用 GSSAPI 的授权机制时，所使用的 Kerberos 服务名。\n\nconnectTimeoutMS\n打开连接超时的时间，单位毫秒。默认为10000（10 秒）\n\nsocketTimeoutMS\n在 socket 上接收或者发送超时的时间。默认为 0 ，意味着永远不超时（译者注：这是客户端的超时时间。如果一个 insert 达到了 socketTimeoutMS， 将无法得知服务器是否已写入）。\n\nsendBufferSize\n设置 socket 发送缓冲区大小（SO_SNDBUF）。默认为 0，这将使用操作系统默认大小。\n\nreceiveBufferSize\n设置 socket 接收缓冲区大小（SO_RCVBUF）。默认为 0，这将使用操作系统默认大小。\n\nkeepAlive\n设置是否复用 socket（SO_KEEPALIVE）连接。默认为 false\n\nheartbeat.socket\n配置集群监视器监控 MongoDB 集群的 socket 连接情况的参数\n\nheartbeatFrequencyMS\n集群监视器访问每个集群服务器的频率。默认为 5000 （5s）\n\nminHeartbeatFrequencyMS\n最小心跳频率。默认为 1000 （1s）\n\n\n\n请注意：上面提到的各类参数的默认值，都是 MongoDB Java 驱动的默认值。请参考驱动文档来获取最新信息。\n\n\n\n原文档更新于 2017-03-15 15:54:14 CET\n\n"},"data/JDBCClient.html":{"url":"data/JDBCClient.html","title":"JDBC Client","keywords":"","body":"Vert.x JDBC Client\n\n原文档：Vert.x JDBC Client \n\n使用 Vert.x JDBC Client，可以让我们的 Vert.x 应用程序通过异步的方式，与任何支持 JDBC 的数据库进行交互。\nVert.x JDBC Client 的接口定义为 JDBCClient。\n要使用Vert.x JDBC Client，需要添加下面的依赖：\n\nMaven (在 pom.xml 文件中):\n\n\n io.vertx\n vertx-jdbc-client\n 3.4.1\n\n\n\nGradle (在 build.gradle 文件中):\n\ncompile 'io.vertx:vertx-jdbc-client:3.4.1'\n\n创建 Vert.x JDBC Client 对象\n接下来，我们一起来看下创建 Vert.x JDBC Client 对象的几种方式。\n默认使用共享的数据源\n大部分情况下，我们希望在不同的 Vert.x JDBC Client 对象之间，共享一个数据源。\n考虑这样一种情况：我们在部署 Verticle 时，设置了 Verticle 拥有多个实例化的对象，但是我们希望每个 Verticle 实例能够共享同一个数据源，而不是单独为每个 Verticle 实例设置不同的数据源。\n要解决上面的问题，我们可以这么做：\nJDBCClient client = JDBCClient.createShared(vertx, config);\n\n只有在第一次调用 JDBCClient.createShared 方法的时候，才会真正的根据 config 参数创建一个数据源。\n之后再调用此方法，只会返回一个新的 Vert.x JDBC Client 对象，但使用的是相同的数据源。这时 config 参数也就不再有作用。\n指定数据源名称\n我们还可以像下面这样，在创建一个 Vert.x JDBC Client 对象的时候指定数据源的名称：\nJDBCClient client = JDBCClient.createShared(vertx, config, \"MyDataSource\");\n\n如果不同的 Vert.x JDBC client 对象使用了相同的Vert.x 对象和相同的数据源名称，那么它们将共享数据源。\n同样的（与默认使用共享的数据源），只有在第一次调用JDBCClient.createShared方法的时候，才会真正的根据 config 参数创建一个数据源。\n之后再调用此方法，只会返回一个新的 Vert.x JDBC Client 对象，但使用的是相同的数据源。这时 config 参数也就不再有作用。\n当我们希望不同含义的 Vert.x JDBC Client 对象拥有不同的数据源时，可以采用这种方式来创建它的对象。比如它们要与不同的数据源进行交互。\n创建不共享数据源的 Vert.x JDBC Client 对象\n在大部分情况下，我们会希望在不同的 Vert.x JDBC Client 对象之间共享数据源。但有时候，却恰恰相反。\n这时，可以调用 JDBCClient.createNonShared 方法：\nJDBCClient client = JDBCClient.createNonShared(vertx, config);\n\n每次调用此方法，就相当于在调用 JDBCClient.createShared 方法时加上了具有唯一名称的数据源参数。\n指定数据源\n如果我们已经存在一个数据源，也可以在创建 Vert.x JDBC Client 对象的时候就直接指定它：\nJDBCClient client = JDBCClient.create(vertx, dataSource);\n\n关闭客户端\n我们可以较长时间的持有 Vert.x JDBC Client 对象（比如在 Verticle 的整个生命周期里），可一旦不再使用它后，就应该关闭它。\n在多个 Vert.x JDBC Client 对象共享数据源的情况下，这个数据源对象维护着一个引用计数器。一旦此数据源最后一个引用关闭后，这个数据源也就关闭了。\n在 Verticle 中自动关闭\n我们在 Verticle 中创建的 Vert.x JDBC Client 对象，会在这些 Verticle 卸载（undeploy）的时候自动关闭。\n获取数据库连接\n在创建 Vert.x JDBC Client 对象后，我们可以通过 getConnection 方法来获取一个数据库连接。\n此方法从连接池中获取一个数据库连接，并返回给回调方法：\nclient.getConnection(res -> {\n if (res.succeeded()) {\n\n SQLConnection connection = res.result();\n\n connection.query(\"SELECT * FROM some_table\", res2 -> {\n if (res2.succeeded()) {\n\n ResultSet rs = res2.result();\n // 用结果集results进行其他操作\n }\n });\n } else {\n // 获取连接失败 - 处理失败的情况\n }\n});\n\n获取的这个连接，是接口 SQLConnection 的一个实现。但是 SQLConnection 是一个通用接口，不只是在 Vert.x JDBC Client 中有用到。\n更多详细内容，可以参考文档 Vert.x Common SQL Interface 。\n配置参数\n在 Vert.x JDBC Client 创建或者部署的时候，我们应该把对应的配置参数传给它。\n常用的配置参数有下面这些：\n\nprovider_class\n此参数确定管理数据库连接池的实现类，默认是io.vertx.ext.jdbc.spi.impl.C3P0DataSourceProvider 。如果我们想使用其他的类，可以自己设置这个参数，但参数对应的类，必须实现接口DataSourceProvider。\n\nrow_stream_fetch_size\n为了提升性能，SQLRowStream 设置有内部缓存。默认缓存大小为 128。\n\n\n若我们使用的是 Vert.x 默认的 C3P0（DataSourceProvider），可以使用下面的配置参数：\n\nurl\n数据库 JDBC 连接地址\n\ndriver_class\nJDBC 驱动\n\nuser\n数据库用户名\n\npassword\n数据库密码\n\nmax_pool_size\n连接池最大连接数，默认15\n\ninitial_pool_size\n连接池初始连接数，默认3\n\nmin_pool_size\n连接池最小连接数\n\nmax_statements\n预处理SQL语句最小缓存数，默认 0\n\nmax_statements_per_connection\n每个数据库连接的最大预处理SQL缓存数，默认0\n\nmax_idle_time\n 空闲连接保留时间，默认0 (代表一直保留)\n\n\n其它连接池实现：\n\nBoneCP\nHikari\n\n类似于 C3P0，上面的连接池也可以通过传递一个 JsonObject 对象来配置参数。考虑这样一种情况，应用程序要运行在一个 Vert.x 环境中，但我们却不想通过 fat jar 的方式来部署，且在没有权限把 JDBC 驱动包加到 Vert.x lib 目录下的时候，建议使用 BoneCP，并在命令行上加上-cp标示。\n如果想要配置 C3P0 更多的参数，我们可以在 classpath 下添加文件c3p0.properties。\n例如：\nJsonObject config = new JsonObject()\n .put(\"url\", \"jdbc:hsqldb:mem:test?shutdown=true\")\n .put(\"driver_class\", \"org.hsqldb.jdbcDriver\")\n .put(\"max_pool_size\", 30);\n\nJDBCClient client = JDBCClient.createShared(vertx, config);\n\n需要注意，Hikari 使用的配置参数不一样：\n\njdbcUrl 数据库 JDBC 连接地址\ndriverClassName JDBC 驱动类名\nmaximumPoolSize 连接池最大连接数\nusername 数据库用户名 (password 数据库密码)\n\n可以阅读 Hikari documentation 和 BoneCP documentation 来了解更多关于两个数据源的知识。\nJDBC 驱动\n如果使用默认的DataSourceProvider实现类（C3P0实现），我们要把JDBC 驱动jar包放在编译路径下。\n如果我们的 Vert.x 应用程序打包成 fat jar，要确保 JDBC 驱动包含在里面。如果我们的 Vert.x 应用程序通过 vertx 命令行启动，要确保 JDBC 驱动包在 ${VERTX_HOME}/lib 路径里面。\n使用不同的连接池时，可能会稍有不一样。\n数据类型\n由于 Vert.x 使用 JSON 作为标准的消息格式，这使得客户端在接受数据类型时受到很多限制。我们只能从 JsonObject 获得下面的数据类型：\n\nnull\nboolean\nnumber\nstring\n\n时间类型 (TIME, DATE, TIMESTAMP) 可以自动转换。需要注意的是，我们可以选择性的使用 UUID 的转换。虽然大部分数据库都支持 UUID，可并不是所有都支持，比如说 MySQL 就不支持。这种情况下，建议使用 VARCHAR(36) 类型的字段。对于其他支持 UUID 的数据库来说，使用下面的参数后，可以对 UUID 进行自动类型转换。\n{ \"castUUID\": true }\n\n这样，UUID 将会被作为原生类型（译者注：java.util.UUID）来处理。\n作为 OSGI 应用程序\nVert.x JDBC Client 也可以作为 OSGI 应用程序。但是，必须首先部署它所有的依赖。但有些连接池要求必须从 classpath 加载 JDBC 驱动，这样的就不能作为 OSGI 应用程序。\n\n原文档更新于2017-03-15 15:54:14 CET\n"},"data/SQLCommon.html":{"url":"data/SQLCommon.html","title":"SQL Common","keywords":"","body":"Vert.x Common SQL Interface\n\n原文档：Vert.x Common SQL interface\n\nVert.x Common SQL Interface组件定义了 Vert.x 与各种 SQL 服务交互的方法。\n您必须通过使用特定的 SQL 服务（例如 JDBC/MySQL/PostgreSQL）的接口来获取数据库连接。\n要使用此组件，需要添加下列依赖：\n\nMaven (在 pom.xml文件中):\n\n\n io.vertx\n vertx-sql-common\n 3.4.1\n\n\n\nGradle (在 build.gradle 文件中):\n\ncompile 'io.vertx:vertx-sql-common:3.4.1'\n\nSQL 连接\n我们用 SQLConnection 接口来表示数据库连接（译者注：此接口中包含各种基本的操作方法）。\n自动提交\n当您获取的数据库连接，其自动提交选项（auto commit）默认设置为 true。这意味着您的每个操作都将在单独的事务中有效执行。\n如果您希望在同一个事务中执行多个操作，就应该使用 setAutoCommit 方法设置自动提交为false。\n当操作完成时，回调方法将会被执行：\nconnection.setAutoCommit(false, res -> {\n if (res.succeeded()) {\n // 成功！\n } else {\n // 失败!\n }\n});\n\n执行查询\n您可以使用 query 方法执行查询操作。\n查询语句（原生SQL）传给数据库时，不会经过任何修改。\n当查询结束时，将执行回调方法处理结果。查询结果包装在 ResultSet 中。\nconnection.query(\"SELECT ID, FNAME, LNAME, SHOE_SIZE from PEOPLE\", res -> {\n if (res.succeeded()) {\n // 获得 result set\n ResultSet resultSet = res.result();\n } else {\n // 失败!\n }\n});\n\nResultSet 类代表查询结果。\n您可以通过 getColumnNames 方法获得查询结果的列名 List 集合，实际的结果集可以通过 getResults 方法获得。结果集被包装成了一组 JsonArray 列表，其中的每个元素代表一行结果。\nList columnNames = resultSet.getColumnNames();\n\nList results = resultSet.getResults();\n\nfor (JsonArray row : results) {\n\n String id = row.getString(0);\n String fName = row.getString(1);\n String lName = row.getString(2);\n int shoeSize = row.getInteger(3);\n\n}\n\n您还可以使用 getRows 方法来获得被包装成了 JSON 对象列表（List）的结果集，这样能让 API 的操作更简单些。但要注意的是，查询出的结果集中可能会出现重复的列名。若遇到这样的情况，您应该选择使用 getResults 方法。\n下面是将结果集作为 JsonObject 进行迭代的例子：\nList rows = resultSet.getRows();\n\nfor (JsonObject row : rows) {\n\n String id = row.getString(\"ID\");\n String fName = row.getString(\"FNAME\");\n String lName = row.getString(\"LNAME\");\n int shoeSize = row.getInteger(\"SHOE_SIZE\");\n\n}\n\n预编译查询\n您可以使用 queryWithParams 方法执行预编译查询（prepared statement queries）。此方法接受含参数占位符的SQL查询语句以及 JsonArray 对象（用于传递参数）或参数值。\nString query = \"SELECT ID, FNAME, LNAME, SHOE_SIZE from PEOPLE WHERE LNAME=? AND SHOE_SIZE > ?\";\nJsonArray params = new JsonArray().add(\"Fox\").add(9);\n\nconnection.queryWithParams(query, params, res -> {\n\n if (res.succeeded()) {\n // 获得 result set\n ResultSet resultSet = res.result();\n } else {\n // 失败!\n }\n});\n\n执行 INSERT/UPDATE/DELETE 语句\n您可以使用 update 方法来执行更新数据库的操作（包括增、删、改）。\n更新语句（原生SQL）传给数据库时，不会经过任何处理。\n当更新结束时，将执行回调方法处理结果。更新结果包装在 UpdateResult 对象中。\n您可以通过 getUpdated 方法获得更新的数据条数，并且如果更新操作有生成主键，可以通过 getKeys方法获得对应的主键。\nconnection.update(\"INSERT INTO PEOPLE VALUES (null, 'john', 'smith', 9)\", res -> {\n if (res.succeeded()) {\n\n UpdateResult result = res.result();\n System.out.println(\"Updated no. of rows: \" + result.getUpdated());\n System.out.println(\"Generated keys: \" + result.getKeys());\n\n } else {\n // Failed!\n }\n});\n\n预编译更新\n您可以使用 updateWithParams 方法来执行预编译更新（prepared statement updates）。此方法接受含参数占位符的SQL更新语句以及 JsonArray 对象（用于传递参数）或参数值。\nString update = \"UPDATE PEOPLE SET SHOE_SIZE = 10 WHERE LNAME=?\";\nJsonArray params = new JsonArray().add(\"Fox\");\n\nconnection.updateWithParams(update, params, res -> {\n\n if (res.succeeded()) {\n\n UpdateResult updateResult = res.result();\n\n System.out.println(\"No. of rows updated: \" + updateResult.getUpdated());\n\n } else {\n\n // Failed!\n\n }\n});\n\n可调用语句\n您可以使用 callWithParams 方法来执行可调用语句（callable statements），例如 SQL 函数或者存储过程。此方法接受以下参数：\n\n可调用语句。可以使用标准 JDBC 格式 { call func_proc_name() }，也可以选择使用占位符传参数的形式，例如：{ call func_proc_name(?, ?) }\n输入参数集（params），JsonArray 类型\n包含输出类型的输出结果集（output），JsonArray 类型，例如：[null, 'VARCHAR']\n对应的回调函数（resultHandler）\n\n请注意，输出结果集的 JsonArray 的下标和输入参数的 JsonArray 同样重要。如果第二个参数代表输出结果集，那么应该设置结果集的 JsonArray 的第一个元素为 null。\n有些 SQL 函数只使用 return 关键字返回输出结果集，这时可以这样调用：\nString func = \"{ call one_hour_ago() }\";\n\nconnection.call(func, res -> {\n\n if (res.succeeded()) {\n ResultSet result = res.result();\n } else {\n // Failed!\n }\n});\n\n但是当您使用存储过程时，还是需要使用它的参数来返回结果集。如果一个存储过程没有返回值的话，可以像下面这样调用：\nString func = \"{ call new_customer(?, ?) }\";\n\nconnection.callWithParams(func, new JsonArray().add(\"John\").add(\"Doe\"), null, res -> {\n\n if (res.succeeded()) {\n // 成功!\n } else {\n // 失败!\n }\n});\n\n但是如果存储过程有返回值的话，需要像下面这样调用：\nString func = \"{ call customer_lastname(?, ?) }\";\n\nconnection.callWithParams(func, new JsonArray().add(\"John\"), new JsonArray().addNull().add(\"VARCHAR\"), res -> {\n\n if (res.succeeded()) {\n ResultSet result = res.result();\n } else {\n // 失败!\n }\n});\n\n请注意：输入输出参数的下标必须匹配 ? 的下标，并且输出结果集元素的值必须是结果集类型的字符串表示。\n为避免歧义，实现类需要遵循以下规则（译者注：可参考 Vert.x JDBC Client 的实现源码 JDBCStatementHelper.fillStatement(statement, in, out)）：\n\n当 IN 参数的元素是 NOT NULL 时，此元素将被注册为输入参数\n当 IN 参数的元素是 null 时，将进一步去检查 OUT 参数的元素值，再做判断\n若当 IN 参数的元素是 null，且 OUT 参数的元素值不是 null 时，OUT 参数的元素值将被注册为输出参数\n若当 IN 参数的元素是 null，且 OUT 参数的元素值也是 null 时， IN 参数的元素将被当作 NULL 值传入存储过程\n\n注册为 OUT 的参数，设置成了 ResultSet 的 output 属性。\n批量操作\nVert.x SQL 公共接口定义了3种批量操作的方法：\n\n批量操作 batch\n批量预编译操作 batchWithParams\n批量调用语句 batchCallableWithParams\n\n批量操作能执行一组 SQL 语句（List 类型），例如：\nList batch = new ArrayList<>();\nbatch.add(\"INSERT INTO emp (NAME) VALUES ('JOE')\");\nbatch.add(\"INSERT INTO emp (NAME) VALUES ('JANE')\");\n\nconnection.batch(batch, res -> {\n if (res.succeeded()) {\n List result = res.result();\n } else {\n // 失败!\n }\n});\n\n预编译或者调用语句将会根据参数列表，来重复使用 SQL 语句，例如：\nList batch = new ArrayList<>();\nbatch.add(new JsonArray().add(\"joe\"));\nbatch.add(new JsonArray().add(\"jane\"));\n\nconnection.batchWithParams(\"INSERT INTO emp (name) VALUES (?)\", batch, res -> {\n if (res.succeeded()) {\n List result = res.result();\n } else {\n // Failed!\n }\n});\n\n执行其他操作\n若需要执行其他数据库操作，例如您可以使用 execute 方法来执行 CREATE TABLE 语句。\nSQL语句传给数据库时，不会经过任何处理。操作结束时将调用回调方法。\nString sql = \"CREATE TABLE PEOPLE (ID int generated by default as identity (start with 1 increment by 1) not null,\" +\n \"FNAME varchar(255), LNAME varchar(255), SHOE_SIZE int);\";\n\nconnection.execute(sql, execute -> {\n if (execute.succeeded()) {\n System.out.println(\"Table created !\");\n } else {\n // 失败!\n }\n});\n\n返回多个结果集\n某些情况下，您的查询语句可能返回多个结果集 ResultSet，此时，返回的结果集会被转成纯 JSON，并且为了保持稳定性，下一个 ResultSet 被作为当前 ResultSet 的 next 属性链接着。一种简单的遍历所有结果集的方式如下：\nwhile (rs != null) {\n // do something with the result set...\n\n // next step\n rs = rs.getNext();\n}\n\nStreaming\n在处理大数据结果集时，不建议使用上面提到的API，而是使用数据流（stream data）的方式。因为它能够避免把所有的返回值加载到内存中，而且得到的 JSON 格式的数据也能够一行行的处理，例如：\nconnection.queryStream(\"SELECT * FROM large_table\", stream -> {\n if (stream.succeeded()) {\n stream.result().handler(row -> {\n // 处理 row...\n });\n }\n});\n\n您还可以控制 Stream 何时停止，何时恢复，何时结束。对于查询返回多个结果集的情况，您应该使用 ended event 来获得下一个结果集。如果有，Stream 将会得到新的结果集，若没有，将会调用结束方法。\nconnection.queryStream(\"SELECT * FROM large_table; SELECT * FROM other_table\", stream -> {\n if (stream.succeeded()) {\n SQLRowStream sqlRowStream = stream.result();\n\n sqlRowStream\n .resultSetClosedHandler(v -> {\n // 如果有新的结果集，将会重启 stream\n sqlRowStream.moreResults();\n })\n .handler(row -> {\n // 处理row\n })\n .endHandler(v -> {\n // 没有新的结果集需要处理\n });\n }\n});\n\n使用事务\n要使用事务，首先要用 setAutoCommit 方法设置 auto-commit 为 false。\n然后您就可以执行在同一个事务中的操作，在需要提交事务时，调用 commit 方法；在需要回滚时，调用 rollback 方法。\n一旦 commit/rollback 方法执行结束，将会调用回调方法。然后下一个事务也将自动开始。\nconnection.commit(res -> {\n if (res.succeeded()) {\n // 事物提交成功!\n } else {\n // 事物提交失败!\n }\n});\n\n关闭连接\n您在用完连接后，必须使用 close 方法把连接返回给连接池。\n\n\n原文档更新于2017-03-15 15:54:14 CET\n\n"},"data/RedisClient.html":{"url":"data/RedisClient.html","title":"Redis Client","keywords":"","body":"Vert.x Redis\n\n原文档：Vert.x Redis\n\nVert.x Redis Client 是 Vert.x 配套的 Redis 客户端实现。\n您可以通过 Vert.x Redis Client 来对 Redis 中的数据进行保存、获取、搜索和删除。Redis 是一个基于BSD协议开源的高性能Key-Value数据库。它可以存储字符串、哈希(hashes)、列表、无序集合(sets)和有序集合(sorted sets)，所以通常被用做结构化数据存储服务器。要使用本组件，您必须有一个运行中的 Redis 实例。\nRedis 有着丰富的 API，总结如下：\n\nCluster - 与集群相关的命令。要使用这些命令，Redis 服务器的版本必须 >=3.0.0\nConnection - 切换 DB、建立连接、断开连接、授权相关的命令\nHashes - 操作 hash 相关的命令\nHyperLogLog - 使用 HyperLogLog 算法来快速计算元素基数的相关命令\nKeys - 操作 Redis key 的相关命令\nList - 操作 List 的相关命令\nPub/Sub - 发布／订阅模式的消息队列相关命令\nScripting - 解释运行 Lua 脚本的相关命令\nServer - 管理 Redis 服务器的相关命令\nSets - 操作无序集合的相关命令\nSorted Sets - 操作有序集合的相关命令\nStrings - 操作字符串的相关命令\nTransactions - 处理事务的相关命令\n\n使用 Vert.x Redis\n要使用 Vert.x Redis 客户端，需要添加下列依赖：\n\nMaven (在 pom.xml 文件中):\n\n\n io.vertx\n vertx-redis-client\n 3.4.1\n\n\n\nGradle (在 build.gradle 文件中):\n\ncompile 'io.vertx:vertx-redis-client:3.4.1'\n\n连接 Redis 服务器\n要连接到 Redis 服务器，需要配置一些参数。配置参数包装在 RedisOptions 对象中，有以下这些参数：\n\nhost: 默认是 localhost\nport: 默认是 6379\nencoding: 默认是 UTF-8\ntcpKeepAlive: 默认是 true\ntcpNoDelay: 默认是 true\n\n例如：\nRedisOptions config = new RedisOptions()\n .setHost(\"127.0.0.1\");\n\nRedisClient redis = RedisClient.create(vertx, config);\n\nVert.x Redis 客户端在连接 Redis 服务器失败时，会尝试重连。所以，如果您连接的 Redis 服务器需要授权，或者您连接的 Redis 服务器的 DB 不是默认 DB，您需要提供授权的密码，或者 DB 的 ID，配置参数如下：\n\nauth\nselect\n\n如果您不这样做，而是手动调用 auth 或者 select 方法，那么当出现 socket 错误的时候，Vert.x Redis 客户端将不知道如何修复错误。\n执行命令\n当使用 Vert.x Redis 客户端连接到 Redis 服务器后，就可以使用 Vert.x Redis 客户端执行 Redis 命令。Vert.x Redis 客户端为执行 Redis 命令提供了一套十分简洁的 API，省去了手写命令的麻烦。例如，如果想通过 key 获得 value的话，可以这样：\nRedisClient redis = RedisClient.create(vertx, new RedisOptions());\n\nredis.get(\"mykey\", res -> {\n if (res.succeeded()) {\n // so something...\n }\n});\n\n要想了解更多 Redis 命令，请参考 Redis 官方文档。\n发布／订阅模式\nRedis 支持发布／订阅模式的消息队列。需要注意，一旦一个 Redis 连接被注册为订阅者时，此连接将不能再执行其他命令，直到这个连接使用取消订阅者的命令。\n可以这样注册一个订阅者：\nvertx.eventBus().consumer(\"io.vertx.redis.channel1\", received -> {\n // 操作接收到的消息\n JsonObject value = received.body().getJsonObject(\"value\");\n // value 是一个包含下面数据的 JSON 对象\n // channel - 发布消息的 channel\n // pattern - 若您使用匹配符来匹配消息 channel，Pattern 代表的是匹配符\n // message - 发布的消息载体\n});\n\nRedisClient redis = RedisClient.create(vertx, new RedisOptions());\n\nredis.subscribe(\"channel1\", res -> {\n if (res.succeeded()) {\n // so something...\n }\n});\n\n发布消息：\nRedisClient redis = RedisClient.create(vertx, new RedisOptions());\n\nredis.publish(\"channel1\", \"Hello World!\", res -> {\n if (res.succeeded()) {\n // so something...\n }\n});\n\n更简洁的 hash 命令\n大部分 Redis 命令使用单个字符串或者字符串数组来作为参数，并且返回的也是单个字符串或者字符串数组。不过在处理 hash 值时，有其他一些更简洁的方式。\nhgetall 命令\nhgetall 命令返回的结果将被转换成 JSON 对象。这样，您就可以使用 JSON 的语法来进行交互，这在与 Event Bus 通信时十分方便。\nmset 命令\n您可以向 mset 命令传入一个 JSON 对象以在 hash 中设置多个值。需要注意 key 和 value 都将被转换成字符串。\n{\n keyName: \"value\",\n otherKeyName: \"other value\"\n}\n\nmsetnx 命令\n您可以向 msetnx 命令传入一个 JSON 对象以在 hash 中设置多个值（译者注：msetnx 命令，必须当且仅当所有给定 key 都不存在）。需要注意 key 和 value 都将被转换成字符串。\n{\n keyName: \"value\",\n otherKeyName: \"other value\"\n}\n\nhmset 命令\n您可以向 hmset 命令传入一个 JSON 对象以在 hash 中设置多个值（译者注：hmset 命令，如果给定 key 不存在，将创建新的 key）。需要注意 key 和 value 都将被转换成字符串。\n{\n keyName: \"value\",\n otherKeyName: \"other value\"\n}\n\nzadd 命令\n调用 zaddMany 方法可以同时向有序集合中添加多个member。需要注意 key 和 value 都将被转换成字符串。\n\n译者注：在 Vert.x Redis Client 中，zadd 方法和 zaddMany 方法都对应 Redis 中的 zadd 命令。不同之处在于，zaddMany 方法可以添加多个 score-member。\n译者注：实际在 zaddMany 方法中，传入的是 Map 类型的参数。\n\n{\n score: \"member\",\n otherScore: \"other member\"\n}\n\n服务器信息\n为让返回的服务器信息易于操作，Vert.x Redis 客户端将会把服务器信息转换成利于理解的 JSON 格式。格式为：JSON 对象的每个部分都包装着属于着这部分的属性。不在这个部分的属性，将会以其他的顶级对象部分展现：\n{\n server: {\n redis_version: \"2.5.13\",\n redis_git_sha1: \"2812b945\",\n redis_git_dirty: \"0\",\n os: \"Linux 2.6.32.16-linode28 i686\",\n arch_bits: \"32\",\n multiplexing_api: \"epoll\",\n gcc_version: \"4.4.1\",\n process_id: \"8107\",\n ...\n },\n memory: {...},\n client: {...},\n ...\n}\n\nEval 和 Evalsha 命令\neval 和 evalsha 命令十分特殊，因为它们可以返回任意类型。Vert.x 基于 Java 语言，而 Java 是强类型语言，并且我们又要避免使用 Object 类型，这使得返回任意类型变得比较困难。避免使用 Object 类型的原因是因为 Vert.x 也是多语言的，而不同语言之间的类型转换实现起来十分的复杂和困难。所以，我们会用 JsonArray 来包装 eval 和 evalsha 命令的返回值，即便是像下面这样简单的脚本：\nreturn 10\n\n执行上面的脚本，将返回一个 JsonArray 对象，且下标为 0 的值为 10。\n\n\n原文档更新于2017-03-15 15:54:14 CET\n\n"},"data/MySQL&PostgreSQLClient.html":{"url":"data/MySQL&PostgreSQLClient.html","title":"MySQL/PostgreSQL Client","keywords":"","body":"Vert.x MySQL/PostgreSQL Client\n\n原文档：Vert.x MySQL/PostgreSQL client\n\n此异步 MySQL/PostgreSQL 客户端给需要与 MySQL 或 PostgreSQL 数据库交互的 Vert.x 应用提供了相应的接口。\nVert.x MySQL/PostgreSQL Client（以下简称客户端）底层实现基于 Mauricio Linhares 写的异步驱动 postgresql-async。此组件让 Vert.x 应用能够以异步、非阻塞的方式访问 MySQL 或者 PostgreSQL 数据库。\n使用 Vert.x MySQL/PostgreSQL 客户端\n这部分内容阐述了如何在您的应用中配置 Vert.x MySQL/PostgreSQL 客户端。\n在常规应用中\n要使用 Vert.x MySQL / PostgreSQL 客户端，您需要把下面的 jar 包加入 CLASSPATH:\n\nvertx-mysql-postgresql-client 3.4.1 (此客户端)\nscala-library 2.11.4\npostgress-async-2.11 和 mysql-async-2.11，来自 https://github.com/mauricio/postgresql-async\njoda time\n\n所有这些都可以从 Maven 中心库下载。\n在打包成 fat jar 的应用中\n如果您使用 Maven 或者 Gradle 构建 Fat-jar 应用，只需要加入下面的依赖：\n\nMaven (在 pom.xml 文件中):\n\n\n io.vertx\n vertx-mysql-postgresql-client\n 3.4.1\n\n\n\nGradle (在 build.gradle 文件中):\n\ncompile 'io.vertx:vertx-mysql-postgresql-client:3.4.1'\n\n在使用 Vert.x 环境的应用中\n如果您使用 Vert.x 环境，需要把上面列出的 jar 包加入到 $VERTX_HOME/lib 路径下。\n或者，您可以编辑位于 $VERTX_HOME 路径下的vertx-stack.json 文件，并且设置 vertx-mysql-postgresql-client 的依赖为 \"included\": true。完成后，执行命令：vertx resolve --dir=lib --stack= ./vertx-stack.json，就会下载此客户端及它的依赖。\n创建客户端对象\n有几种方式来创建客户端，我们一起来看下。\n使用默认共享连接池\n大部分情况下，您都将希望不同的客户端实例（AsyncSQLClient）共享一个连接池。\n考虑这样一种情况：您在部署 Verticle 时，设置了 Verticle 拥有多个实例化的对象，但是您希望每个 Verticle 实例能够共享同一个数据源，而不是单独为每个 Verticle 实例设置不同的数据源。\n要解决上面的问题，您可以这么做：\nJsonObject mySQLClientConfig = new JsonObject().put(\"host\", \"mymysqldb.mycompany\");\nAsyncSQLClient mySQLClient = MySQLClient.createShared(vertx, mySQLClientConfig);\n\n// 创建一个 PostgreSQL 客户端\n\nJsonObject postgreSQLClientConfig = new JsonObject().put(\"host\", \"mypostgresqldb.mycompany\");\nAsyncSQLClient postgreSQLClient = PostgreSQLClient.createShared(vertx, postgreSQLClientConfig);\n\n只有在第一次调用 MySQLClient.createShared 或者 PostgreSQLClient.createShared 方法的时候，才会真正地根据 config 参数创建一个数据源。\n之后再调用此方法，只会返回一个新的客户端实例，但使用的是相同的数据源。这时 config 参数也就不再有作用。\n指定数据源名称\n您还可以像下面这样，在创建一个客户端实例的时候指定数据源的名称：\nJsonObject mySQLClientConfig = new JsonObject().put(\"host\", \"mymysqldb.mycompany\");\nAsyncSQLClient mySQLClient = MySQLClient.createShared(vertx, mySQLClientConfig, \"MySQLPool1\");\n\n// To create a PostgreSQL client:\n\nJsonObject postgreSQLClientConfig = new JsonObject().put(\"host\", \"mypostgresqldb.mycompany\");\nAsyncSQLClient postgreSQLClient = PostgreSQLClient.createShared(vertx, postgreSQLClientConfig, \"PostgreSQLPool1\");\n\n如果不同的客户端对象使用了相同的 Vert.x 对象和相同的数据源名称，那么它们将共享数据源。\n只有在第一次调用 MySQLClient.createShared 或者 PostgreSQLClient.createShared 方法的时候，才会真正的根据 config 参数创建一个数据源。\n之后再调用此方法，只会返回一个新的客户端对象，但使用的是相同的数据源。这时 config 参数也就不再有作用。\n当我们希望不同含义的客户端对象拥有不同的数据源时，可以采用这种方式来创建它的对象，比如它们要与不同的数据库进行交互。\n创建不共享数据源的客户端对象\n在大部分情况下，我们会希望在不同的客户端实例之间共享数据源。但有时候，却恰恰相反。\n这时，可以调用MySQLClient.createNonShared 或者PostgreSQLClient.createNonShared 方法：\nJsonObject mySQLClientConfig = new JsonObject().put(\"host\", \"mymysqldb.mycompany\");\nAsyncSQLClient mySQLClient = MySQLClient.createNonShared(vertx, mySQLClientConfig);\n\n// 创建 PostgreSQL 客户端\n\nJsonObject postgreSQLClientConfig = new JsonObject().put(\"host\", \"mypostgresqldb.mycompany\");\nAsyncSQLClient postgreSQLClient = PostgreSQLClient.createNonShared(vertx, postgreSQLClientConfig);\n\n每次调用此方法，就相当于在调用 MySQLClient.createShared 或者 PostgreSQLClient.createShared 方法时加上了具有唯一名称的数据源参数。\n关闭客户端\n您可以较长时间的持有客户端对象（比如在 Verticle 的整个生命周期里），可一旦不再使用，就应该使用 close(handler) 或者 close() 方法来关闭它。\n获取数据库连接\n您可以使用 getConnection 方法来获得数据库连接。\n此方法从连接池中获取一个数据库连接，并返回给回调方法：\nclient.getConnection(res -> {\n if (res.succeeded()) {\n\n SQLConnection connection = res.result();\n\n // 获得一个连接\n\n } else {\n // 获取连接失败 - 处理异常\n }\n});\n\n一旦您用完一个数据库连接后，请确保关闭它。\n获取的连接，是接口 SQLConnection 的一个实现。但是 SQLConnection 是一个通用接口，不只是在此客户端中有用到。\n您可以在 Vert.x Common SQL Interface 文档 中了解如何去使用它。\n日期和时间戳\n只要您从数据库从获取时间格式的数据，此客户端都将会隐式将它们转换成 ISO 8601（yyyy-MM-ddTHH:mm:ss.SSS）格式的字符串。MySQL 会舍弃毫秒项，所以您会看到 .000。\n最后插入的数据id\n在表中插入新数据时，您也许希望获得数据库的自增长id。JDBC API 通常都会让您从数据库连接中得到最后一个插入的 id。在 MySQL 中，可以按照 JDBC API 描述的方式获得最后插入的 id，而在 PostgreSQL 中，您可以使用 RETURNING clause。您可以选择使用其中的一个 query 方法来获取返回的列。\n存储过程\n call 和 callWithParams 方法目前暂未实现。\n配置参数\nPostgreSql 和 MySql 客户端的配置参数一样：\n{\n \"host\" : ,\n \"port\" : ,\n \"maxPoolSize\" : ,\n \"username\" : ,\n \"password\" : ,\n \"database\" : ,\n \"charset\" : ,\n \"queryTimeout\" : \n}\n\n\nhost\n数据库主机地址，默认为 localhost。\n\nport\n数据库端口，PostgreSQL 默认为 5432，MySQL 默认为 3306 。\n\nmaxPoolSize\n最大连接数。默认为 10。\n\nusername\n数据库用户名，PostgreSQL 默认为 postgres ，MySQL 默认为 root 。\n\npassword\n数据库密码，默认不设置。\n\ndatabase\n数据库名称，默认为 testdb。\n\ncharset\n编码格式，默认为 UTF-8。\n\nqueryTimeout\n查询超时时间（毫秒），默认为 10000 (= 10秒)。\n\n\n\n\n原文档更新于2017-03-15 15:54:14 CET\n\n"},"integration/Integration.html":{"url":"integration/Integration.html","title":"Integration","keywords":"","body":"Vert.x Integration\n"},"integration/MailClient.html":{"url":"integration/MailClient.html","title":"Mail Client","keywords":"","body":"Vert.x Mail Client\n"},"integration/STOMPClient&Server.html":{"url":"integration/STOMPClient&Server.html","title":"STOMP Client & Server","keywords":"","body":"Vert.x STOMP Client & Server\n"},"integration/JCAAdaptor.html":{"url":"integration/JCAAdaptor.html","title":"JCA Adaptor","keywords":"","body":"Vert.x JCA Adaptor\n"},"integration/KafkaClient.html":{"url":"integration/KafkaClient.html","title":"Kafka Client","keywords":"","body":"Vert.x Kafka Client\n\n原文档\n组件源码\n组件示例\n\n中英文对照表\n\nconsumer：消费者\nconsumer group：消费组（Kafka中的设计）\npartition：分区（Kafka中的设计）\nproducer: 生产者\noffset：偏移量\n\n组件介绍\n此组件提供了 Kafka Client 的集成，可以以 Vert.x 的方式从 Apache Kafka 集群上消费或者发送消息。\n对于消费者(consumer)，API以异步的方式订阅消费指定的 topic 以及相关的分区(partition)，或者将消息以 Vert.x Stream 的方式读取（甚至可以支持暂停(pause)和恢复(resume)操作）。 \n对于生产者(producer)，API提供发送信息到指定 topic 以及相关的分区(partition)的方法，类似于向 Vert.x Stream 中写入数据。 \n\n警告：此组件处于技术预览阶段，因此在之后版本中API可能还会发生一些变更。\n\n使用 Vert.x Kafka Client\n要使用 Vert.x Kafka Client 组件，需要添加以下依赖：\n\nMaven（在 pom.xml文件中）：\n\n\n io.vertx\n vertx-kafka-client\n 3.4.1\n\n\n\nGradle（在build.gradle文件中）：\n\ncompile 'io.vertx:vertx-kafka-client:3.4.1'\n\n创建 Kafka Client\n创建 Consumer 和 Producer 以及使用它们的方法其实与原生的 Kafka Client 库非常相似，Vert.x 只是做了一层异步封装。\n我们需要对 Consumer 与 Producer 进行一些相关的配置，具体可以参考 Apache Kafka 的官方文档：\n\nConsumer Configs\nProducer Configs\n\n我们可以通过一个 Map 来包装这些配置，然后将其传入到 KafkaConsumer 接口或 KafkaProducer 接口中的 create 静态方法里来创建 KafkaConsumer 或 KafkaProducer：\nMap config = new HashMap<>();\nconfig.put(\"bootstrap.servers\", \"localhost:9092\");\nconfig.put(\"key.deserializer\", \"org.apache.kafka.common.serialization.StringDeserializer\");\nconfig.put(\"value.deserializer\", \"org.apache.kafka.common.serialization.StringDeserializer\");\nconfig.put(\"group.id\", \"my_group\");\nconfig.put(\"auto.offset.reset\", \"earliest\");\nconfig.put(\"enable.auto.commit\", \"false\");\n\n// 创建一个Kafka Consumer\nKafkaConsumer consumer = KafkaConsumer.create(vertx, config);\n\n在上面的例子中，我们在创建 KafkaConsumer 实例时传入了一个 Map 实例，用于指定要连接的 Kafka 节点列表（只有一个）以及如何对接收到的消息进行解析以得到 key 与 value。\n我们可以用类似的方法来创建 Producer：\nMap config = new HashMap<>();\nconfig.put(\"bootstrap.servers\", \"localhost:9092\");\nconfig.put(\"key.serializer\", \"org.apache.kafka.common.serialization.StringSerializer\");\nconfig.put(\"value.serializer\", \"org.apache.kafka.common.serialization.StringSerializer\");\nconfig.put(\"acks\", \"1\");\n\n// 创建一个Kafka Producer\nKafkaProducer producer = KafkaProducer.create(vertx, config);\n\n另外也可以使用 Properties 来代替 Map：\nProperties config = new Properties();\nconfig.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, \"localhost:9092\");\nconfig.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);\nconfig.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);\nconfig.put(ConsumerConfig.GROUP_ID_CONFIG, \"my_group\");\nconfig.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, \"earliest\");\nconfig.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, \"false\");\n\nKafkaConsumer consumer = KafkaConsumer.create(vertx, config);\n\n消息的 key 和 value 的序列化格式也可以作为 create 方法的参数直接传进去，而不是在相关配置中指定：\nProperties config = new Properties();\nconfig.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, \"localhost:9092\");\nconfig.put(ProducerConfig.ACKS_CONFIG, \"1\");\n\n// 注意这里的第三和第四个参数\nKafkaProducer producer = KafkaProducer.create(vertx, config, String.class, String.class);\n\n在这里，我们在创建 KafkaProducer 实例的时候传入了一个 Properties 实例，用于指定要连接的 Kafka 节点列表（只有一个）和消息确认模式。消息 key 和 value 的解析方式作为参数传入 KafkaProducer.create 方法中。\n消费感兴趣 Topic 的消息并加入消费组\n我们可以通过 KafkaConsumer 的的 subscribe 方法来订阅一个或多个 topic 进行消费，同时加入到某个消费组（consumer group）中（在创建消费者实例时通过配置指定）。当然你需要通过 handler 方法注册一个 Handler 来处理接收的消息：\nconsumer.handler(record -> {\n System.out.println(\"Processing key=\" + record.key() + \",value=\" + record.value() +\n \",partition=\" + record.partition() + \",offset=\" + record.offset());\n});\n\n// 订阅多个topic\nSet topics = new HashSet<>();\ntopics.add(\"topic1\");\ntopics.add(\"topic2\");\ntopics.add(\"topic3\");\nconsumer.subscribe(topics);\n\n// 订阅单个主题\nconsumer.subscribe(\"a-single-topic\");\n\n另外如果想知道消息是否成功被消费掉，可以在调用 subscribe 方法时绑定一个 Handler：\nconsumer.handler(record -> {\n System.out.println(\"Processing key=\" + record.key() + \",value=\" + record.value() +\n \",partition=\" + record.partition() + \",offset=\" + record.offset());\n});\n\n// subscribe to several topics\nSet topics = new HashSet<>();\ntopics.add(\"topic1\");\ntopics.add(\"topic2\");\ntopics.add(\"topic3\");\n\n//这里lambda表达式用于接收消息处理结果\nconsumer.subscribe(topics, ar -> {\n if (ar.succeeded()) {\n System.out.println(\"subscribed\");\n } else {\n System.out.println(\"Could not subscribe \" + ar.cause().getMessage());\n }\n});\n\n//这里lambda表达式用于接收消息处理结果\nconsumer.subscribe(\"a-single-topic\", ar -> {\n if (ar.succeeded()) {\n System.out.println(\"subscribed\");\n } else {\n System.out.println(\"Could not subscribe \" + ar.cause().getMessage());\n }\n});\n\n由于Kafka的消费者会组成一个消费组(consumer group)，同一个组只有一个消费者可以消费特定的 partition，同时此消费组也可以接纳其他的消费者，这样可以实现 partition 分配给组内其它消费者继续去消费。\n如果组内的一个消费者挂了，kafka 集群会自动把 partition 重新分配给组内其他消费者，或者新加入一个消费者去消费对应的 partition。您可以通过 partitionsRevokedHandler 和 partitionsAssignedHandler 方法在 KafkaConsumer 里注册一个 Handler 用于监听对应的 partition 是否被删除或者分配。\nconsumer.handler(record -> {\n System.out.println(\"Processing key=\" + record.key() + \",value=\" + record.value() +\n \",partition=\" + record.partition() + \",offset=\" + record.offset());\n});\n\n// 注册一个用于侦听新分配partition的Handler\nconsumer.partitionsAssignedHandler(topicPartitions -> {\n\n System.out.println(\"Partitions assigned\");\n for (TopicPartition topicPartition : topicPartitions) {\n System.out.println(topicPartition.getTopic() + \" \" + topicPartition.getPartition());\n }\n});\n\n// 注册一个用于侦听撤销partition的Handler\nconsumer.partitionsRevokedHandler(topicPartitions -> {\n\n System.out.println(\"Partitions revoked\");\n for (TopicPartition topicPartition : topicPartitions) {\n System.out.println(topicPartition.getTopic() + \" \" + topicPartition.getPartition());\n }\n});\n\n// subscribes to the topic\nconsumer.subscribe(\"test\", ar -> {\n\n if (ar.succeeded()) {\n System.out.println(\"Consumer subscribed\");\n }\n});\n\n加入某个 consumer group 的消费者，可以通过 unsubscribe 方法退出该消费组，从而不再接受到相关消息：\nconsumer.unsubscribe();\n\n当然你也可以在 unsubscribe 方法中传入一个 Handler 用于监听执行结果状态：\nconsumer.unsubscribe(ar -> {\n\n if (ar.succeeded()) {\n System.out.println(\"Consumer unsubscribed\");\n }\n});\n\n从 Topic 的特定分区里接收消息\n消费组内的消费者可以消费某个 topic 指定的 partition。如果某个消费者并不属于任何消费组，那么整个程序就不能依赖 Kafka 的 re-balancing 机制去消费消息。\n您可以通过 assign 方法请求分配指定的分区：\nconsumer.handler(record -> {\n System.out.println(\"key=\" + record.key() + \",value=\" + record.value() +\n \",partition=\" + record.partition() + \",offset=\" + record.offset());\n});\n\n//\nSet topicPartitions = new HashSet<>();\ntopicPartitions.add(new TopicPartition()\n .setTopic(\"test\")\n .setPartition(0));\n\n// 要求分配到特定的topic以及partitions\nconsumer.assign(topicPartitions, done -> {\n\n if (done.succeeded()) {\n System.out.println(\"Partition assigned\");\n\n // 侦听分配结果\n consumer.assignment(done1 -> {\n\n if (done1.succeeded()) {\n\n for (TopicPartition topicPartition : done1.result()) {\n System.out.println(topicPartition.getTopic() + \" \" + topicPartition.getPartition());\n }\n }\n });\n }\n});\n\n上面的 assignment 方法可以列出当前分配的 topic partition。\n获取 Topic 以及分区信息\n您可以通过 partitionsFor 方法获取指定 topic 的 partition 信息：\n\nconsumer.partitionsFor(\"test\", ar -> {\n if (ar.succeeded()) {\n for (PartitionInfo partitionInfo : ar.result()) {\n System.out.println(partitionInfo);\n }\n }\n});\n\n另外，listTopics 方法可以列出消费者下的所有 topic 以及对应的 partition 信息：\nconsumer.listTopics(ar -> {\n\n if (ar.succeeded()) {\n\n Map> map = ar.result();\n map.forEach((topic, partitions) -> {\n System.out.println(\"topic = \" + topic);\n System.out.println(\"partitions = \" + map.get(topic));\n });\n }\n});\n\n手动提交偏移量\n在 Apache Kafka 中，消费者负责处理最新读取消息的偏移量（offset）。Consumer 会在每次从某个 topic partition 中读取一批消息的时候自动执行提交偏移量的操作。需要在创建 KafkaConsumer 时将 enable.auto.commit 配置项设为 true 来开启自动提交。\n我们可以通过 commit 方法进行手动提交。手动提交偏移量通常用于确保消息分发的 at least once 语义，以确保消息没有被消费前不会执行提交。\nconsumer.commit(ar -> {\n\n if (ar.succeeded()) {\n System.out.println(\"Last read message offset committed\");\n }\n});\n\n分区偏移量定位\nApache Kafka 中的消息是按顺序持久化在磁盘上的，所以消费者可以在某个 partition 内部进行偏移量定位(seek)操作，并从任意指定的 topic 以及 partition 位置开始消费消息。我们可以通过 seek 方法来更改读取位置对应的偏移量：\nTopicPartition topicPartition = new TopicPartition()\n .setTopic(\"test\")\n .setPartition(0);\n\n// 指定offset位置10\nconsumer.seek(topicPartition, 10, done -> {\n\n if (done.succeeded()) {\n System.out.println(\"Seeking done\");\n }\n});\n\n当消费者需要从 Stream 的起始位置读取消息时，可以使用 seekToBeginning 方法将 offset 位置设置到 partition 的起始端：\nTopicPartition topicPartition = new TopicPartition()\n .setTopic(\"test\")\n .setPartition(0);\n\n// 将offset挪到分区起始端\nconsumer.seekToBeginning(Collections.singleton(topicPartition), done -> {\n\n if (done.succeeded()) {\n System.out.println(\"Seeking done\");\n }\n});\n\n最后我们也可以通过 seekToEnd 方法将 offset 位置设置到 partition 的末端：\n\nTopicPartition topicPartition = new TopicPartition()\n .setTopic(\"test\")\n .setPartition(0);\n\n// 将offset挪到分区末端\nconsumer.seekToEnd(Collections.singleton(topicPartition), done -> {\n\n if (done.succeeded()) {\n System.out.println(\"Seeking done\");\n }\n});\n\n偏移量查询\n你可以利用 Kafka 0.10.1.1 引入的新的API beginningOffsets 来获取给定分区的起始偏移量。这个跟上面的 seekToBeginning 方法有一个地方不同：beginningOffsets 方法不会更改 offset 的值，仅仅是读取（只读模式）。\nSet topicPartitions = new HashSet<>();\nTopicPartition topicPartition = new TopicPartition().setTopic(\"test\").setPartition(0);\ntopicPartitions.add(topicPartition);\n\nconsumer.beginningOffsets(topicPartitions, done -> {\n if(done.succeeded()) {\n Map results = done.result();\n results.forEach((topic, beginningOffset) ->\n System.out.println(\"Beginning offset for topic=\"+topic.getTopic()+\", partition=\"+\n topic.getPartition()+\", beginningOffset=\"+beginningOffset));\n }\n});\n\n// partition offset 查询辅助方法\nconsumer.beginningOffsets(topicPartition, done -> {\n if(done.succeeded()) {\n Long beginningOffset = done.result();\n System.out.println(\"Beginning offset for topic=\"+topicPartition.getTopic()+\", partition=\"+\n topicPartition.getPartition()+\", beginningOffset=\"+beginningOffset);\n }\n});\n\n与此对应的API还有 endOffsets 方法，用于获取给定分区末端的偏移量值。与 seekToEnd 方法相比，endOffsets 方法不会更改 offset 的值，仅仅是读取（只读模式）。\nSet topicPartitions = new HashSet<>();\nTopicPartition topicPartition = new TopicPartition().setTopic(\"test\").setPartition(0);\ntopicPartitions.add(topicPartition);\n\nconsumer.endOffsets(topicPartitions, done -> {\n if(done.succeeded()) {\n Map results = done.result();\n results.forEach((topic, endOffset) ->\n System.out.println(\"End offset for topic=\"+topic.getTopic()+\", partition=\"+\n topic.getPartition()+\", endOffset=\"+endOffset));\n }\n});\n\nconsumer.endOffsets(topicPartition, done -> {\n if(done.succeeded()) {\n Long endOffset = done.result();\n System.out.println(\"End offset for topic=\"+topicPartition.getTopic()+\", partition=\"+\n topicPartition.getPartition()+\", endOffset=\"+endOffset);\n }\n});\n\nKafka 0.10.1.1 还提供了一个根据时间戳(timestamp)来定位 offset 的API方法 offsetsForTimes，调用此API可以返回大于等于给定时间戳的 offset。因为 Kafka 的 offset 低位就是时间戳，所以 Kafka 很容易定位此类offset。\nMap topicPartitionsWithTimestamps = new HashMap<>();\nTopicPartition topicPartition = new TopicPartition().setTopic(\"test\").setPartition(0);\n\n// 我们只想要60秒之前的消息的offset\nlong timestamp = (System.currentTimeMillis() - 60000);\n\ntopicPartitionsWithTimestamps.put(topicPartition, timestamp);\nconsumer.offsetsForTimes(topicPartitionsWithTimestamps, done -> {\n if(done.succeeded()) {\n Map results = done.result();\n results.forEach((topic, offset) ->\n System.out.println(\"Offset for topic=\"+topic.getTopic()+\n \", partition=\"+topic.getPartition()+\"\\n\"+\n \", timestamp=\"+timestamp+\", offset=\"+offset.getOffset()+\n \", offsetTimestamp=\"+offset.getTimestamp()));\n\n }\n});\n\nconsumer.offsetsForTimes(topicPartition, timestamp, done -> {\n if(done.succeeded()) {\n OffsetAndTimestamp offsetAndTimestamp = done.result();\n System.out.println(\"Offset for topic=\"+topicPartition.getTopic()+\n \", partition=\"+topicPartition.getPartition()+\"\\n\"+\n \", timestamp=\"+timestamp+\", offset=\"+offsetAndTimestamp.getOffset()+\n \", offsetTimestamp=\"+offsetAndTimestamp.getTimestamp());\n\n }\n});\n\n流量控制\nConsumer 可以对消息流进行流量控制。如果我们读到一批消息，需要花点时间进行处理则可以暂时暂停（pause）消息的流入（这里实际上是把消息全部缓存到内存里了）；等我们处理了差不多了，可以再继续消费缓存起来的消息（resume）。\n我们可以利用 pause 方法和 resume 方法来进行流量控制：\nTopicPartition topicPartition = new TopicPartition()\n .setTopic(\"test\")\n .setPartition(0);\n\n//注册一个handler处理进来的消息\nconsumer.handler(record -> {\n System.out.println(\"key=\" + record.key() + \",value=\" + record.value() +\n \",partition=\" + record.partition() + \",offset=\" + record.offset());\n\n // 如果我们读到partition0的第5个offset\n if ((record.partition() == 0) && (record.offset() == 5)) {\n\n // 则暂停读取\n consumer.pause(topicPartition, ar -> {\n\n if (ar.succeeded()) {\n\n System.out.println(\"Paused\");\n\n // 5秒后再恢复,继续读取\n vertx.setTimer(5000, timeId -> {\n\n // resumi read operations\n consumer.resume(topicPartition);\n });\n }\n });\n }\n});\n\n关闭 Consumer\n关闭 Consumer 只需要调用 close 方法就可以了，它会自动的关闭与 Kafka 的连接，同时释放相关资源。\n由于 close 方法是异步的，你并不知道关闭操作什么时候完成或失败，这时你需要注册一个处理器(Handler)来监听关闭完成的消息。当关闭操作彻底完成以后，注册的 Handler 将会被调用。\nconsumer.close(res -> {\n if (res.succeeded()) {\n System.out.println(\"Consumer is now closed\");\n } else {\n System.out.println(\"close failed\");\n }\n});\n\n发送消息到某个 Topic\n您可以利用 write 方法来向某个 topic 发送消息(records)。\n最简单的发送消息的方式是仅仅指定目的 topic 以及相应的值而省略消息的 key 以及分区。在这种情况下，消息会以轮询(round robin)的方式发送到对应 topic 的所有分区上。\nfor (int i = 0; i record =\n KafkaProducerRecord.create(\"test\", \"message_\" + i);\n\n producer.write(record);\n}\n\n您可以通过绑定 Handler 来接受发送的结果。这个结果其实就是一些元数据(metadata)，包含消息的 topic、目的分区 (destination partition) 以及分配的偏移量 (assigned offset)。\nfor (int i = 0; i record =\n KafkaProducerRecord.create(\"test\", \"message_\" + i);\n\n producer.write(record, done -> {\n\n if (done.succeeded()) {\n\n RecordMetadata recordMetadata = done.result();\n System.out.println(\"Message \" + record.value() + \" written on topic=\" + recordMetadata.getTopic() +\n \", partition=\" + recordMetadata.getPartition() +\n \", offset=\" + recordMetadata.getOffset());\n }\n\n });\n}\n\n如果希望将消息发送到指定的分区，你可以指定分区的标识(identifier)或者设定消息的 key：\nfor (int i = 0; i record =\n KafkaProducerRecord.create(\"test\", null, \"message_\" + i, 0);\n\n producer.write(record);\n}\n\n因为 Producer 可以使用消息的 key 作为 hash 值来确定 partition，所以我们可以保证所有的消息被发送到同样的 partition 中，并且是有序的。\n\nfor (int i = 0; i record =\n KafkaProducerRecord.create(\"test\", String.valueOf(key), \"message_\" + i);\n\n producer.write(record);\n}\n\n\n注意：可共享的 Producer 通过 createShared 方法创建。它可以在多个 Verticle 实例之间共享，所以相关的配置必须在创建 Producer 的时候定义。\n\n共享 Producer\n有时候您希望在多个 Verticle 或者 Vert.x Context 下共用一个 Producer。您可以通过 KafkaProducer.createShared 方法来创建可以在 Verticle 之间安全共享的 KafkaProducer 实例：\nKafkaProducer producer1 = KafkaProducer.createShared(vertx, \"the-producer\", config);\n\n// 关闭\nproducer1.close();\n\n返回的 KafkaProducer 实例将复用相关的资源（如线程、连接等）。使用完 KafkaProducer 后，直接调用 close 方法关闭即可，相关的资源会自动释放。 \n关闭 Producer\n与关闭 Consumer 类似，关闭 Producer 只需要调用 close 方法就可以了，它会自动的关闭与 Kafka 的连接，同时释放所有相关资源。\n由于 close 方法是异步的，你并不知道关闭操作什么时候完成或失败，这时你需要注册一个处理器(Handler)来监听关闭完成的消息。当关闭操作彻底完成以后，注册的 Handler 将会被调用。\nproducer.close(res -> {\n if (res.succeeded()) {\n System.out.println(\"Producer is now closed\");\n } else {\n System.out.println(\"close failed\");\n }\n});\n\n获取 Topic Partition 的相关信息\n您可以通过 partitionsFor 方法获取指定 topic 的分区信息。\nproducer.partitionsFor(\"test\", ar -> {\n\n if (ar.succeeded()) {\n\n for (PartitionInfo partitionInfo : ar.result()) {\n System.out.println(partitionInfo);\n }\n }\n});\n\n错误处理\n您可以利用 KafkaProducer#exceptionHandler 方法和 KafkaConsumer#exceptionHandler 方法来处理 Kafka 客户端（生产者和消费者）和 Kafka 集群之间的错误（如超时）。比如：\nconsumer.exceptionHandler(e -> {\n System.out.println(\"Error = \" + e.getMessage());\n});\n\n随 Verticle 自动关闭\n如果您是在 Verticle 内部创建的 Consumer 和 Producer，那么当对应 Verticle 被卸载(undeploy)的时候，相关的 Consumer 和 Producer 会自动关闭。\n使用 Vert.x 自带的序列化与反序列化机制\nVert.x Kafka Client 自带现成的序列化与反序列化机制，可以处理 Buffer、JsonObject 和 JsonArray 等类型。\n在 KafkaConsumer 里您可以使用 Buffer：\nMap config = new HashMap<>();\nconfig.put(\"bootstrap.servers\", \"localhost:9092\");\nconfig.put(\"key.deserializer\", \"io.vertx.kafka.client.serialization.BufferDeserializer\");\nconfig.put(\"value.deserializer\", \"io.vertx.kafka.client.serialization.BufferDeserializer\");\nconfig.put(\"group.id\", \"my_group\");\nconfig.put(\"auto.offset.reset\", \"earliest\");\nconfig.put(\"enable.auto.commit\", \"false\");\n\n// 创建一个可以反序列化成jsonObject的consumer.\nconfig = new HashMap<>();\nconfig.put(\"bootstrap.servers\", \"localhost:9092\");\nconfig.put(\"key.deserializer\", \"io.vertx.kafka.client.serialization.JsonObjectDeserializer\");\nconfig.put(\"value.deserializer\", \"io.vertx.kafka.client.serialization.JsonObjectDeserializer\");\nconfig.put(\"group.id\", \"my_group\");\nconfig.put(\"auto.offset.reset\", \"earliest\");\nconfig.put(\"enable.auto.commit\", \"false\");\n\n// 创建一个可以反序列化成jsonArray的consumer.\nconfig = new HashMap<>();\nconfig.put(\"bootstrap.servers\", \"localhost:9092\");\nconfig.put(\"key.deserializer\", \"io.vertx.kafka.client.serialization.JsonArrayDeserializer\");\nconfig.put(\"value.deserializer\", \"io.vertx.kafka.client.serialization.JsonArrayDeserializer\");\nconfig.put(\"group.id\", \"my_group\");\nconfig.put(\"auto.offset.reset\", \"earliest\");\nconfig.put(\"enable.auto.commit\", \"false\");\n\n同样在 KafkaProducer 中也可以：\nMap config = new HashMap<>();\nconfig.put(\"bootstrap.servers\", \"localhost:9092\");\nconfig.put(\"key.serializer\", \"io.vertx.kafka.client.serialization.BufferSerializer\");\nconfig.put(\"value.serializer\", \"io.vertx.kafka.client.serialization.BufferSerializer\");\nconfig.put(\"acks\", \"1\");\n\n// 创建一个可以序列化成jsonObject的Producer.\nconfig = new HashMap<>();\nconfig.put(\"bootstrap.servers\", \"localhost:9092\");\nconfig.put(\"key.serializer\", \"io.vertx.kafka.client.serialization.JsonObjectSerializer\");\nconfig.put(\"value.serializer\", \"io.vertx.kafka.client.serialization.JsonObjectSerializer\");\nconfig.put(\"acks\", \"1\");\n\n// 创建一个可以序列化成jsonArray的Producer.\nconfig = new HashMap<>();\nconfig.put(\"bootstrap.servers\", \"localhost:9092\");\nconfig.put(\"key.serializer\", \"io.vertx.kafka.client.serialization.JsonArraySerializer\");\nconfig.put(\"value.serializer\", \"io.vertx.kafka.client.serialization.JsonArraySerializer\");\nconfig.put(\"acks\", \"1\");\n\n您也可以在 create 方法里指明序列化与反序列化相关的类。 \n比如创建 Consumer 时：\nMap config = new HashMap<>();\nconfig.put(\"bootstrap.servers\", \"localhost:9092\");\nconfig.put(\"group.id\", \"my_group\");\nconfig.put(\"auto.offset.reset\", \"earliest\");\nconfig.put(\"enable.auto.commit\", \"false\");\n\n// 创建一个可以反序列化成Buffer的Consumer\nKafkaConsumer bufferConsumer = KafkaConsumer.create(vertx, config, Buffer.class, Buffer.class);\n\n// 创建一个可以反序列化成JsonObject的Consumer\nKafkaConsumer jsonObjectConsumer = KafkaConsumer.create(vertx, config, JsonObject.class, JsonObject.class);\n\n// 创建一个可以反序列化成JsonArray的Consumer\nKafkaConsumer jsonArrayConsumer = KafkaConsumer.create(vertx, config, JsonArray.class, JsonArray.class);\n\n创建 Producer 时：\nMap config = new HashMap<>();\nconfig.put(\"bootstrap.servers\", \"localhost:9092\");\nconfig.put(\"acks\", \"1\");\n\n// 创建一个可以序列化成Buffer的Producer.\nKafkaProducer bufferProducer = KafkaProducer.create(vertx, config, Buffer.class, Buffer.class);\n\n// 创建一个可以序列化成jsonObject的Producer.\nKafkaProducer jsonObjectProducer = KafkaProducer.create(vertx, config, JsonObject.class, JsonObject.class);\n\n// 创建一个可以序列化成jsonArray的Producer.\nKafkaProducer jsonArrayProducer = KafkaProducer.create(vertx, config, JsonArray.class, JsonArray.class);\n\nRxJava API\nVert.x Kafka Client 组件也提供Rx风格的API。\n\n译者注：此处也可以参考 Kafka Stream 相关的 API。\n\nObservable> observable = consumer.toObservable();\n\nobservable\n .map(record -> record.value())\n .buffer(256)\n .map(\n list -> list.stream().mapToDouble(n -> n).average()\n).subscribe(val -> {\n\n //获取到一个平均值\n\n});\n\n流实现与 Kafka 原生对象\n如果您希望直接操作原生的 Kafka record，您可以使用原生的 Kafka 流式对象，它可以处理原生 Kafka 对象。\nKafkaReadStream用于读取 topic partition。它是 ConsumerRecord 对象的可读流对象，读到的是 ConsumerRecord 对象。\nKafkaWriteStream用于向某些 topic 中写入数据。它是 ProducerRecord 对象的可写流对象。\nAPI通过这些接口将这些方法展现给用户，其他语言版本也应该类似。\n\n\n原文档最后更新于 2017-03-15 15:54:14 CET\n\n"},"eventbusbridge/CamelBridge.html":{"url":"eventbusbridge/CamelBridge.html","title":"Camel Bridge","keywords":"","body":"Vert.x Camel Bridge\n"},"eventbusbridge/TCPEventbusBridge.html":{"url":"eventbusbridge/TCPEventbusBridge.html","title":"TCP Eventbus Bridge","keywords":"","body":"Vert.x TCP Eventbus Bridge\n"},"auth/Auth.html":{"url":"auth/Auth.html","title":"Authentication and Authorisation","keywords":"","body":"Vert.x Authentication and Authorisation\nVert.x为您的应用程序提供了简单的认证API。我们还提供了一些开箱即用的实现\nhttp://vertx.io/docs/Auth common：http://vertx.io/docs/vertx-auth-common/java/JDBC auth：http://vertx.io/docs/vertx-auth-jdbc/java/JWT auth：http://vertx.io/docs/vertx-auth-jwt/java/Shiro auth：http://vertx.io/docs/vertx-auth-shiro/java/MongoDB auth：http://vertx.io/docs/vertx-auth-mongo/java/OAuth 2：http://vertx.io/docs/vertx-auth-oauth2/java/ \n译者：虞浪，易世伟校对：钟子期，易世伟\n"},"auth/AuthCommon.html":{"url":"auth/AuthCommon.html","title":"Auth Common","keywords":"","body":"Vert.x Auth Common\n\n引用：http://vertx.io/docs/vertx-auth-common/java/\n\n基本术语\n\nAuthentication：认证\nAuthorisation：授权\nAuthority：权限\nPermission：许可\nRole：角色\nUser：用户\nToken：令牌\nPrincipal：凭证\nHandler：处理器\n\n\n\nVert.X Auth项目提供了处理认证和授权的功能，它可以被vertx-web项目使用，若要在自己的项目中运用它，则需要在构建描述信息的dependencies节点中添加如下信息：\n\nMaven（在pom.xml文件中）\n \n io.vertx\n vertx-auth-common\n 3.2.1\n \n\nGradle（在build.gradle文件中）\n compile io.vertx:vertx-auth-common:3.2.1\n\n\n基本概念\n认证Authentication：用于验证用户的标识和身份。\n授权Authorisation：用于验证用户是否拥有访问系统的许可。\n权限Authority：它取决于一些特定的系统实现但对特定的模型不做任何要求；比如：许可/角色permissions/roles模型，可以使事情变得灵活。在一些实现中一个权限可以用来表述一个许可，如：有权限访问所有打印机、或特定打印机。在另外一些实现中则必须支持角色信息，通常使用一些角色信息对权限进行前缀role:命名/标识，如：role:admin。还有一些实现也许会包含更加复杂以及不同的模型来表述权限信息。\n如果要了解期望的特定认证提供者Auth Provider，则可以按照文档中的内容实施。\n认证\n如果要对用户进行认证可使用Provider中的authenticate方法。\n这个方法的第一个参数是一个JSON对象，它包含了认证用的信息，实际上这些信息取决于特定的实现；对于简单基于用户名/密码username/password的认证包含了如下信息：\n{\n “username\": \"tim\",\n \"password\": \"mypassword\"\n}\n对于一些基于JWT Token或OAuth Bearer Token的实现还会在认证信息中包含令牌Token信息。Vert.X中的认证是异步执行，在调用过程中，认证结果被传给结果处理器中的用户User对象里，异步调用结果包含了一个用户User的实例，这个实例表述了已经认证过的用户信息，并且包含了这些用户允许执行的合法操作。\n这里是一个简单的基于用户名/密码username/password认证用户的代码实现：\nJsonObject authInfo = new JsonObject().put(\"username\", \"tim\").put(\"password\", \"mypassword\");\n\n authProvider.authenticate(authInfo, res -> {\n if (res.succeeded()) {\n\n User user = res.result();\n\n System.out.println(\"User \" + user.principal() + \" is now authenticated\");\n } else {\n res.cause().printStackTrace();\n }\n});\n授权\n一旦你拥有了一个用户User的实例过后，你就可以调用它的方法对这个用户进行授权。\n检查一个用户是否拥有特定权限需要使用它的isAuhorised方法。\n上边所有操作的结果都是通过处理器Handler异步调用提供的。\n这里是一个对用户授权的例子：\nuser.isAuthorised(\"printers:printer1234\", res -> {\n if (res.succeeded()) {\n\n boolean hasAuthority = res.result();\n\n if (hasAuthority) {\n System.out.println(\"User has the authority\");\n } else {\n System.out.println(\"User does not have the authority\");\n }\n } else {\n res.cause().printStackTrace();\n }\n});\n另外一个例子对基于角色模型的用户进行授权就是使用role:前缀，请注意，就像上边讨论的一样，权限字符串如何被解释完全取决于底层实现，这里Vert.X不对解释细节提供假设。\n权限缓存\n用户对象可以缓存任何权限，之后的调用会检查是否拥有同样的权限执行其操作，这个结果实际上调用了底层提供者Provider的方法。\n为了清空内部缓存，则你可以使用clearCache方法。\n用户凭证\n对于已经认证过的用户，你可以调用principal方法获取用户的凭证信息，获取凭证信息的内容同样取决于底层实现。\n创建自己的认证实现\n如果你希望创建自己的认证提供者Auth Provider则需要创建一个类实现AuthProvider接口。\nVert.X提供了用户对象的抽象实现AbstractUser，你可以创建这个类的子类对自己的用户User对象提供自定义实现。这个抽象实现中包含了缓存逻辑，所以你在实现的时候不需要考虑自己处理缓存问题。\n如果你希望在集群环境中使用你的User对象，则需要保证这个用户对象实现了ClusterSerializable接口。\n"},"auth/JDBCAuth.html":{"url":"auth/JDBCAuth.html","title":"JDBC Auth","keywords":"","body":"Vert.x JDBC Auth\n\n引用：http://vertx.io/docs/vertx-auth-jdbc/java/\n\n基本术语\n\nAuthentication：认证\nAuthorisation：授权\nAuthority：权限\nPermission：许可\nRole：角色\nUser：用户\nToken：令牌\nPrincipal：凭证\nHandler：处理器\n\nVert.X中提供了一个使用JDBCClient的AuthProvider实现，它针对任何兼容JDBC的关系数据库执行认证和授权。若要在自己的项目中使用它，则需要在构建描述信息的dependencies节点中添加如下信息：\n\nMaven（在pom.xml文件中）\n \n io.vertx\n vertx-auth-jdbc\n 3.2.1\n \n\nGradle（在build.gradle文件中）\n compile io.vertx:vertx-auth-jdbc:3.2.1\n\n\n如果要创建一个客户端实例，你首先需要一个JDBCClient的实例，要知道如何创建这个实例可按照文档中的内容实施。\n一旦你创建了一个JDBCClient实例后，就可以按下边代码创建JDBCAuth实例：\nJDBCClient jdbcClient = JDBCClient.createShared(vertx, jdbcClientConfig);\n\nJDBCAuth authProvider = JDBCAuth.create(jdbcClient);\n创建好上边的实例过后你就可以如使用任何AuthProvider执行认证和授权功能了。\nVert.X的默认标准配置（Out Of the Box）中包含了某些针对认证和授权的信息查询，如果你想要使用不同的数据库模式（Schema），这些查询内容可以通过下边几个方法进行更改：\n\nsetAuthenticationQuery\nsetPermissionQuery\nsetRolesQuery\n\nVert.X默认实现中的密码在数据库中使用了SHA-512算法加密后进行存储，之后会连接对应的salt值，这个salt值和密码存储在同一个表里。\n如果你想要重写这些行为，则可以重写setHashStrategy方法去修改Hash策略的设置。\n！WARNING\n强烈建议在存储密码时使用哈希算法加密过后保存在数据库中，这个哈希值是在创建这一行记录时基于salt值计算的，应用中应该使用强壮的密码算法，在存储密码时绝对不要使用明文。\n认证\n如果要使用默认的认证实现，认证信息中用了username和password字段进行表述：\nJsonObject authInfo = new JsonObject().put(\"username\", \"tim\").put(\"password\", \"sausages\");\n\nauthProvider.authenticate(authInfo, res -> {\n if (res.succeeded()) {\n User user = res.result();\n } else {\n // Failed!\n }\n});\n授权 - Permission/Role模型\n尽管Vert.X Auth自身并不要求使用特定的许可模型（它本身只是使用了不透明的字符串），但默认的实现使用了比较熟悉的：用户/角色/许可模型，这样在应用里你可以使用一个或者多个角色，而一个角色也可以拥有一个或者多个许可。\n如果要验证一个用户是否拥有特定的许可，则需要将许可信息传递到isAuthorised中：\nuser.isAuthorised(\"commit_code\", res -> {\n if (res.succeeded()) {\n boolean hasPermission = res.result();\n } else {\n // Failed to\n }\n});\n如果要验证一个用户是否属于特定角色，则可以使用前缀法给角色带上前缀表示：\nuser.isAuthorised(\"role:manager\", res -> {\n if (res.succeeded()) {\n boolean hasRole = res.result();\n } else {\n // Failed to\n }\n});\nVert.X中的默认角色前缀使用了role:，这个值可通过setRolePrefix进行更改。\n"},"auth/JWTAuth.html":{"url":"auth/JWTAuth.html","title":"JWT Auth","keywords":"","body":"JWT auth\n\n引用：http://vertx.io/docs/vertx-auth-jwt/java/\n\n基本术语\n\nAuthentication ：认证\nAuthorisation：授权\nAuthenticity：真实性\nPermission： 许可\nToken： 令牌\nProvider：提供者\n\n使用JSON web tokens实现Auth。\nThe JWT auth Provider\n这个组件包含了一个开箱即用的JWT实现。\n要使用这个项目，将下面的依赖添加到构建描述符里的dependencies部分。\n\nMaven（在你的pom.xml文件里）\n \n io.vertx\n vertx-auth-jwt\n 3.2.1\n \n\nGradle(在你的build.gradle文件里)\n compile 'io.vertx:vertx-auth-jwt:3.2.1'\n\n\nJSON Web 令牌是一种简单的方法来发送明文信息（通常是URL），其内容可以被验证为是可信的。像下面的这些场景JWT是非常适用的：\n\n在一个单一的报名场景中，你想要有一个隔离的认证服务用可被信任的方式发送用户信息\n无状态的Server API，非常适用于简单的页面应用\n等等\n\n在决定使用JWT之前，需要重点注意的是JWT并不加密payload，它仅对payload签名。你不应该使用JWT发送任何私密信息，相反你应该发送是不是私密的但要被验证的信息。举个例子，使用JWT发送一个签名过的用户id来表明这个用户已经登录了的做法非常对的。相反发送一个用户的密码的做法是非常非常错误的。\nJWT主要的优点有：\n\n它可以让你验证令牌的真实性\n它有一个JSON结构，可以包含任何你想要的变量和大量的数据\n它完全是无状态的\n\n你可以使用JWTAuth来创建一个提供者的实例，并指定一个JSON对象的配置。这是创建一个JWT auth提供者的示例代码：\nJsonObject config = new JsonObject().put(\"keyStore\", new JsonObject()\n .put(\"path\", keystore.jceks)\n .put(\"type\", \"jceks\")\n .put(\"password\", \"secret\"));\n\nAuthProvider provider = JWTAuth.create(vertx, config);\nJWT用法的典型流程是，在您的应用程序有一个终点颁发令牌，这个终点应在SSL模式下运行，终点这通过用户名和密码验证完请求用户之后，表示你将这样做生成令牌：\nJsonObjetc config = new JsonObject().put(\"keyStore\", new JsonObject()\n .put(\"path\", \"keystore.jceks\")\n .put(\"type\", \"jceks\")\n .put(\"password\", \"secret\"));\n\nJWTAuth provider = JWTAuth.create(vertx, config);\n\n// 在验证的终点上，一旦你通过它的用户名/密码验证了用户的id\nif (\"paulo\".equal(username) && \"super_secret\".equals(password)) {\n String token = provider.generateToken(new JsonObject().put(\"sub\", \"paulo\"), new JWTOptions());\n // 这时任何请求受保护的资源你应该传入这个字符串到http头授权部分，像这样：\n // 授权：Bearer \n}\nTODO展示了使用JWT的验证和授权的例子并解释了如何通过传入到授权的许可字符映射到JW令牌中的声明。\nTHE JWT keystore file\nauth提供者需要在类路径或文件系统上加载一个keystore文件，keystore文件要么有一个mac要么有一个Signature用于签名和验证生成的令牌，。\n默认的情况下，实践将会查找这些别名，然而并不是所有的算法都需要存在。作为一个好的实践HS256应该存在：\n`HS256`:: HMAC using SHA-256 hash algorithm\n`HS384`:: HMAC using SHA-384 hash algorithm\n`HS512`:: HMAC using SHA-512 hash algorithm\n`RS256`:: RSASSA using SHA-256 hash algorithm\n`RS384`:: RSASSA using SHA-384 hash algorithm\n`RS512`:: RSASSA using SHA-512 hash algorithm\n`ES256`:: ECDSA using P-256 curve and SHA-256 hash algorithm\n`ES384`:: ECDSA using P-384 curve and SHA-384 hash algorithm\n`ES512`:: ECDSA using P-521 curve and SHA-512 hash algorithm\n当keystore没有被提供，执行将会回滚到一个不安全的模式同时签名并不会被验证，如果payload被外部的方法签名或加密后的情况下这是非常有用的。\n生成一个新的Keystore文件\n生成keystore文件唯一需要的工具是keytool，运行的时候，你可以指定你需要使用的算法：\nkeytool -genseckey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg HMacSHA256 -keysize 2048 -alias HS256 -keypass secret\nkeytool -genseckey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg HMacSHA384 -keysize 2048 -alias HS384 -keypass secret\nkeytool -genseckey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg HMacSHA512 -keysize 2048 -alias HS512 -keypass secret\nkeytool -genkey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg RSA -keysize 2048 -alias RS256 -keypass secret -sigalg SHA256withRSA -dname \"CN=,OU=,O=,L=,ST=,C=\" -validity 360\nkeytool -genkey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg RSA -keysize 2048 -alias RS384 -keypass secret -sigalg SHA384withRSA -dname \"CN=,OU=,O=,L=,ST=,C=\" -validity 360\nkeytool -genkey -keystore keystore.jceks -storetype jceks -storepass secret -keyalg RSA -keysize 2048 -alias RS512 -keypass secret -sigalg SHA512withRSA -dname \"CN=,OU=,O=,L=,ST=,C=\" -validity 360\nkeytool -genkeypair -keystore keystore.jceks -storetype jceks -storepass secret -keyalg EC -keysize 256 -alias ES256 -keypass secret -sigalg SHA256withECDSA -dname \"CN=,OU=,O=,L=,ST=,C=\" -validity 360\nkeytool -genkeypair -keystore keystore.jceks -storetype jceks -storepass secret -keyalg EC -keysize 256 -alias ES384 -keypass secret -sigalg SHA384withECDSA -dname \"CN=,OU=,O=,L=,ST=,C=\" -validity 360\nkeytool -genkeypair -keystore keystore.jceks -storetype jceks -storepass secret -keyalg EC -keysize 256 -alias ES512 -keypass secret -sigalg SHA512withECDSA -dname \"CN=,OU=,O=,L=,ST=,C=\" -validity 360\nJulien VietTim FoxPaulo Lopes\ntranslated by weiyiysw\n"},"auth/ShiroAuth.html":{"url":"auth/ShiroAuth.html","title":"Shiro Auth","keywords":"","body":"Vert.x Shiro Auth\nApache Shiro Auth提供者实现\n基本术语\n\nprovider：提供者\nauthentication：验证\npermissions：权限\n\n这是一个使用Apache Shiro的auth提供者的实现。\n要使用这个项目，将下面的依赖添加到构建描述符里的dependencies部分。\n\nMaven（在pom.xml文件里）\n \n io.vertx\n vertx-auth-shiro\n 3.2.1\n \n\nGradle(在build.gradle文件里)\n compile 'io.vertx:vertx-auth-shiro:3.2.1'\n\n\n我们使用Shiro提供基于身份认证属性和LDAP开箱即用的支持，你也可以使用插件，在任何其他的期望用户名和密码作为凭据的Shiro Realm里。\n使用ShiroAuth创建提供者的实例。使用ShiroAuthRealmType指定Shiro auth提供者的类型，并且也可以指定一个JSON对象的配置。\n这是通过指定类型创建Shiro auth提供者的示例：\nJsonObject config = new JsonObject().put(\"properties_path\", \"classpath:test-auth.properties\");\nAuthProvider provider = ShiroAuth.create(vertx, ShiroAuthRealmType.PROPERTIES, config);\n验证\n当使用这种实现作为认证时，它需要在认证信息里获取username和password：\nJsonObject authInfo = new JsonObject().put(\"username\", \"tim\").put(\"password\", \"sausages\");\nauthProvider.authenticate(authInfo, res -> {\n if (res.succeeded()) {\n User user = res.result();\n } else {\n // Failed!\n }\n});\n授权-权限-角色模型\n尽管Vert.x auth本身并没有授权任何特定的许可（它们仅是不透明的字符串）模型，这个的实现和 用户/角色/权限 模型类似，一个用户可以有0到多个角色，一个角色可以有0到多个权限。\n要验证一个用户是否有一个特定的权限，只需要简单的将权限传入到isAuthorised像接下来这样做：\nuser.isAuthorised(\"newsletter:edit:13\", res -> {\n if (res.succeeded()) {\n boolean hasPermission = res.result();\n } else {\n // Failed to\n }\n});\n要验证一个用户是否有一个特定的角色，你需要在参数前面加上角色前缀。\nuser.isAuthorised(\"role:manager\", res -> {\n if (res.succeeded()) {\n boolean hasRole = res.result();\n } else {\n // Failed to\n }\n});\n默认的角色前缀是role:。你可以设置setRolePrefix改变默认的。\nThe Shiro properties auth provider\n这个auth提供者的实现是使用Apache Shiro从一个配置文件里获取 用户/角色/权限 信息。\n注意，角色在API里并不是直接可用的，因为这个事实，vertx-auth尽可能的尝试轻便。然而，可以通过使用前缀role:或者通过setRolePrefix指定你想要的前缀在一个角色上执行断言。\n默认的情况下，这个实现将会在类路径里查找一个名为vertx-users.properties的文件。如果你想要改变这个，你可以使用properties_path配置元素来定义属性文件的路径，默认的值是classpath:vertx-users.properties。\n如果这个值得前缀是classpath:，将会在类路径查找那个名字的属性文件。如果这个值的前缀是file:，将在文件系统上指定一个具体的文件。如果这个值得前缀是url:，将会指定一个具体的URL来加载这个属性文件。\n这个属性文件应该遵从下面的结构：\n每一行应该要么包含一个用户的用户名、密码和角色，要么包含角色的权限。\n一个用户的行应该是这样的结构：\nuser.{username}={password},{roleName1},{roleName2},...,{roleNameN}\n一个角色行应该是这样的结构：\nrole.{roleName}={permissionName1},{permissionName2},...,{permissionNameN}\n这是示例：\nuser.tim = mypassword,administrator,developer\nuser.bob = hispassword,developer\nuser.joe = anotherpassword,manager\nrole.administrator = *\nrole.manager = play_golf,say_buzzwords\nrole.developer = do_actual_work\n当描述一个角色使用通配符*时，说明这个角色拥有所有的权限。\nThe Shiro LDAP auth Provider\nLDAP auth realm从一个LDAP服务器上获取 用户/角色/权限 信息。\n接下来的这些配置属性是用来配置一个LDAP realm：\n\nldap-user-dn-template：这是用来决定实际的查找使用当通过一个特定的id来查找一个用户的时候。一个例子是uid={0},ou=users,dc=foo,dc=com-这个元素{0}是创建实际的查找时替换成用户的id。这个设置是强制的。\nldap_url：这个url是设置LDAP服务器。这个url必须以ldap://开头，端口也必须要指定。这是一个示例ldap://myldapserver.mycompany.com:10389\nldap-authentication-mechanism：TODO\nldap-context-factory-class-name：TODO\nldap-pooling-enabled：TODO\nldap-referral：TODO\nldap-system-username：TODO\nldap-system-password：TODO\n\n使用另一个Shiro Realm\n使用一个预先创建的Apache Shiro Realm对象创建一个auth提供者的示例是可以的。\n像下面这样做的：\nAuthProvider provider = ShiroAuth.create(vertx, realm);\n这个实现当前假定了在基本的验证中使用了用户名和密码。\nJulien VietTim Fox\ntranslated by weiyiysw\n"},"auth/MongoDBAuth.html":{"url":"auth/MongoDBAuth.html","title":"MongoDB Auth","keywords":"","body":"Vert.x MongoDB Auth\n\n引用：http://vertx.io/docs/vertx-auth-mongo/java/\n\n基本术语\n\nAuthentication：认证\nAuthorisation：授权\nAuthority：权限\nPermission：许可\nRole：角色\nUser：用户\nToken：令牌\nPrincipal：凭证\nHandler：处理器\nCollection：集合，MongoDB专用（概念稍同Database的Table）\nDocument：文档，MongoDB专用（概念稍同Database中Row）\n\nVert.X中提供了一个AuthProvider的实现，它可以让你使用MongoClient针对MongoDb数据库执行认证和授权。若要在自己的项目中使用它，则需要在构建描述信息的dependencies节点中添加如下信息：\n\nMaven（在pom.xml文件中）\n \n io.vertx\n vertx-auth-mongo\n 3.2.1\n \n\nGradle（在build.gradle文件中）\n compile io.vertx:vertx-auth-mongo:3.2.1\n\n\n如果要创建一个客户端实例，你首先需要一个MongoClient的实例，要知道如何创建这个实例可按照文档中的内容实施。\n一旦你创建了一个MongoClient实例后，就可以按照下边的代码创建MongoAuth实例：\nMongoClient client = MongoClient.createShared(vertx, mongoClientConfig);\nJsonObject authProperties = new JsonObject();\nMongoAuth authProvider = MongoAuth.create(client, authProperties);\n创建好上边的实例过后，你就可以使用任何AuthProvider针对MongoDB执行认证和授权功能了。\nVert.X的默认标准配置（Out Of the Box）中包含了\"user\"集合（Collection），用户名字段使用\"username\"进行存储和读取。\n为了避免在\"user\"集合中出现重复的用户名，应该在\"user\"集合中给\"username\"添加唯一索引（Unique Index），你可以在MongoDB服务器中运行下边的片段来完成此操作：\ndb.user.createIndex( { username: 1 }, { unique: true } )\nMongoDB的特性是先查询username字段中的值是否已经存在，然后会插入一个Document，并不能作为一个原子性操作，基于这个原因你需要添加上边的唯一索引，使用了这个索引过后你的代码会尝试先插入一行数据，如果出现了重复记录则会失败。\n根据你自己的需要，你同样可以使用下边的方法改变MongoDB中使用的默认集合（Collection）和列（Column）名称等信息：\n\nsetCollectionName\nsetUsernameField\nsetPasswordField\nsetPermissionField\nsetRoleField\n\nVert.X默认实现中的密码在数据库中使用了SHA-512算法加密后进行存储，之后会连接对应的salt值，这个salt值和密码存储在同一个表里。你可以调用setSaltField方法来改变存储salt值的字段名称，它的默认值是\"salt\"，你同样可以使用setSaltStyle来改变一些行为。通过调用getHashStrategy方法还可以读取Hash策略设置。\nMongoDB中可以设置下边几种SALT的值（参考下边WARNING）：\n\nNO_SALT：密码就不会执行加密以明文的方式存储。\nCOLUMN：Vert.X会为每个用户创建一个\"salt“值，并且存储在用户表定义的列中；\nEXTERNAL：Vert.X仅仅将密码最终加密结果存储在数据库中，\"salt“值可以在外部使用，并且可以调用setExternalSalt方法进行设置。\n\n如果你想要重写上述行为，则你可以调用setHashStrategy方法设置新的Hash策略，并且提供变更过的Hash策略及配置信息。\n！WARNING\n强烈建议在设置“salt\"值时候使用EXTERNAL选项。NO_SALT选项仅仅推荐在开发阶段中使用，不仅仅如此，COLUMN方式也不推荐，因为它会导致salt和密码都存储在了同一个地方！\n认证\n如果认证使用了默认的MongoDB实现，认证信息中用了username和password字段：\nJsonObject authInfo = new JsonObject()\n .put(\"username\", \"tim\")\n .put(\"password\", \"sausages\");\nauthProvider.authenticate(authInfo, res -> {\n if (res.succeeded()) {\n User user = res.result();\n } else {\n // Failed!\n }\n});\n如果想要替换上边的username和password两个默认字段名，你可以使用下边两个方法：\n\nsetUsernameCredentialField\nsetPasswordCredentialField\n\n授权 - Permission/Role模型\n尽管Vert.X自身并不要求使用特定的许可模型（它本身只是使用了不透明的字符串），但MongoDB认证中的实现使用了比较熟悉的：用户/角色/许可模型，这样在应用里你可以使用一个或者多个角色，而一个角色也可以拥有一个或者多个许可。\n如果要验证一个用户是否拥有特定的许可，则要将许可信息传递到isAuthorised中：\nuser.isAuthorised(\"commit_code\", res -> {\n if (res.succeeded()) {\n boolean hasPermission = res.result();\n } else {\n // Failed to\n }\n});\n如果要验证一个用户是否属于特定角色，则可以使用MongoDB认证前缀（MongoAuth.ROLE_PREFIX）法给角色带上前缀表示：\nuser.isAuthorised(MongoAuth.ROLE_PREFIX + \"manager\", res -> {\n if (res.succeeded()) {\n boolean hasRole = res.result();\n } else {\n // Failed to\n }\n});\n"},"auth/Oauth2.html":{"url":"auth/Oauth2.html","title":"OAuth 2","keywords":"","body":"Vert.x OAuth 2\n\n引用：http://vertx.io/docs/vertx-auth-oauth2/java/\n\n基本术语\n\nAuthentication：认证\nAuthorisation：授权\nAuthority：权限\nPermission：许可\nRole：角色\nUser：用户\nToken：令牌\nPrincipal：凭证\nHandler：处理器\nCredential：证书\nToken：令牌\n\nVert.X的这个组件包含了标准的OAuth2的实现。若要在自己的项目中使用它，则需要在构建描述信息的dependencies节点中添加如下信息：\n\nMaven（在pom.xml文件中）\n \n io.vertx\n vertx-auth-oauth2\n 3.2.1\n \n\nGradle（在build.gradle文件中）\n compile io.vertx:vertx-auth-oauth2:3.2.1\n\n\n如果用户以第三方应用的方式访问想要的资源，OAuth2可以对这些用户进行授权，任何时候可以根据用户想要都有可能启用或禁用它的访问权限。\nVert.X中的OAuth2支持下边三种流程：\n\nAuthorization Code：授权码流程（对服务器和App可持久化存储信息）\nPassword Credentials：密码证书流程（之前的流程无法使用或开发阶段使用）\nClient Credentials：客户端证书流程（客户端可仅仅可凭借客户端整数申请访问令牌【Access Token】）\n\n授权码——Authorization Code Flow\n授权码授权类型可以用来获取访问令牌（Access Token）和刷新令牌（Refresh Token），对安全性要求高的客户端（Confidential Client）是很不错的（Optimized）一种方式。作为一个基于重定向的流程，客户端必须能和资源拥有者的用户代理交互（通常是浏览器），同时要能接受从授权服务器（Authorization Server）通过重定向发送过来的请求。\n更多：OAuth2 Section 4.1\n密码证书——Password Credentials Flow\n资源拥有者密码证书授权类型比较适合于这样一种情况：当资源拥有者和客户端之间有可信任的关系时使用，如设备操作系统、或高特权应用。授权服务器应该在很特殊的情况时启用这种授权类型，并且仅仅当其他应用都不可见时允许使用这种类型。\n这种类型对于客户端要获取资源拥有者证书（用户名和密码，通常使用交互式表单）是合适的。它用于从已经存在的直接使用认证模式的如Basic或Digest的客户端向OAuth2认证方式迁移的时候，它会将证书直接转换成OAuth2中的访问令牌。\n更多：OAuth2 Section 4.3\n客户端证书——Client Credentials Flow\n当客户端想要申请访问控制之下受保护的资源时，或者其他资源拥有者先前被授权服务器托管时（这种方式超出了本文范畴），客户端仅仅可以使用客户端证书（或者其他表示认证含义的信息）申请访问令牌。\n客户端证书类型必须用于且仅用于机密客户端。\n更多：OAuth2 Section 4.4\n初探\n下边是基于GitHub中使用Vert.X的OAuth2 Provider的认证示例实现代码：\nOAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.AUTH_CODE, new JsonObject()\n .put(\"clientID\", \"YOUR_CLIENT_ID\")\n .put(\"clientSecret\", \"YOUR_CLIENT_SECRET\")\n .put(\"site\", \"https://github.com/login\")\n .put(\"tokenPath\", \"/oauth/access_token\")\n .put(\"authorizationPath\", \"/oauth/authorize\")\n);\n\n// when there is a need to access a protected resource or call a protected method,\n// call the authZ url for a challenge\n\nString authorization_uri = oauth2.authorizeURL(new JsonObject()\n .put(\"redirect_uri\", \"http://localhost:8080/callback\")\n .put(\"scope\", \"notifications\")\n .put(\"state\", \"3(#0/!~\"));\n\n// when working with web application use the above string as a redirect url\n\n// in this case GitHub will call you back in the callback uri one should now complete the handshake as:\n\n\nString code = \"xxxxxxxxxxxxxxxxxxxxxxxx\"; // the code is provided as a url parameter by github callback call\n\noauth2.getToken(new JsonObject().put(\"code\", code).put(\"redirect_uri\", \"http://localhost:8080/callback\"), res -> {\n if (res.failed()) {\n // error, the code provided is not valid\n } else {\n // save the token and continue...\n }\n});\n授权码流程\n授权码流程主要包含两部分内容：\n\n第一步，你的应用客户端向用户申请允许访问它们的数据，如果用户审批后，OAuth2服务器发送给客户端一个授权码；\n第二步，客户端将这个授权码和客户端密钥放到POST请求中发送给授权服务器（Authority Server）得到访问令牌；\n\n示例代码：\nJsonObject credentials = new JsonObject()\n .put(\"clientID\", \"\")\n .put(\"clientSecret\", \"\")\n .put(\"site\", \"https://api.oauth.com\");\n\n// Initialize the OAuth2 Library\nOAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.AUTH_CODE, credentials);\n\n// Authorization oauth2 URI\nString authorization_uri = oauth2.authorizeURL(new JsonObject()\n .put(\"redirect_uri\", \"http://localhost:8080/callback\")\n .put(\"scope\", \"\")\n .put(\"state\", \"\"));\n\n// Redirect example using Vert.x\nresponse.putHeader(\"Location\", authorization_uri)\n .setStatusCode(302)\n .end();\n\nJsonObject tokenConfig = new JsonObject()\n .put(\"code\", \"\")\n .put(\"redirect_uri\", \"http://localhost:3000/callback\");\n\n// Callbacks\n// Save the access token\noauth2.getToken(tokenConfig, res -> {\n if (res.failed()) {\n System.err.println(\"Access Token Error: \" + res.cause().getMessage());\n } else {\n // Get the access token object (the authorization code is given from the previous step).\n AccessToken token = res.result();\n }\n});\n密码证书流程\n资源拥有者密码证书授权类型比较适合于这样一种情况：当资源拥有者和客户端之间有可信任的关系时使用，如设备操作系统、或高特权应用。授权服务器应该在很特殊的情况时启用这种授权类型，并且仅仅当其他应用都不可见时允许使用这种类型。\nOAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.PASSWORD);\n\nJsonObject tokenConfig = new JsonObject()\n .put(\"username\", \"username\")\n .put(\"password\", \"password\");\n\n// Callbacks\n// Save the access token\noauth2.getToken(tokenConfig, res -> {\n if (res.failed()) {\n System.err.println(\"Access Token Error: \" + res.cause().getMessage());\n } else {\n // Get the access token object (the authorization code is given from the previous step).\n AccessToken token = res.result();\n\n oauth2.api(HttpMethod.GET, \"/users\", new JsonObject().put(\"access_token\", token.principal().getString(\"access_token\")), res2 -> {\n // the user object should be returned here...\n });\n }\n});\n客户端证书流程\n这种类型对于客户端要获取资源拥有者证书是合适的。\nJsonObject credentials = new JsonObject()\n .put(\"clientID\", \"\")\n .put(\"clientSecret\", \"\")\n .put(\"site\", \"https://api.oauth.com\");\n\n// Initialize the OAuth2 Library\nOAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.CLIENT, credentials);\n\nJsonObject tokenConfig = new JsonObject();\n\n// Callbacks\n// Save the access token\noauth2.getToken(tokenConfig, res -> {\n if (res.failed()) {\n System.err.println(\"Access Token Error: \" + res.cause().getMessage());\n } else {\n // Get the access token object (the authorization code is given from the previous step).\n AccessToken token = res.result();\n }\n});\n访问令牌对象\n当一个令牌过期后你需要刷新令牌，OAuth2提供了访问令牌类AccessToken，它包含了很多实用的方法可以在令牌过期过后对令牌进行刷新。\nif (token.expired()) {\n // Callbacks\n token.refresh(res -> {\n if (res.succeeded()) {\n // success\n } else {\n // error handling...\n }\n });\n}\n当你使用令牌访问完成过后想要注销，你可以撤销（Revoke）访问令牌和刷新令牌。\ntoken.revoke(\"access_token\", res -> {\n // Session ended. But the refresh_token is still valid.\n\n // Revoke the refresh_token\n token.revoke(\"refresh_token\", res1 -> {\n System.out.println(\"token revoked.\");\n });\n});\n其他通用OAuth2的Provider配置示例\nGoogle\nJsonObject credentials = new JsonObject()\n .put(\"clientID\", \"CLIENT_ID\")\n .put(\"clientSecret\", \"CLIENT_SECRET\")\n .put(\"site\", \"https://accounts.google.com\")\n .put(\"tokenPath\", \"https://www.googleapis.com/oauth2/v3/token\")\n .put(\"authorizationPath\", \"/o/oauth2/auth\");\n\n// Initialize the OAuth2 Library\nOAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.CLIENT, credentials);\nGitHub\nJsonObject credentials = new JsonObject()\n .put(\"clientID\", \"CLIENT_ID\")\n .put(\"clientSecret\", \"CLIENT_SECRET\")\n .put(\"site\", \"https://github.com/login\")\n .put(\"tokenPath\", \"/oauth/access_token\")\n .put(\"authorizationPath\", \"/oauth/authorize\");\n\n// Initialize the OAuth2 Library\nOAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.CLIENT, credentials);\nLinkedin\nJsonObject credentials = new JsonObject()\n .put(\"clientID\", \"CLIENT_ID\")\n .put(\"clientSecret\", \"CLIENT_SECRET\")\n .put(\"site\", \"https://www.linkedin.com\")\n .put(\"authorizationPath\", \"/uas/oauth2/authorization\")\n .put(\"tokenPath\", \"/uas/oauth2/accessToken\");\n\n// Initialize the OAuth2 Library\nOAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.CLIENT, credentials);\nTwitter\nJsonObject credentials = new JsonObject()\n .put(\"clientID\", \"CLIENT_ID\")\n .put(\"clientSecret\", \"CLIENT_SECRET\")\n .put(\"site\", \"https://api.twitter.com\")\n .put(\"authorizationPath\", \"/oauth/authorize\")\n .put(\"tokenPath\", \"/oauth/access_token\");\n\n// Initialize the OAuth2 Library\nOAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.CLIENT, credentials);\nFacebook\nJsonObject credentials = new JsonObject()\n .put(\"clientID\", \"CLIENT_ID\")\n .put(\"clientSecret\", \"CLIENT_SECRET\")\n .put(\"site\", \"https://www.facebook.com\")\n .put(\"authorizationPath\", \"/dialog/oauth\")\n .put(\"tokenPath\", \"https://graph.facebook.com/oauth/access_token\");\n\n\n// Initialize the OAuth2 Library\nOAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.CLIENT, credentials);\nJBoss Keycloak\nJsonObject credentials = new JsonObject()\n .put(\"clientID\", \"CLIENT_ID\")\n .put(\"clientSecret\", \"CLIENT_SECRET\")\n .put(\"site\", \"https://www.your-keycloak-server.com\")\n .put(\"authorizationPath\", \"/realms/\" + realm + \"/protocol/openid-connect/auth\")\n .put(\"tokenPath\", \"/realms/\" + realm + \"/protocol/openid-connect/token\");\n\n// Initialize the OAuth2 Library\nOAuth2Auth oauth2 = OAuth2Auth.create(vertx, OAuth2FlowType.CLIENT, credentials);\n"},"reactive/Reactive.html":{"url":"reactive/Reactive.html","title":"Reactive","keywords":"","body":"Vert.x Reactive\nVert.x 提供了数个组件，可以使你的应用更具有响应性（reactive）。\n"},"reactive/Rx.html":{"url":"reactive/Rx.html","title":"Vert.x Rx","keywords":"","body":"Vert.x Rx\n\n原文档\n组件源码\n组件示例\n\n中英文对照表\n\nobservable sequences：可观察序列\nRxified：Rx化\noperator：操作符\nlift：变换\nflow：流\nread stream：可读流\nwrite stream：可写流\nobserver：观察者\nsubscriber：订阅者\nitem：对象\nhandler：（事件）处理器\ntimer：定时器\nsubscription(n.)：订阅\nunmarshall：重组\n\nVert.x API for RxJava\nRxJava 是 JVM 上一个流行的库，用于组合异步的、使用可观察序列的、基于事件的程序。\nVert.x 与 RxJava 集成起来很自然：它使得无论什么时候，只要我们能使用流和异步结果，就能使用 Observable。\n要使用 Vert.x 的 RxJava API，有两种方式：\n\n通过原始的 Vert.x API 辅以 RxHelper 类，这个辅助类提供了用于 Vert.x Core API 和 RxJava API 之间互相转化的静态方法。\n通过基于 Vert.x Core API 增强的Rx化的 Vert.x API。\n\n可读流支持\nRxJava 中 Observable 的概念和 Vert.x 中 ReadStream 类是一对完美的匹配：都提供了一个对象流。\n静态方法 RxHelper.toObservable 用于将 Vert.x 可读流转换为 rx.Observable：\nFileSystem fileSystem = vertx.fileSystem();\nfileSystem.open(\"/data.txt\", new OpenOptions(), result -> {\n AsyncFile file = result.result();\n Observable observable = RxHelper.toObservable(file);\n observable.forEach(data -> System.out.println(\"Read data: \" + data.toString(\"UTF-8\")));\n});\n\n而 Rx化的 Vert.x API 在 ReadStream 类上提供了 toObservable 方法：\nFileSystem fs = vertx.fileSystem();\nfs.open(\"/data.txt\", new OpenOptions(), result -> {\n AsyncFile file = result.result();\n Observable observable = file.toObservable();\n observable.forEach(data -> System.out.println(\"Read data: \" + data.toString(\"UTF-8\")));\n});\n\n这样的 Observable 是所谓 hot observable，即不管是否有订阅，它们都会产生通知。\n\n译者注：在 RxJava 里，Observable 有“冷热”(cold/hot)之分。区别在于 cold observable 只有当订阅发生时，才会开始发射数据，而 hot observable 在创建完成后就会开始发射数据。更进一步的信息请查阅 RxJava 关于 Observable 的文档。\n\n同样的，将一个 Observable 转变为 Vert.x ReadStream 也是可以的。\n静态方法 RxHelper.toReadStream 用于将 rx.Observable 转换为 Vert.x 可读流：\nObservable observable = getObservable();\nReadStream readStream = RxHelper.toReadStream(observable);\nPump pump = Pump.pump(readStream, response);\npump.start();\n\n处理器支持\nRxHelper 类可以创建 ObservableHandler 对象。这是一个 Observable 对象，它的 toHandler 方法会返回 Handler 接口的实现：\nObservableHandler observable = RxHelper.observableHandler();\nobservable.subscribe(id -> {\n // Fired\n});\nvertx.setTimer(1000, observable.toHandler());\n\nRx化的 Vert.x API 未提供针对 Handler 的 API。\n异步结果支持\n以一个现有的 Vert.x Handler> 对象为基础，你可以创建一个 RxJava Subscriber，然后将其注册在 Observable 或 Single 上：\nobservable.subscribe(RxHelper.toSubscriber(handler1));\n\n// Subscribe to a Single\nsingle.subscribe(RxHelper.toSubscriber(handler2));\n\n在构造(construct)发生时，作为异步方法的最后一个参数的 Vert.x Handler> 可以被映射为单个元素的 Observable：\n\n当回调成功时，观察者的 onNext 方法将被调用，参数就是这个对象；且其后 onComplete 方法会立即被调用。\n当回调失败时，观察者的 onError 方法将被调用。\n\nRxHelper.observableFuture 方法可以创建一个 ObservableFuture 对象。这这是一个 Observable 对象，它的 toHandler 方法会返回 Handler> 接口的实现：\nObservableFuture observable = RxHelper.observableFuture();\nobservable.subscribe(\n server -> {\n // Server is listening\n },\n failure -> {\n // Server could not start\n }\n);\nvertx.createHttpServer(new HttpServerOptions().\n setPort(1234).\n setHost(\"localhost\")\n).listen(observable.toHandler());\n\n我们可以从 ObservableFuture 中获取单个 HttpServer 对象。如果端口监听失败，订阅者将会得到通知。\nRxHelper.toHandler 方法为观察者（Observer）和事件处理器（Handler）做了适配：\nObserver observer = new Observer() {\n @Override\n public void onNext(HttpServer o) {\n }\n @Override\n public void onError(Throwable e) {\n }\n @Override\n public void onCompleted() {\n }\n};\nHandler> handler = RxHelper.toFuture(observer);\n\n下面的代码也是可以的（直接基于Action）：\nAction1 onNext = httpServer -> {};\nAction1 onError = httpServer -> {};\nAction0 onComplete = () -> {};\n\nHandler> handler1 = RxHelper.toFuture(onNext);\nHandler> handler2 = RxHelper.toFuture(onNext, onError);\nHandler> handler3 = RxHelper.toFuture(onNext, onError, onComplete);\n\nRx化的 Vert.x API 复制了类似的每一个方法，并冠以 rx 的前缀，它们都返回 RxJava 的 Single 对象：\nSingle single = vertx\n .createHttpServer()\n .rxListen(1234, \"localhost\");\n\n// 订阅绑定端口的事件\nsingle.\n subscribe(\n server -> {\n // Server is listening\n },\n failure -> {\n // Server could not start\n }\n );\n\n这样的 Single 是 “冷的”(cold)，对应的 API 方法将在注册时被调用。\n\n注意：类似 rx* 的方法替换了以前版本中 *Observable 的方法，这样一个语义上的改变是为了与 RxJava 保持一致。\n\n调度器支持\n有时候 Reactive 扩展库需要执行一些可调度的操作，例如 Observable#timer 方法将创建一个能周期性发射事件的定时器并返回之。缺省情况下，这些可调度的操作由 RxJava 管理，这意味着定时器线程并非 Vert.x 线程，因此（这些操作）并不是在 Vert.x Event Loop 线程上执行的。\n在 RxJava 中，有些操作通常会有接受一个 rx.Scheduler 参数的重载方法用于设定 Scheduler。RxHelper 类提供了一个 RxHelper.scheduler 方法，其返回的调度器可供 RxJava 的这些方法使用。比如：\nScheduler scheduler = RxHelper.scheduler(vertx);\nObservable timer = Observable.timer(100, 100, TimeUnit.MILLISECONDS, scheduler);\n\n对于阻塞型的可调度操作（blocking scheduled actions），我们可以通过 RxHelper.blockingScheduler 方法获得适用的调度器：\nScheduler scheduler = RxHelper.blockingScheduler(vertx);\nObservable obs = blockingObservable.observeOn(scheduler);\n\nRxJava 也能被配置成使用 Vert.x 的调度器，这得益于 RxHelper.schedulerHook 方法创建的调度器钩子对象。对于 IO 操作这里使用了阻塞型的调度器：\nRxJavaSchedulersHook hook = RxHelper.schedulerHook(vertx);\nRxJavaHooks.setOnIOScheduler(f -> hook.getIOScheduler());\nRxJavaHooks.setOnNewThreadScheduler(f -> hook.getNewThreadScheduler());\nRxJavaHooks.setOnComputationScheduler(f -> hook.getComputationScheduler());\n\nRx化的 Vert.x API 在 RxHelper 类中也提供了相似的方法：\nScheduler scheduler = io.vertx.rxjava.core.RxHelper.scheduler(vertx);\nObservable timer = Observable.interval(100, 100, TimeUnit.MILLISECONDS, scheduler);\n\nRxJavaSchedulersHook hook = io.vertx.rxjava.core.RxHelper.schedulerHook(vertx);\nRxJavaHooks.setOnIOScheduler(f -> hook.getIOScheduler());\nRxJavaHooks.setOnNewThreadScheduler(f -> hook.getNewThreadScheduler());\nRxJavaHooks.setOnComputationScheduler(f -> hook.getComputationScheduler());\n\n基于一个命名的工作线程池（named worker pool）创建调度器也是可以的，如果你想为了调度阻塞操作复用特定的线程池，这将会很有帮助：\nScheduler scheduler = io.vertx.rxjava.core.RxHelper.scheduler(workerExecutor);\nObservable timer = Observable.interval(100, 100, TimeUnit.MILLISECONDS, scheduler);\n\nJSON解码\nRxHelper.unmarshaller 方法创建了一个 rx.Observable.Operator 对象，这个操作符的作用是将 Observable 变换为对象的 Observable：\nfileSystem.open(\"/data.txt\", new OpenOptions(), result -> {\n AsyncFile file = result.result();\n Observable observable = RxHelper.toObservable(file);\n observable.lift(RxHelper.unmarshaller(MyPojo.class)).subscribe(\n mypojo -> {\n // 处理对象\n }\n );\n});\n\nRx化的辅助类也能做同样的事：\nfileSystem.open(\"/data.txt\", new OpenOptions(), result -> {\n AsyncFile file = result.result();\n Observable observable = file.toObservable();\n observable.lift(io.vertx.rxjava.core.RxHelper.unmarshaller(MyPojo.class)).subscribe(\n mypojo -> {\n // 处理对象\n }\n );\n});\n\n部署Verticle\nRx化的 API 不能部署一个已经存在的 Verticle 实例。RxHelper.observableFuture 方法为此提供了一个解决方案。\n所有工作都在 RxHelper.deployVerticle 方法里自动完成，它会部署一个 Verticle 并返回包含部署 ID 的 Observable。\nObservable deployment = RxHelper.deployVerticle(vertx, verticle);\n\ndeployment.subscribe(id -> {\n // 部署成功\n}, err -> {\n // 部署失败\n});\n\nHttpClient GET on subscription\n对于通过订阅执行一个 HTTP GET 请求这样的需求，利用 RxHelper.get 方法是很适合的：\nObservable get = RxHelper.get(client, \"http://the-server\");\n\n// 执行请求\nget.subscribe(resp -> {\n // 获得响应\n}, err -> {\n // 出错了\n});\n\n\n警告：执行 GET 请求时，这个 API 和 HttpClient 是不同的。当方法被调用时，它会返回一次性的 Observable。\n\nRxified API\nRx化的 API 是 Vert.x API 的一个代码自动生成版本，就像 Vert.x 的 JavaScript 或 Groovy 版本一样。这个 API 以 io.vertx.rxjava 为包名前缀，例如 io.vertx.core.Vertx 类被转化为 ·io.vertx.rxjava.core.Vertx·类。\nEmbedding Rxfified Vert.x\n只需使用 Vertx.vertx 方法：\nVertx vertx = io.vertx.rxjava.core.Vertx.vertx();\n\n作为Verticle\n通过继承 AbstractVerticle 类，它会做一些包装（你将获得一个 RxJava Verticle）：\nclass MyVerticle extends io.vertx.rxjava.core.AbstractVerticle {\n public void start() {\n // Use Rxified Vertx here\n }\n}\n\n部署一个 RxJava Verticle 不需要特别的部署器，使用 Java 部署器即可。\nAPI 样例\n让我们通过研究一些样例来了解相关 API 吧。\nEvent Bus 消息流\n很自然地，MessageConsumer 类提供了相关的 Observable>：\nEventBus eb = vertx.eventBus();\nMessageConsumer consumer = eb.consumer(\"the-address\");\nObservable> observable = consumer.toObservable();\nSubscription sub = observable.subscribe(msg -> {\n // 获得消息\n});\n\n// 10秒后注销\nvertx.setTimer(10000, id -> {\n sub.unsubscribe();\n});\n\nMessageConsumer 类提供了 Message 的流，如果需要，还可以通过 body 方法获得消息体组成的新流：\nEventBus eb = vertx.eventBus();\nMessageConsumer consumer = eb.consumer(\"the-address\");\nObservable observable = consumer.bodyStream().toObservable();\n\nRxJava 的 map/reduce 组合风格在这里是相当有用的：\nObservable observable = vertx.eventBus().\n consumer(\"heat-sensor\").\n bodyStream().\n toObservable();\n\nobservable.\n buffer(1, TimeUnit.SECONDS).\n map(samples -> samples.\n stream().\n collect(Collectors.averagingDouble(d -> d))).\n subscribe(heat -> {\n vertx.eventBus().send(\"news-feed\", \"Current heat is \" + heat);\n });\n\n定时器\n定时器任务可以通过 timerStream 方法来创建：\nvertx.timerStream(1000).\n toObservable().\n subscribe(\n id -> {\n System.out.println(\"Callback after 1 second\");\n }\n );\n\n周期性的任务可以通过 periodicStream 方法来创建：\nvertx.periodicStream(1000).\n toObservable().\n subscribe(\n id -> {\n System.out.println(\"Callback every second\");\n }\n );\n\n通过注销操作可以取消对 Observable 的订阅：\nvertx.periodicStream(1000).\n toObservable().\n subscribe(new Subscriber() {\n public void onNext(Long aLong) {\n // 回调\n unsubscribe();\n }\n public void onError(Throwable e) {}\n public void onCompleted() {}\n });\nHTTP客户端请求\ntoObservable 方法提供了带有 HttpClientResponse 对象的一次性回调，请求错误同样会在 Observable 中反映处理。\nHttpClient client = vertx.createHttpClient(new HttpClientOptions());\nHttpClientRequest request = client.request(HttpMethod.GET, 8080, \"localhost\", \"/the_uri\");\nrequest.toObservable().subscribe(\n response -> {\n // 处理响应\n },\n error -> {\n // 无法连接\n }\n);\nrequest.end();\n\n通过 toObservable 方法可以将响应当成 Observable 来处理：\nrequest.toObservable().\n subscribe(\n response -> {\n Observable observable = response.toObservable();\n observable.forEach(\n buffer -> {\n // 处理 buffer\n }\n );\n }\n );\n\nflatMap 操作也能获得同样的流：\nrequest.toObservable().\n flatMap(HttpClientResponse::toObservable).\n forEach(\n buffer -> {\n // Process buffer\n }\n );\n\n通过静态方法 RxHelper.unmarshaller ，我们也能将 Observable 重组为对象。这个方法创建了一个 Rx.Observable.Operator（Rx 操作符）供重组操作使用：\nrequest.toObservable().\n flatMap(HttpClientResponse::toObservable).\n lift(io.vertx.rxjava.core.RxHelper.unmarshaller(MyPojo.class)).\n forEach(\n pojo -> {\n // Process pojo\n }\n );\n\nHTTP服务端请求\nrequestStream 方法对到达的每个请求都提供了回调：\nObservable requestObservable = server.requestStream().toObservable();\nrequestObservable.subscribe(request -> {\n // 处理请求\n});\n\nHttpServerRequest 可以被适配为 Observable：\nObservable requestObservable = server.requestStream().toObservable();\nrequestObservable.subscribe(request -> {\n Observable observable = request.toObservable();\n});\n\nRxHelper.unmarshaller 方法可以用来解析 JSON 格式的请求并将其映射为对象：\nObservable requestObservable = server.requestStream().toObservable();\nrequestObservable.subscribe(request -> {\n Observable observable = request.\n toObservable().\n lift(io.vertx.rxjava.core.RxHelper.unmarshaller(MyPojo.class));\n});\n\nWebSocket客户端\n当 WebSocket 连接上或失败时，websocketStream 方法对此提供了一次性的回调：\nHttpClient client = vertx.createHttpClient(new HttpClientOptions());\nclient.websocketStream(8080, \"localhost\", \"/the_uri\").toObservable().subscribe(\n ws -> {\n // Use the websocket\n },\n error -> {\n // Could not connect\n }\n);\n\nWebSocket 对象可以轻松地转换为 Observable：\nsocketObservable.subscribe(\n socket -> {\n Observable dataObs = socket.toObservable();\n dataObs.subscribe(buffer -> {\n System.out.println(\"Got message \" + buffer.toString(\"UTF-8\"));\n });\n }\n);\n\nWebSocket服务端\n每当有新连接到达时，websocketStream 方法都会提供一次回调：\nObservable socketObservable = server.websocketStream().toObservable();\nsocketObservable.subscribe(\n socket -> System.out.println(\"Web socket connect\"),\n failure -> System.out.println(\"Should never be called\"),\n () -> {\n System.out.println(\"Subscription ended or server closed\");\n }\n);\n\nServerWebSocket 对象可以轻松地转换为 Observable：\nsocketObservable.subscribe(\n socket -> {\n Observable dataObs = socket.toObservable();\n dataObs.subscribe(buffer -> {\n System.out.println(\"Got message \" + buffer.toString(\"UTF-8\"));\n });\n }\n);\n\n\n\n原文档最后更新于 2017-03-15 15:54:14 CET\n\n"},"reactive/Reactivestreams.html":{"url":"reactive/Reactivestreams.html","title":"Reactive streams","keywords":"","body":"Vert.x Reactive Streams\n\n原文档\n组件源码\n\n中英文对照表\n\npublisher(n.)：发布者\nsubscriber(n.)：订阅者\nread stream(n.)：可读流\nwrite stream(n.)：可写流\nsubscribe(v.)：注册\nback pressure：背压机制\n\n为了支持在 JVM 上进行非阻塞的带背压机制的异步流处理， Reactive Streams 做了一些初创性的工作来提供这样一份标准。\n这个库提供了 Vert.x 上 Reactive Streams 标准的实现。\n在处理流式数据方面，Vert.x 有自己的机制；通过这三个类：io.vertx.core.streams.ReadStream 、 io.vertx.core.streams.WriteStream 和 io.vertx.core.streams.Pump，可以在将数据从一个流泵到另一个流时，实现流量控制。更多关于 Vert.x 流方面的信息请查阅 Vert.x Core 部分的手册。\n这个库为可读流、可写流都提供了实现，这两者分别扮演了 Reactive Streams 中发布者和订阅者的角色；这使得我们能够以对待 Vert.x 中读写流的方式处理任意 Reactive Streams 的发布者和订阅者。\n使用 Vert.x Reactive Streams\n要使用 Vert.x Reactive Streams 组件，需要在构建描述符中添加如下依赖：\n\nMaven（在 pom.xml 文件中）：\n\n\n io.vertx\n vertx-reactive-streams\n 3.4.1\n\n\n\nGradle（在 build.gradle 文件中）：\n\ncompile 'io.vertx:vertx-reactive-streams:3.4.1'\n\nReactive Read Stream\n我们为 Vert.x 的 ReadStream 接口提供了实现类 ReactiveReadStream ，它同样也实现了 Reactive Streams 的订阅者角色。\n你可以把这个类的实例传递给任意的 Reactive Streams 发布者（例如来自 Akka 的发布者），随后你就可以像从其他任意的 Vert.x ReadStream中一样读取数据（例如使用一个 Pump 把数据从这个流泵到一个 WriteStream）。\n这里有个例子，从某个其他的 Reactive Streams 实现中（例如 Akka）获得一个发布者，并将其数据泵入到服务端的 HTTP 响应体中。其间，背压机制是自动执行的。\nReactiveReadStream rrs = ReactiveReadStream.readStream();\n\n// 在另外的发布者上注册订阅者\notherPublisher.subscribe(rrs);\n\n// 将数据从可读流泵入 HTTP 响应\nPump pump = Pump.pump(rrs, response);\n\npump.start();\n\nReactive Write Stream\n同样的，我们为 WriteStream 接口提供了实现类 ReactiveWriteStream ，它也是 Reactive Streams 的发布者角色的实现。拿到任意的 Reactive Streams 订阅者（例如来自 Akka 的订阅者）之后，你就可以像处理其他任意的 Vert.x WriteStream一样，往其中写入数据（例如使用一个 Pump 把从 ReadStream 来的数据泵入其中）。\n在手动处理 Vert.x 可读流的背压时，你会用到 pause，resume，writeQueueFull 这些方法；它们会在内部被自动转换成 Reactive Streams 中背压机制传播方面的方法（在请求更多数据项时）。\n这里有个例子，从其他的 Reactive Streams 实现拿到订阅者之后，将服务端的请求体泵入其中。其间背压机制将自动运行。\nReactiveWriteStream rws = ReactiveWriteStream.writeStream(vertx);\n\n// 在可写流上注册另外的订阅者\nrws.subscribe(otherSubscriber);\n\n// 将 HTTP 请求泵入可写流\nPump pump = Pump.pump(request, rws);\n\npump.start();\n\n\n\n原文档最后更新于 2017-03-15 15:54:14 CET\n\n"},"reactive/Sync.html":{"url":"reactive/Sync.html","title":"Vert.x Sync","keywords":"","body":"Vert.x Sync\n\n原文档\n组件源码\n组件示例\n\n中英文对照表\n\nbytecode instrumentation：字节码修改/增强\nkernel thread：内核线程\n\n简介\nVert.x Sync 是一组工具集，其特点是在不阻塞内核线程的同时，允许用户以同步的方式接收事件、执行异步操作。\n比起很多历史遗留的应用系统，Vert.x 的一个关键优点是完全非阻塞(于内核线程而言) —— 这使它用少量的内核线程就可以处理大量的并发(例如，处理很多的连接、消息之类)，具有优异的可扩展性。\nVert.x 非阻塞性的特性产生了异步的 API 。异步 API 可以有多种风格，包括回调、Promise和Rx风格。Vert.x 在绝大多数地方使用回调(尽管它也支持Rx)。\n某些情况下，使用异步 API 编程比直接使用同步 API 要更具挑战，特别是当你有好几个操作要按顺序完成时。同时，使用异步 API 时，错误的传递也会变得更复杂。\nVert.x Sync 可以让你在熟悉的同步风格下继续使用异步 API 。\n在此，通往自由之路的功臣乃 Fiber(译者注：这个词国内有译作纤程，类似协程-coroutine)。Fiber 是超轻量级的线程，并不是对应于底层的那种内核线程，它们被阻塞时不会导致内核线程也被阻塞。\nVert.x 借助 Quasar 库来实现 Fiber。\n\n注意：Vert.x Sync 当前只适用于 Java 。\n\nSyncVerticle\n要使用 Vert.x Sync 库，你的代码需要继承 io.vertx.ext.sync.SyncVerticle 类，并重载start()方法和stop()方法(stop 非必需)。\n这些方法还必须加上 @Suspendable 注解。\n写好的 Sync Verticle，其部署方法和其他 Verticle 完全一样。\nInstrumentation\nVert.x 用到了 Quasar 库，这个库借助字节码增强(bytecode instrumentation)的技术实现了 Fiber。字节码增强工作是在运行时使用 Java Agent 技术完成的。\n为了使这个特性正常工作，需要在启动 JVM 时指定 quasar-core jar包为 Java Agent jar 包：\n-javaagent:/path/to/quasar/core/quasar-core.jar\n\n如果你用的是 vertx 命令行工具，可以在执行 vertx 前设置环境变量 ENABLE_VERTX_SYNC_AGENT 为 ture，这样可以启用 Agent 的配置。\n你也可以使用 quasar-maven-plugin 达成离线增强(offline instrumentation，指非运行时织入字节码)的效果。更多细节请参考 Quasar 官方文档。\n获得一次性的异步操作结果\n在Vert.x 的领域里，很多操作都会接受一个 Handler> 作为最后的参数，例如用 Vert.x 的 Mongo 客户端执行一次查询或者发送一个 Event Bus 消息然后拿到回应。\nVert.x Sync 可以让你用同步的方式得到这种一次性的异步操作的结果。这是通过调用 Sync.awaitResult 方法完成的。调用这个方法时，需将想要执行的异步操作包装成 Consumer 的形式。Handler 参数会在运行时传给此 Consumer 。\n看下面的例子：\nEventBus eb = vertx.eventBus();\n\n// Send a message and get the reply synchronously\n\nMessage reply = awaitResult(h -> eb.send(\"someaddress\", \"ping\", h));\n\nSystem.out.println(\"Received reply \" + reply.body());\n\n上面的例子中，在回应返回前，Fiber 会一直被阻塞住，而内核线程不会。\n获得一次性的事件\nVert.x Sync 也能以同步的方式获得一次性的事件，例如定时器的触发，或者 end handler（译者注：关于 end handler 的例子可以参见 Vert.x Core 文档中 HTTP 服务器与客户端 一节）的执行。这是通过 Sync.awaitEvent 方法完成成的。\n看下面的例子：\nlong tid = awaitEvent(h -> vertx.setTimer(1000, h));\n\nSystem.out.println(\"Timer has now fired\");\n\n事件流\n很多时候，Vert.x 的 Handler 接收到的是事件流，例如 Event Bus 消息的消费者(Consumer)、HTTP 服务端里的 HTTP 服务端请求(server request)。\nVert.x Sync 使你能以同步的方式从这种流中接收事件。\n你需要一个同时实现了 Handler 和 Receiver 接口的 HandlerReceiverAdaptor 类实例。Sync.streamAdaptor 方法可以创建这样一个实例。\n你可以把它当成一个普通的 Handler ，然后可以用实现自 Receiver 接口的方法来同步地接收事件。\n下面是一个 Event Bus 消息消费者的例子：\nEventBus eb = vertx.eventBus();\n\nHandlerReceiverAdaptor> adaptor = streamAdaptor();\n\neb.consumer(\"some-address\").handler(adaptor);\n\n// Receive 10 messages from the consumer:\nfor (int i = 0; i received1 = adaptor.receive();\n\n System.out.println(\"got message: \" + received1.body());\n\n}\n\n使用 FiberHandler\n如果你想在一般的 Handler 中使用 Fiber —— 例如 HTTP 服务端的请求处理器（request handler） ，那得首先把这个一般的 Handler 转换为 Fiber Handler 。\nFiber Handler 会在 Fiber 里运行那个一般的 Handler 。\n看例子：\nEventBus eb = vertx.eventBus();\n\nvertx.createHttpServer().requestHandler(fiberHandler(req -> {\n\n // Send a message to address and wait for a reply\n Message reply = awaitResult(h -> eb.send(\"some-address\", \"blah\", h));\n\n System.out.println(\"Got reply: \" + reply.body());\n\n // Now end the response\n req.response().end(\"blah\");\n\n})).listen(8080, \"localhost\");\n\n更多示例\n在 Examples Repository 这里有一些示例，展示了 vertx-sync 的用法。\n\n\n原文档最后更新于 2017-03-15 15:54:14 CET\n\n"},"microservices/ServiceDiscovery.html":{"url":"microservices/ServiceDiscovery.html","title":"Vert.x Service Discovery","keywords":"","body":"Vert.x Service Discovery\n\n原文档\n组件源码\n组件示例\n\n组件介绍\nVert.x 提供了一个服务发现的基础组件，用来发布和发现各种类型的资源，比如服务代理、HTTP端点（endpoint）、数据源（data source）等等。\n这些资源都可以称为服务。服务就是一个可以被发现和访问的功能，可以通过它的类型、元数据和位置来进行描述。所以，服务可以是一个数据库、一个服务代理、一个HTTP应用，以及任何你能想到的可描述、可发现、可交互的资源。它不一定是Vert.x实体，它可以是任何组件。在Vert.x 服务发现组件中，我们通过 Record 来描述每个服务。\n服务发现组件实现了面向服务计算中定义的服务交互。此外，在某种程度上，还提供了动态的面向服务计算交互，这样应用程序可以对各种服务的上线、下线作出反应。\n一个服务提供者可以：\n\n发布一个服务记录\n将已经发布的服务记录注销\n更新已发布服务记录的状态（下线、服务暂停等等）\n\n一个服务消费者可以：\n\n查找各种服务\n绑定到某个服务（它所获取到的 ServiceReference）并且使用这个服务\n当使用完后，释放绑定的服务\n监听服务的上线、下线和状态变更的消息\n\n服务消费者访问服务的步骤：\n\n查找满足它需求的服务记录\n取得可访问的 ServiceReference\n通过服务对象来访问服务\n一旦使用完后释放服务对象\n\n如果知道服务的类型（JDBC客户端、HTTP客户端），整个过程就可以简化为通过服务类型直接获取服务对象。\n从上面可以看出，服务提供者和服务消费者，通过服务记录来共享关键的信息。\n服务提供者和消费者，必须创建他们自己的 ServiceDiscovery 实例。这些实例通过底层的分布式数据结构来协同保持服务集合的同步。\n服务发现组件支持桥接的方式，来从其他服务发现技术中导入和导出服务。\n使用Service Discovery\n要使用Vert.x 服务发现组件，需要将下列依赖加入到依赖配置中文件：\n\nMaven (pom.xml文件中)：\n\n\n io.vertx\n vertx-service-discovery\n 3.4.1\n\n\n\nGradle (build.gradle 文件中)：\n\ncompile 'io.vertx:vertx-service-discovery:3.4.1'\n\n基本概念\n本节将解释服务发现机制所涉及到的一些概念。\n服务记录\n我们用服务记录 （Record 对象）来描述服务提供者提供的服务，它包含了服务名称、一些元数据和一个描述服务所在位置的位置对象。\n服务记录的元数据、甚至位置的格式，都有赖于服务的类型（详见后续章节）。\n当服务提供者准备好可以提供服务时，会发布一条服务记录，在服务停止的时候，会收回这条服务记录。\n服务提供者和发布者\n服务提供者是提供服务的实体，而发布者的职责是发布服务记录，通过该服务记录来描述服务提供者的信息。服务提供者和发布者可以是同一个实体，也可以是不同的实体。\n服务消费者\n服务消费者在Service Discovery中搜索服务，每次搜索得到的结果是0..n条服务记录（Record）。通过这些服务记录，消费者可以获得服务引用（ServiceReference）。服务引用的作用是绑定服务消费者和服务提供者。通过服务引用，消费者可以得到服务对象来使用服务，也可以通过服务引用释放服务对象。\n在使用完服务后，必须释放服务引用，才能清理服务对象和更新服务使用状态。\n服务对象\n服务对象为服务消费者提供了一条获取服务的通道，它有各种实现方式，比如一个代理对象、一个客户端对象、甚至某些类型的服务可能不存在这样一个服务对象。服务对象的表现有赖于服务的类型。\n由于Vert.x的多语言特性，当你从Java、Groovy或其他语言中获取服务对象的时候，可能会有差异。\n服务类型\n服务就是资源。有很多各种各样的服务，比如功能性的服务组件、数据库、REST API等等。Vert.x 服务发现组件通过服务类型的概念来处理这种差异。每种服务类型都需要定义：\n\n如何定位服务（URI、Event Bus地址、IP/DNS 等） - location\n提供服务的对象的性质（服务代理、HTTP Client、消息消费者 等） - client\n\n服务发现组件提供了一些现成的服务类型，但你也可以添加自己的服务类型。\n服务事件\n每当发布或回收服务时，Event Bus中都会触发一个事件，这个事件包含着被修改的服务记录。\n每当通过 getReference 方法获取一个服务引用或者通过 release 方法释放一个服务引用时，都会有事件发送到 Event Bus 中，用来跟踪服务的使用情况。\n关于服务事件的更详细内容参考后续章节。\n服务存储后端\n服务发现组件使用Vert.x的分布式数据结构来存储服务记录。所以，集群中所有的成员都可以访问到所有的服务记录，这是服务后端的默认实现。你也可以实现自己的服务记录存储后端，只要实现 ServiceDiscoveryBackend 接口就可以了。比如，Vert.x还通过实现该接口提供了基于Redis的存储后端。\n注意服务发现模块并不需要运行在Vert.x 集群模式下。在单机模式下，服务记录存储于本地，并且可以通过 ServiceImporter 来导入。\n创建Service Discovery实例\n服务发布者和服务消费者都必须通过单独创建自己的 ServiceDiscovery 实例来使用服务发现模块：\nServiceDiscovery discovery = ServiceDiscovery.create(vertx);\n\n// 自定义配置\ndiscovery = ServiceDiscovery.create(vertx,\n new ServiceDiscoveryOptions()\n .setAnnounceAddress(\"service-announce\")\n .setName(\"my-name\"));\n\n// 做一些事情。。。\n\ndiscovery.close();\n\n在默认情况下，服务事件发送到Event Bus中的地址是 vertx.discovery.announce，你可以自己配置一个（查看服务使用章节）。\n当你不再需要 ServiceDiscovery 对象时，不要忘记关掉它（通过 close 方法）。它会把你配置的不同的服务导入/导出模块都关掉，并且释放服务引用。\n发布服务\n有了 ServiceDiscovery 实例，就可以发布服务了。发布的流程如下：\n\n为服务提供者创建一个服务记录\n发布这个服务记录\n保存这个发布记录的引用，后面可以用来取消发布或者修改发布\n\n你可以通过 Record 类或者各种服务类型类提供的快捷方法来创建服务记录。\nRecord record = new Record()\n .setType(\"eventbus-service-proxy\")\n .setLocation(new JsonObject().put(\"endpoint\", \"the-service-address\"))\n .setName(\"my-service\")\n .setMetadata(new JsonObject().put(\"some-label\", \"some-value\"));\n\ndiscovery.publish(record, ar -> {\n if (ar.succeeded()) {\n // publication succeeded\n Record publishedRecord = ar.result();\n } else {\n // publication failed\n }\n});\n\n// Record creation from a type\nrecord = HttpEndpoint.createRecord(\"some-rest-api\", \"localhost\", 8080, \"/api\");\ndiscovery.publish(record, ar -> {\n if (ar.succeeded()) {\n // publication succeeded\n Record publishedRecord = ar.result();\n } else {\n // publication failed\n }\n});\n\n一定要保持一个指向服务记录对象的引用，因为这个返回的服务记录会带有一个 注册ID。\n取消发布的服务\n要取消一个已发布的服务，可以用如下方式：\ndiscovery.unpublish(record.getRegistration(), ar -> {\n if (ar.succeeded()) {\n // Ok\n } else {\n // cannot un-publish the service, may have already been removed, or the record is not published\n }\n});\n\n查找服务\n本节讲述的是最基本的获取服务的方法。每种服务类型接口，都提供了快捷的方法，来简化获取服务的步骤。\n在服务消费端，第一步要做的事情就是查找服务记录。你可以查找并获取一条服务记录，也可以获取一批满足条件的记录。如果是获取一条记录，那么将返回第一条满足条件的服务记录。\n服务消费者通过传递一个过滤器来选择服务，有两种形式的过滤器：\n\n一个接收 Record 对象的函数，这个函数返回一个布尔值（就是一个 predicate，即判断函数）\n过滤器是一个JSON对象。对象中的每个条目，将会用来过滤服务记录。服务记录必须满足所有的条目要求。这些条目可以使用 * 号来代表必须存在某个key值，而不管value值\n\n让我们看一些JSON过滤器的例子\n{ \"name\" = \"a\" } => 匹配所有名称为\"a\"的记录\n{ \"color\" = \"*\" } => 匹配所有设置了 \"color\" 的记录\n{ \"color\" = \"red\" } => 匹配所有\"color\" 值为 \"red\"的记录\n{ \"color\" = \"red\", \"name\" = \"a\"} => 匹配所有名称为 \"a\", 并且\"color\"值为\"red\"的记录\n\n如果JSON过滤器未设置（为空或null），获取时将获取到所有的服务记录。当使用函数形式时，要获取所有的服务记录，你只需要返回 true 而不需要管服务记录的内容。\n下面是一些例子：\ndiscovery.getRecord(r -> true, ar -> {\n if (ar.succeeded()) {\n if (ar.result() != null) {\n // we have a record\n } else {\n // the lookup succeeded, but no matching service\n }\n } else {\n // lookup failed\n }\n});\n\ndiscovery.getRecord((JsonObject) null, ar -> {\n if (ar.succeeded()) {\n if (ar.result() != null) {\n // we have a record\n } else {\n // the lookup succeeded, but no matching service\n }\n } else {\n // lookup failed\n }\n});\n\n\n// Get a record by name\ndiscovery.getRecord(r -> r.getName().equals(\"some-name\"), ar -> {\n if (ar.succeeded()) {\n if (ar.result() != null) {\n // we have a record\n } else {\n // the lookup succeeded, but no matching service\n }\n } else {\n // lookup failed\n }\n});\n\ndiscovery.getRecord(new JsonObject().put(\"name\", \"some-service\"), ar -> {\n if (ar.succeeded()) {\n if (ar.result() != null) {\n // we have a record\n } else {\n // the lookup succeeded, but no matching service\n }\n } else {\n // lookup failed\n }\n});\n\n// Get all records matching the filter\ndiscovery.getRecords(r -> \"some-value\".equals(r.getMetadata().getString(\"some-label\")), ar -> {\n if (ar.succeeded()) {\n List results = ar.result();\n // If the list is not empty, we have matching record\n // Else, the lookup succeeded, but no matching service\n } else {\n // lookup failed\n }\n});\n\n\ndiscovery.getRecords(new JsonObject().put(\"some-label\", \"some-value\"), ar -> {\n if (ar.succeeded()) {\n List results = ar.result();\n // If the list is not empty, we have matching record\n // Else, the lookup succeeded, but no matching service\n } else {\n // lookup failed\n }\n});\n\n你可以获取一条服务记录，也可以通过 getRecords 方法获取所有匹配到的服务记录。默认情况下，服务查找只会包含状态为UP的服务，可以通过如下方式覆盖默认设置：\n\n当使用JSON过滤器，设置status属性为你想要的值（或者 * 来接收所有的状态）\n当使用函数过滤器，将 getRecords 方法的参数includeOutOfService设置为true\n\n获取服务引用\n当你选择好了服务记录后，你就可以获得到一个ServiceReference，然后得到服务对象：\nServiceReference reference1 = discovery.getReference(record1);\nServiceReference reference2 = discovery.getReference(record2);\n\n// Then, gets the service object, the returned type depends on the service type:\n// For http endpoint:\nHttpClient client = reference1.getAs(HttpClient.class);\n// For message source\nMessageConsumer consumer = reference2.getAs(MessageConsumer.class);\n\n// When done with the service\nreference1.release();\nreference2.release();\n\n使用完后，不要忘记释放服务引用。\n服务引用代表了一个绑定的服务提供者。\n获取服务引用的时候，可以传递一个JsonObject对象来配置服务对象，可以包括用来配置服务对象的各种参数。某些服务类型不需要额外的配置，有些需要（比如数据库对象）：\nServiceReference reference = discovery.getReferenceWithConfiguration(record, conf);\n\n// Then, gets the service object, the returned type depends on the service type:\n// For http endpoint:\nJDBCClient client = reference.getAs(JDBCClient.class);\n\n// Do something with the client...\n\n// When done with the service\nreference.release();\n\n在前面的示例中，代码中使用的是getAs方法，参数是你期望获得的对象类型。如果你使用Java语言，那么可以直接用get方法，而其他语言中，你必须传递对象类型。\n服务类型\n前面提到，服务发现使用了服务类型的概念，来封装各种服务的差异性。\n目前服务发现组件提供了几种默认的服务类型：\n\nHttpEndpoint - 为REST API服务提供的类型，服务对象的类型是一个配置好了host和port的HttpClient（其location表现为一个url）\nEventBusService - 服务代理，服务对象是一个代理，它的类型是所代理的接口（其location表现为一个Event Bus的address地址）\nMessageSource - 消息源服务，服务对象的类型是一个MessageConsumer（其location表现为一个Event Bus的address地址）\nJDBCDataSource - JDBC数据源服务，服务对象的类型是一个JDBCClient（该Client的配置参数，将从location、元数据和服务消费者传递的参数中获取）\nRedisDataSource - Redis数据源服务，服务对象的类型是一个RedisClient（该client的配置参数，将从location、元数据和服务消费者传递的参数中获取）\nMongoDataSource - Mongo数据源服务，服务对象的类型一个MongoClient（该client的配置参数，将从location、元数据和服务消费者传递的参数中获取）\n\n本节将详细介绍一下服务类型，以及如何使用服务发现框架已提供的几种服务类型。\n无类型的服务\n某些服务记录也可以不带有类型（ServiceType.UNKNOWN）。通过这种服务记录，是无法获取到服务引用的，但是你可以通过服务记录（Record）的location和metadata来创建连接的细节。\n使用这种服务，将不会产生服务使用的事件。\n自定义的服务类型\n通过实现 ServiceType SPI接口，可以自定义服务类型：\n\n（可选）创建一个继承了 ServiceType 的公共接口。在这个接口中，仅需要提供一些辅助方法，来简化自定义类型的使用，比如提供 createRecord 方法以及 getX 方法（这里的X指的是将返回的服务对象的类型）等等。可以查看 HttpEndpoint 和 MessageSource 等接口例子来了解这种设计。\n创建一个实现了 ServiceType 接口或者第一步定义的接口的类，这个类必须有一个 name 方法和一个用来创建 ServiceReference 的方法，这个 name 方法返回的名称，要和关联到自定义类型的 Record 的 type 属性一致。\n创建一个继承io.vertx.ext.discovery.types.AbstractServiceReference的类。你可以对类进行参数化，添加上你要返回的服务对象的类型信息，你必须实现AbstractServiceReference#retrieve()这个方法，在这个方法中创建服务对象，这个方法只会被调用一次，如果你的服务对象需要释放资源，那另外还需要覆写 AbstractServiceReference#close()方法。\n创建META-INF/services/io.vertx.servicediscovery.spi.ServiceType文件，并把这个文件打包到自定义类型的jar包中，在这个文件中，需要标明第二步中所创建类的全限定名。\n将第一步的服务接口、第二步第三步的实现类以及第四步中的服务描述文件打包成一个jar包，然后将这个jar包放到你应用的 classpath 中。然后，这个自定义类型就可以使用了。\n\nHTTP Endpoint\n一个 HTTP 端点(endpoint)，就是一个REST API或可以通过HTTP请求访问的服务。HTTP Endpoint服务对象就是一个配置了host、port和ssl的 HttpClient 对象。\n发布HTTP Endpoint服务\n要发布一个HTTP Endpoint服务，你需要一个 Record 对象。你可以通过调用HttpEndpoint.createRecord创建这样一个服务记录对象。\n下面的代码片段，展示了如何通过 HttpEndpoint 接口创建一个 Record：\nRecord record1 = HttpEndpoint.createRecord(\n \"some-http-service\", // The service name\n \"localhost\", // The host\n 8433, // the port\n \"/api\" // the root of the service\n);\n\ndiscovery.publish(record1, ar -> {\n // ...\n});\n\nRecord record2 = HttpEndpoint.createRecord(\n \"some-other-name\", // the service name\n true, // whether or not the service requires HTTPs\n \"localhost\", // The host\n 8433, // the port\n \"/api\", // the root of the service\n new JsonObject().put(\"some-metadata\", \"some value\")\n);\n\n当你在容器或云上部署你的服务时，可能你不能确定公开的IP地址和端口。所以，服务的发布必须通过其他拥有这些信息的实体来进行，这通常是一个桥接对象（bridge）。\n调用HTTP Endpoint服务\n一旦一个HTTP Endpoint服务发布好了，服务消费者就可以获取到这个服务。对应的服务对象是一个 HttpClient 实例，并且已经配置好了host和port参数。\ndiscovery.getRecord(new JsonObject().put(\"name\", \"some-http-service\"), ar -> {\n if (ar.succeeded() && ar.result() != null) {\n // Retrieve the service reference\n ServiceReference reference = discovery.getReference(ar.result());\n // Retrieve the service object\n HttpClient client = reference.getAs(HttpClient.class);\n\n // You need to path the complete path\n client.getNow(\"/api/persons\", response -> {\n\n // ...\n\n // Dont' forget to release the service\n reference.release();\n\n });\n }\n});\n\n你也可以使用 HttpEndpoint.getClient 这个方法，一步就完成服务查找和服务获取：\nHttpEndpoint.getClient(discovery, new JsonObject().put(\"name\", \"some-http-service\"), ar -> {\n if (ar.succeeded()) {\n HttpClient client = ar.result();\n\n // You need to path the complete path\n client.getNow(\"/api/persons\", response -> {\n\n // ...\n\n // Dont' forget to release the service\n ServiceDiscovery.releaseServiceObject(discovery, client);\n\n });\n }\n});\n\n在第二种写法中，服务对象的释放是通过 ServiceDiscovery.releaseServiceObject 这个方法完成的，因此在这种情况下你是不需要持有一个服务引用的。\n从Vert.x 3.4.0开始，Vert.x提供了另一种更高层次封装、更方便使用的HTTP客户端 — WebClient。你可以通过如下方式来获取一个 WebClient 实例：\ndiscovery.getRecord(new JsonObject().put(\"name\", \"some-http-service\"), ar -> {\n if (ar.succeeded() && ar.result() != null) {\n // Retrieve the service reference\n ServiceReference reference = discovery.getReference(ar.result());\n // Retrieve the service object\n WebClient client = reference.getAs(WebClient.class);\n\n // You need to path the complete path\n client.get(\"/api/persons\").send(\n response -> {\n\n // ...\n\n // Dont' forget to release the service\n reference.release();\n\n });\n }\n});\n\n另外一种写法，通过对应的服务类型接口获取的方式：\nHttpEndpoint.getWebClient(discovery, new JsonObject().put(\"name\", \"some-http-service\"), ar -> {\n if (ar.succeeded()) {\n WebClient client = ar.result();\n\n // You need to path the complete path\n client.get(\"/api/persons\")\n .send(response -> {\n\n // ...\n\n // Dont' forget to release the service\n ServiceDiscovery.releaseServiceObject(discovery, client);\n\n });\n }\n});\n\nEvent Bus 服务\nEvent Bus 服务是一种服务代理，是基于Event Bus实现的一种异步RPC服务。当从一个Event Bus服务中获取一个服务对象时，你实际上得到的某个服务类的服务代理。你也可以使用 EventBusService 接口的辅助方法来获得服务代理。\n注意服务代理（服务实现和服务接口）都需要用Java语言开发。\n发布Event Bus 服务\n要发布一个Event Bus服务，你需要创建一个 Record 对象：\nRecord record = EventBusService.createRecord(\n \"some-eventbus-service\", // The service name\n \"address\", // the service address,\n \"examples.MyService\", // the service interface as string\n new JsonObject()\n .put(\"some-metadata\", \"some value\")\n);\n\ndiscovery.publish(record, ar -> {\n // ...\n});\n\n你也可以直接传递服务接口类：\nRecord record = EventBusService.createRecord(\n\"some-eventbus-service\", // The service name\n\"address\", // the service address,\nMyService.class // the service interface\n);\n\ndiscovery.publish(record, ar -> {\n// ...\n});\n\n调用 Event Bus 服务\n要调用（消费）Event Bus服务，你可以通过先获取到服务记录然后获取服务引用的方式，也可以直接通过 EventBusService 接口，将两步合并成一次方法调用。\n当使用服务引用的方式，你需要如下方式：\ndiscovery.getRecord(new JsonObject().put(\"name\", \"some-eventbus-service\"), ar -> {\n if (ar.succeeded() && ar.result() != null) {\n // Retrieve the service reference\n ServiceReference reference = discovery.getReference(ar.result());\n // Retrieve the service object\n MyService service = reference.getAs(MyService.class);\n\n // Dont' forget to release the service\n reference.release();\n }\n});\n\n当使用 EventBusService 接口时，你可以通过如下方式获得代理对象：\nEventBusService.getProxy(discovery, MyService.class, ar -> {\n if (ar.succeeded()) {\n MyService service = ar.result();\n\n // 不要忘记释放服务对象！\n ServiceDiscovery.releaseServiceObject(discovery, service);\n }\n});\n\n消息源服务\n消息源服务，就是通过Event Bus发送消息到某个地址的组件。消息源服务的Client是 MessageConsumer。\n消息源服务的location是消息所发送的Event Bus 地址。\n发布消息源服务\n和其他服务类型一样，发布一个消息源服务包含两个步骤：\n\n通过 MessageSource 接口创建一条服务记录\n发布这条服务记录\n\nRecord record = MessageSource.createRecord(\n \"some-message-source-service\", // The service name\n \"some-address\" // The event bus address\n);\n\ndiscovery.publish(record, ar -> {\n // ...\n});\n\nrecord = MessageSource.createRecord(\n \"some-other-message-source-service\", // The service name\n \"some-address\", // The event bus address\n \"examples.MyData\" // The payload type\n);\n\n在第二个 Record 创建时，我们同时指明了消息体（payload）的类型，这不是必须的。\n在Java中，你可以使用 Class 类型的参数：\nRecord record1 = MessageSource.createRecord(\n\"some-message-source-service\", // The service name\n\"some-address\", // The event bus address\nJsonObject.class // The message payload type\n);\n\nRecord record2 = MessageSource.createRecord(\n\"some-other-message-source-service\", // The service name\n\"some-address\", // The event bus address\nJsonObject.class, // The message payload type\nnew JsonObject().put(\"some-metadata\", \"some value\")\n);\n\n消费消息源服务\n在服务消费端，你可以手动获取服务记录和服务引用，也可以使用 MessageSource 接口提供的辅助方法直接获取。\n第一种方式对应的代码示例如下：\ndiscovery.getRecord(new JsonObject().put(\"name\", \"some-message-source-service\"), ar -> {\n if (ar.succeeded() && ar.result() != null) {\n // Retrieve the service reference\n ServiceReference reference = discovery.getReference(ar.result());\n // Retrieve the service object\n MessageConsumer consumer = reference.getAs(MessageConsumer.class);\n\n // Attach a message handler on it\n consumer.handler(message -> {\n // message handler\n JsonObject payload = message.body();\n });\n\n // ...\n // when done\n reference.release();\n }\n});\n\n如果使用 MessageSource 接口，代码如下：\nMessageSource.getConsumer(discovery, new JsonObject().put(\"name\", \"some-message-source-service\"), ar -> {\n if (ar.succeeded()) {\n MessageConsumer consumer = ar.result();\n\n // Attach a message handler on it\n consumer.handler(message -> {\n // message handler\n JsonObject payload = message.body();\n });\n // ...\n\n // Dont' forget to release the service\n ServiceDiscovery.releaseServiceObject(discovery, consumer);\n\n }\n});\n\nJDBC 数据源\n数据源指的是数据库或数据存储。JDBC数据源通过JDBC驱动访问数据库，JDBC数据源服务对象是是 JDBCClient 实例。\n发布 JDBC 数据源服务\n和其他服务类型一样，发布 JDBC 数据源服务共两个步骤：\n\n通过 JDBCDataSource 接口创建服务记录\n发布服务记录\n\nRecord record = JDBCDataSource.createRecord(\n \"some-data-source-service\", // The service name\n new JsonObject().put(\"url\", \"some jdbc url\"), // The location\n new JsonObject().put(\"some-metadata\", \"some-value\") // Some metadata\n);\n\ndiscovery.publish(record, ar -> {\n // ...\n});\n\nJDBC 数据源可以代表各种类型的数据库，而这些数据库的访问方式一般是不同的，服务记录很难有统一结构。在服务记录中，location 由一个简单的JSON对象组成，里面包含访问数据源的各种属性（JDBC URL、用户名、密码等）。这些属性既依赖于数据库，同时也依赖于所使用的连接池。\n消费 JDBC 数据源服务\n如前所述，访问数据源的方式依赖于数据源本身。要创建一个 JDBCClient，你需要同时提供：服务记录位置信息、元数据以及服务消费者提供的JSON对象：\ndiscovery.getRecord(\n new JsonObject().put(\"name\", \"some-data-source-service\"),\n ar -> {\n if (ar.succeeded() && ar.result() != null) {\n // Retrieve the service reference\n ServiceReference reference = discovery.getReferenceWithConfiguration(\n ar.result(), // The record\n new JsonObject().put(\"username\", \"clement\").put(\"password\", \"*****\")); // Some additional metadata\n\n // Retrieve the service object\n JDBCClient client = reference.getAs(JDBCClient.class);\n\n // ...\n\n // when done\n reference.release();\n }\n });\n\n你也可以使用 JDBCDataSource 接口的辅助方法，来查询和获取服务对象：\nJDBCDataSource.getJDBCClient(discovery,\n new JsonObject().put(\"name\", \"some-data-source-service\"),\n new JsonObject().put(\"username\", \"clement\").put(\"password\", \"*****\"), // Some additional metadata\n ar -> {\n if (ar.succeeded()) {\n JDBCClient client = ar.result();\n\n // ...\n\n // Dont' forget to release the service\n ServiceDiscovery.releaseServiceObject(discovery, client);\n\n }\n });\n\nRedis 数据源\nRedis 数据源服务是专门为Redis提供的服务类型，对应服务对象是 RedisClient。\n发布 Redis 数据源服务\n发布一个 Redis 数据源服务共两个步骤：\n\n通过 RedisDataSource 接口创建一条服务记录\n发布这个服务记录\n\nRecord record = RedisDataSource.createRecord(\n \"some-redis-data-source-service\", // The service name\n new JsonObject().put(\"url\", \"localhost\"), // The location\n new JsonObject().put(\"some-metadata\", \"some-value\") // Some metadata\n);\n\ndiscovery.publish(record, ar -> {\n // ...\n});\n\n这里的 location 是一个JSON对象，包含访问Redis数据源的属性（URL、端口等）。\n消费 Redis 数据源服务\n如前所述，访问数据源的方式依赖于数据源本身。要创建一个 RedisClient，你需要同时提供：服务记录位置信息、元数据以及服务消费者提供的JSON对象：\ndiscovery.getRecord(\n new JsonObject().put(\"name\", \"some-redis-data-source-service\"), ar -> {\n if (ar.succeeded() && ar.result() != null) {\n // Retrieve the service reference\n ServiceReference reference = discovery.getReference(ar.result());\n\n // Retrieve the service instance\n RedisClient client = reference.getAs(RedisClient.class);\n\n // ...\n\n // when done\n reference.release();\n }\n });\n\n你也可以利用 RedisDataSource 接口的辅助方法来查询和获取服务对象：\nRedisDataSource.getRedisClient(discovery,\n new JsonObject().put(\"name\", \"some-redis-data-source-service\"),\n ar -> {\n if (ar.succeeded()) {\n RedisClient client = ar.result();\n\n // ...\n\n // Dont' forget to release the service\n ServiceDiscovery.releaseServiceObject(discovery, client);\n\n }\n })\n\nMongo 数据源\nMongo 数据源服务是专门为 MongoDB 提供的一种服务类型，对应的服务对象是 MongoClient。\n发布 Mongo 数据源服务\n发布一个 Mongo 数据源服务需要两步：\n\n通过 MongoDataSource 接口创建一条服务记录\n发布这条服务记录\n\nRecord record = MongoDataSource.createRecord(\n \"some-data-source-service\", // The service name\n new JsonObject().put(\"connection_string\", \"some mongo connection\"), // The location\n new JsonObject().put(\"some-metadata\", \"some-value\") // Some metadata\n);\n\ndiscovery.publish(record, ar -> {\n // ...\n});\n\n其中location是一个JSON对象，包含了访问Mongo数据源的所有属性（URL、端口等）\n消费 Mongo 数据源服务\n如前所述，访问数据源的方式依赖于数据源本身。要创建一个 MongoClient，你需要同时提供：服务记录位置信息、元数据以及服务消费者提供的JSON对象：\ndiscovery.getRecord(\n new JsonObject().put(\"name\", \"some-data-source-service\"),\n ar -> {\n if (ar.succeeded() && ar.result() != null) {\n // Retrieve the service reference\n ServiceReference reference = discovery.getReferenceWithConfiguration(\n ar.result(), // The record\n new JsonObject().put(\"username\", \"clement\").put(\"password\", \"*****\")); // Some additional metadata\n\n // Retrieve the service object\n MongoClient client = reference.get();\n\n // ...\n\n // when done\n reference.release();\n }\n });\n\n你也可以利用 MongoDataSource 接口中的辅助方法来完成服务对象的查找和获取：\nMongoDataSource.getMongoClient(discovery,\n new JsonObject().put(\"name\", \"some-data-source-service\"),\n new JsonObject().put(\"username\", \"clement\").put(\"password\", \"*****\"), // Some additional metadata\n ar -> {\n if (ar.succeeded()) {\n MongoClient client = ar.result();\n\n // ...\n\n // Dont' forget to release the service\n ServiceDiscovery.releaseServiceObject(discovery, client);\n\n }\n });\n\n监听服务的上线与下线\n每当服务发布或者取消发布，都会有相应的事件发送到 vertx.discovery.announce 这个地址。这个地址可以通过ServiceDiscoveryOptions配置。\n收到的Record中有个status字段，用来表示服务的状态：\n\nUP：服务已经可以使用了\nDOWN：服务不再可用\nOUT_OF_SERVICE：服务目前不可用，但是过段时间会继续提供服务。\n\n监听服务的使用\n每当有一个服务引用被绑定或者被释放，都会有相应的事件发送到 vertx.discovery.usage 这个地址。这个地址可以通过ServiceDiscoveryOptions配置。\n通过这个事件，可以监听服务的使用和服务的映射。\n收到的消息是一个包含如下内容的JsonObject对象：\n\n在 record 属性中，包含了服务记录信息\n在 type 属性中记录了事件的类型，类型分为bind和release\n在 id 属性中记录了服务发现实例的ID（服务发现实例的名称或节点ID）\n\n其中 id 可以通过 ServiceDiscoveryOptions 进行配置。默认情况下，在单节点时它的值是localhost，在集群模式时是节点的ID。\n你也可以通过setUsageAddress方法，将事件发送地址设置为null，这样就可以禁用服务使用情况的监听功能了。\n服务发现桥接器\n通过桥接器（bridge），你可以从其他服务发现组件中导入和导出服务，比如Docker，Kubernetes，Consul等。每种类型的桥接器，决定了服务如何导入和导出，并且不一定都是双向的。\n要想自定义桥接器，你可以通过实现 ServiceImporter 接口，然后再使用 registerServiceImporter 方法注册一下。你可以通过第二个参数传递一些可选的配置信息给桥接器。\n当桥接器注册后，start 方法将会被调用，这样你可以对桥接器进行一些配置。当桥接器配置好了，已经准备导入导出初始的服务时，必须 complete 所传递的 Future。如果桥接器的启动方法是阻塞型的，那么就必须使用 executeBlocking 方法进行封装，并且complete所传递的 Future 对象。\n当服务发现实例被关闭的时候，对应的桥接器也一块被关闭了。执行关闭操作的时候，服务发现组件会调用 close 方法以进行资源的释放以及移除导入/导出的服务。这个方法必须调用所传递的 Future 的complete方法，来通知调用者关闭操作已经完成。\n需要提醒的是，在一个集群中，只需要有一个节点注册了服务桥接器，集群中所有成员就都能使用了。\n可用的服务发现桥接器\nVert.x 服务发现组件除了支持桥接器机制以外，还提供了一些现成的桥接器。\nConsul 桥接器\nConsul 桥接器可以将 Consul 中的服务导入到Vert.x的服务发现组件中。\n这个桥接器可以连接 Consul agent（服务器），并且会进行周期性的扫描，来更新服务情况：\n\n新的服务被导入\n维护模式下的服务或已经从 Consul 中移除的服务将会被移除\n\n这个桥接器使用的是 Consul 的HTTP API接口。它不能将服务导出到Consul，并且也不支持服务的修改。\n服务的类型是通过tags推断出来的，如果有一个tag和已知的服务类型一样，那么就使用这种服务类型，如果没有匹配的，那么服务导入后将标记为unknown类型。目前暂时只支持http-endpoint类型。\n桥接器的使用\n要使用该服务发现桥接器，需要将如下的依赖包加入到依赖配置文件中：\n\nMaven（在 pox.xml 文件中）：\n\n\n io.vertx\n vertx-service-discovery-bridge-consul\n 3.4.1\n\n\n\nGradle（在 build.gradle 文件中）：compile 'io.vertx:vertx-service-discovery-bridge-consul:3.4.1'\n\n\n\n然后，在创建服务发现对象的时候，像下面这样注册桥接器：\nServiceDiscovery.create(vertx)\n .registerServiceImporter(new ConsulServiceImporter(),\n new JsonObject()\n .put(\"host\", \"localhost\")\n .put(\"port\", 8500)\n .put(\"scan-period\", 2000));\n\n你可以做一些配置：\n\nhost 属性，配置 agent 的地址，默认是localhost\nport 属性，配置 agent 的端口，默认的端口是 8500\nscan-period 属性，配置扫描的频率，扫描的单位是毫秒（ms），默认是 2000 ms\n\nKubernetes 桥接器\nKubernetes 桥接器可以从Kubernetes（或者 Openshift v3）中导入服务到Vert.x的服务发现组件中。\nKubernetes的所有服务，都将映射为一条 Record。目前桥接器只支持将服务从Kubernetes中导入到Vert.x中（反过来不行）。\nKubernetes中的服务，在导入到Vert.x后都会创建对应的服务记录（Record）。服务类型是通过 service.type.lable 推断出来的。如果该属性没有设置，那么服务类型被设置为unknown。目前暂时只支持 http-endpoint 服务类型。\n桥接器的使用\n要使用该服务发现桥接器，需要将如下的依赖包加入到依赖配置文件中：\n\nMaven（在 pox.xml 文件中）：\n\n\n io.vertx\n vertx-service-discovery-bridge-kubernetes\n 3.4.1\n\n\n\nGradle（在 build.gradle 文件中）：compile 'io.vertx:vertx-service-discovery-bridge-kubernetes:3.4.1'\n\n\n\n桥接器的配置\n桥接器的配置项有：\n\nOAuth token（默认是使用/var/run/secrets/kubernetes.io/serviceaccount/token中的内容）\n服务搜索的命名空间（默认是default）\n\n请注意，应用程序必须能够访问 Kubernetes 并且能够读取所选择的命名空间。\n服务记录的映射\n服务记录按照如下的步骤进行创建：\n\n从 service.type 中推断出服务类型；如果没有设置，那么服务类型被设置为unknown\n服务记录的名称就是服务的名称\n服务的标签（label）都被映射为服务记录的元数据\n此外还会加上：kubernetes.uuid, kubernetes.namespace, kubernetes.name\nlocation信息将从服务的第一个端口推断出来\n\n对于 HTTP 端点，如果服务带有ssl标签的话，那么服务记录的ssl(https)属性将被设置为true。\n动态性\nKubernetes 桥接器将会在启动(start)的时候导入所有的服务，在停止(stop)的时候移除所有的服务。在运行期间，它将监听 Kubernetes 的服务，并且动态地导入新加入的服务，移除被删除的服务。\nDocker Links 桥接器\nDocker Links 桥接器可以从 Docker Links 中导入服务到 Vert.x 的服务发现组件中。\n当你将一个Docker容器与另外一个Docker容器链接在一起(link)的时候，Docker将会注入一组环境变量。该桥接器将分析这些环境变量，并且针对每个链接(link)，生成一个服务记录。服务记录的类型从service.type.lable属性中推断；如果没有设置，那么服务类型将被设置为unknown。目前暂时只支持 http-endpoint 服务类型。\n由于Docker容器只在启动的时候创建链接，所以这个桥接器只会在启动的时候导入服务记录，然后此后就都不改变了。\n桥接器的使用\n要使用该服务发现桥接器，需要将如下的依赖包加入到依赖配置文件中：\n\nMaven（在 pox.xml 文件中）：\n\n\n io.vertx\n vertx-service-discovery-bridge-docker-links\n 3.4.1\n\n\n\nGradle（在 build.gradle 文件中）：compile 'io.vertx:vertx-service-discovery-bridge-docker-links:3.4.1'\n\n\n\n然后，在创建服务发现对象的时候，像下面这样注册桥接器：\nServiceDiscovery.create(vertx)\n .registerServiceImporter(new DockerLinksServiceImporter(), new JsonObject());\n\n这种桥接器不需要任何进一步的配置。\n其他存储后端\nVert.x服务发现框架还提供了一些现成的后端存储机制支持。\nRedis 存储后端\n服务发现组件通过实现 ServiceDiscoveryBackend SPI提供了一种可插拔的存储后端扩展机制。\nVert.x Service Discovery Redis Backend组件是基于Redis的后端存储实现。\n使用 Redis 存储后端\n要使用 Redis 存储后端，需要将如下的依赖包加入到依赖配置文件中：\n\nMaven（在 pom.xml 文件中）：\n\n\n io.vertx\n vertx-service-discovery-backend-redis\n 3.4.1\n\n\n\nGradle（在 build.gradle 文件中）：compile 'io.vertx:vertx-service-discovery-backend-redis:3.4.1'\n\n\n\n需要注意的是，你只能在 classpath 中指定一个SPI的实现；如果没有指定，那么将使用默认的存储后端。\n配置\nRedis存储后端是基于 Vert.x Redis Client 实现的，所以配置内容和 RedisClient 的配置内容一致。\n下面是一个示例：\nServiceDiscovery.create(vertx, new ServiceDiscoveryOptions()\n .setBackendConfiguration(\n new JsonObject()\n .put(\"host\", \"127.0.0.1\")\n .put(\"key\", \"records\")\n ));\n\n\n\n原文档最后更新于 2017-03-15 15:54:14 CET\n\n"},"microservices/CircuitBreaker.html":{"url":"microservices/CircuitBreaker.html","title":"Vert.x Circuit Breaker","keywords":"","body":"Vert.x Circuit Breaker\n\n原文档\n组件源码\n组件示例\n\n中英文对照表\n\nCircuit Breaker：熔断器\nmetric：指标\n\n组件介绍\nVert.x Circuit Breaker是 熔断器模式 的Vert.x实现。\n熔断器用来追踪故障次数，当失败次数达到阈值时触发熔断，并且可选择性提供失败回调。\n熔断器支持以下的故障：\n\n使用 Future 时失败\n运行时抛出异常\n没有完成的 Future(超时)\n\n熔断器要旨是保护 Vert.x 的 非阻塞 和 异步 的行为，以便受益于Vert.x 执行模型。\n使用 Vert.x 熔断器\n要使用 Vert.x 熔断器，只需要在依赖中增加以下代码片段：\n\nMaven (在 pom.xml 文件中): \n\n\n io.vertx\n vertx-circuit-breaker\n 3.4.1\n\n\n\nGradle (在 build.gradle 文件中):\n\ncompile 'io.vertx:vertx-circuit-breaker:3.4.1'\n\n使用熔断器\n为了使用熔断器我们需要以下的步骤： \n\n创建一个熔断器，并配置成你所需要的(超时，最大故障次数)\n使用熔断器执行代码\n\n以下是例子:\nCircuitBreaker breaker = CircuitBreaker.create(\"my-circuit-breaker\", vertx,\n new CircuitBreakerOptions()\n .setMaxFailures(5) // 最大故障次数\n .setTimeout(2000) // 超时时间\n .setFallbackOnFailure(true) // 设置是否失败回调\n .setResetTimeout(10000) // 重置状态超时\n);\n\nbreaker.execute(future -> {\n // 在熔断器中执行的代码\n // 这里的代码可以成功或者失败\n // 如果future在这里被标记为失败，熔断器将自增失败数\n}).setHandler(ar -> {\n // 处理结果\n});\n\n执行块中接收 Future 作为参数，以表示操作和结果的成功或失败。 例如在下面的例子中，对应的结果就是REST调用的输出：\nCircuitBreaker breaker = CircuitBreaker.create(\"my-circuit-breaker\", vertx,\n new CircuitBreakerOptions().setMaxFailures(5).setTimeout(2000)\n);\n\nbreaker.execute(future -> {\n vertx.createHttpClient().getNow(8080, \"localhost\", \"/\", response -> {\n if (response.statusCode() != 200) {\n future.fail(\"HTTP error\");\n } else {\n response\n .exceptionHandler(future::fail)\n .bodyHandler(buffer -> {\n future.complete(buffer.toString());\n });\n }\n });\n}).setHandler(ar -> {\n // 处理结果\n});\n\n操作的结果以下面的方式提供： \n\n调用 execute 方式返回 Future\n调用 executeAndReport 时作为参数提供的 Future\n\n也可以提供一个失败时回调方法(fallback)：\nCircuitBreaker breaker = CircuitBreaker.create(\"my-circuit-breaker\", vertx,\n new CircuitBreakerOptions().setMaxFailures(5).setTimeout(2000)\n);\n\nbreaker.executeWithFallback(\n future -> {\n vertx.createHttpClient().getNow(8080, \"localhost\", \"/\", response -> {\n if (response.statusCode() != 200) {\n future.fail(\"HTTP error\");\n } else {\n response\n .exceptionHandler(future::fail)\n .bodyHandler(buffer -> {\n future.complete(buffer.toString());\n });\n }\n });\n }, v -> {\n // 当熔断器熔断时将调用此处代码\n return \"Hello\";\n })\n .setHandler(ar -> {\n // 处理结果\n });\n\n熔断状态中都会调用失败回调（fallback），或者设置 isFallbackOnFailure，其结果是失败回调函数的输出。失败回调函数将 Throwable 对象作为参数，并返回预期类型的​​对象。\n失败回调可以直接设置在 CircuitBreaker 上：\nCircuitBreaker breaker = CircuitBreaker.create(\"my-circuit-breaker\", vertx,\n new CircuitBreakerOptions().setMaxFailures(5).setTimeout(2000)\n).fallback(v -> {\n // 当熔断器熔断时将调用此处代码\n return \"hello\";\n});\n\nbreaker.execute(\n future -> {\n vertx.createHttpClient().getNow(8080, \"localhost\", \"/\", response -> {\n if (response.statusCode() != 200) {\n future.fail(\"HTTP error\");\n } else {\n response\n .exceptionHandler(future::fail)\n .bodyHandler(buffer -> {\n future.complete(buffer.toString());\n });\n }\n });\n });\n\n可以指定熔断器在生效之前的尝试次数，使用 setMaxRetries。如果将其设置为高于0的值，则您的代码在最终失败之前进行尝试多次执行。如果代码在其中一个重试中成功，则处理程序将得到通知，并且跳过剩余的重试。此配置仅当熔断器未生效时工作。\n回调\n你能够配置熔断生效/关闭时回调。 \nCircuitBreaker breaker = CircuitBreaker.create(\"my-circuit-breaker\", vertx,\n new CircuitBreakerOptions().setMaxFailures(5).setTimeout(2000)\n).openHandler(v -> {\n System.out.println(\"Circuit opened\");\n}).closeHandler(v -> {\n System.out.println(\"Circuit closed\");\n});\n\nbreaker.execute(\n future -> {\n vertx.createHttpClient().getNow(8080, \"localhost\", \"/\", response -> {\n if (response.statusCode() != 200) {\n future.fail(\"HTTP error\");\n } else {\n // 处理结果\n future.complete();\n }\n });\n });\n\n当熔断器决定尝试复位的时候（ half-open 状态），我们也可以注册 halfOpenHandler 的回调从而得到回调通知。\nEvent Bus 通知\n每次熔断器状态发生变化时，会在Event Bus上发布事件。事件发送的地址可以使用 setNotificationAddress 进行配置。如果将 null 传递给此方法，则通知将被禁用。默认情况下，使用的地址是 vertx.circuit-breaker。\n每次事件信息包含以下：\n\nstate: 熔断器的新状态 （OPEN，CLOSED，HALF_OPEN）\nname: 熔断器的名字\nfailures: 故障的数量\nnode: 节点的标志符（如果运行在单节点模式是 local）\n\n半开启状态\n当熔断器在熔断状态中，对其调用会立即失败，不会执行实际操作。经过适当的时间（setResetTimeout 设置），熔断器决定是否恢复状态，此时进入半开启状态（half-open state）。在这种状态下，允许下一次熔断器的调用实际调用如果成功，熔断器将复位并返回到关闭状态，回归正常的模式；但是如果这次调用失败，则熔断器返回到熔断状态，直到下次半开状态。\n将熔断器指标推送到Hystrix Dashboard\nNetflix Hystrix带有一个仪表板（dashboard），用于显示熔断器的当前状态。 Vert.x 熔断器可以发布其指标（metric），以供Hystrix 仪表板使用。 Hystrix 仪表板需要一个发送指标的SSE流，此流由 HystrixMetricHandler 这个 Vert.x Web Handler 提供：\nCircuitBreaker breaker = CircuitBreaker.create(\"my-circuit-breaker\", vertx);\nCircuitBreaker breaker2 = CircuitBreaker.create(\"my-second-circuit-breaker\", vertx);\n\n// 创建 Vert.x Web 路由\nRouter router = Router.router(vertx);\n// 注册指标Handler\nrouter.get(\"/hystrix-metrics\").handler(HystrixMetricHandler.create(vertx));\n\n// 创建HTTP服务器，并分配路由\nvertx.createHttpServer()\n .requestHandler(router::accept)\n .listen(8080);\n\n在Hystrix 仪表板中，配置流网址（stream url），如：http://localhost:8080/metrics。仪表板将使用Vert.x熔断器的指标。\n请注意，这些指标量是由 Vert.x Web Handler 使用 Event Bus 事件通知收集的。如果您不使用默认通知地址，则需要在创建时指定。\n使用 Netflix Hystrix\nHystrix提供了熔断器模式的实现。可以在Vert.x中使用Hystrix提供的熔断器或组合使用。本节介绍在Vert.x应用程序中使用Hystrix的技巧。\n首先，您需要将Hystrix添加到你的依赖中。详细信息请参阅Hystrix页面。然后，您需要使用 Command 隔离“受保护的”调用。你可以这样执行它：\nHystrixCommand someCommand = getSomeCommandInstance();\nString result = someCommand.execute();\n\n但是，命令执行是阻塞的，必须结合 executeBlocking 方法执行，或者在Worker Verticle中调用：\nHystrixCommand someCommand = getSomeCommandInstance();\nvertx.executeBlocking(\n future -> future.complete(someCommand.execute()),\n ar -> {\n // 回到Event Loop线程中\n String result = ar.result();\n }\n);\n\n如果您使用Hystrix的异步支持，请注意，对应的回调函数不会在Vert.x线程中执行，并且必须在执行前保留对上下文的引用（使用 getOrCreateContext )，并且在回调中，执行 runOnContext 函数将当前线程切换回Event Loop线程。如果不这样做的话，您将失去Vert.x并发模型的优势，并且必须自行管理线程同步和执行顺序：\nvertx.runOnContext(v -> {\n Context context = vertx.getOrCreateContext();\n HystrixCommand command = getSomeCommandInstance();\n command.observe().subscribe(result -> {\n context.runOnContext(v2 -> {\n // 回到Vert.x Context下(Event Loop线程或Worker线程)\n String r = result;\n });\n });\n});\n\n\n\n原文档最后更新于 2017-03-15 15:54:14 CET\n\n"},"microservices/Config.html":{"url":"microservices/Config.html","title":"Vert.x Config","keywords":"","body":"Vert.x Config\n\n原文档\n组件源码\n\n中英文对照表\n\nOverloading：重载\nConfiguration Store：配置仓库\n\n组件介绍\nVert.x Config 提供了一种配置 Vert.x 应用的方式。\n它包含：\n\n支持多种配置语法（JSON、properties、YAML（扩展）、HOCON（扩展）等）\n支持多种存储方式（文件、目录、HTTP、Git（扩展）、Redis（扩展）、系统属性、环境变量等）\n支持自定义配置处理顺序和配置重载(overloading)\n支持运行时重新配置(runtime reconfiguration)\n\n概念\n本组件基于如下几个概念：\n\nConfig Retriever 由Vert.x 应用实例化以及使用；它配置了一系列的配置仓库\nConfiguration Store 定义了配置项的数据源和语法（默认是 JSON）\n\n配置文件最终会以 JSON 对象(JsonObject)的形式取出。\n使用 Config Retriever\n要使用 Config Retriever，只需要在依赖中增加以下代码片段：\n\nMaven (在 pom.xml 文件中): \n\n\n io.vertx\n vertx-config\n 3.4.1\n\n\n\nGradle (在 build.gradle 文件中):\n\ncompile 'io.vertx:vertx-config:3.4.1'\n\n一旦完成以上步骤，我们第一步所需要做的就是实例化 ConfigRetriever：\nConfigRetriever retriever = ConfigRetriever.create(vertx);\n\n默认配置下，Config Retriever 会按照以下的顺序进行配置：\n\nVert.x Verticle 中的 config() 函数\n系统配置\n环境变量\n\n你可以通过下列示例自定义配置：\nConfigStoreOptions httpStore = new ConfigStoreOptions()\n .setType(\"http\")\n .setConfig(new JsonObject()\n .put(\"host\", \"localhost\").put(\"port\", 8080).put(\"path\", \"/conf\"));\n\nConfigStoreOptions fileStore = new ConfigStoreOptions()\n .setType(\"file\")\n .setConfig(new JsonObject().put(\"path\", \"my-config.json\"));\n\nConfigStoreOptions sysPropsStore = new ConfigStoreOptions().setType(\"sys\");\n\n\nConfigRetrieverOptions options = new ConfigRetrieverOptions()\n .addStore(httpStore).addStore(fileStore).addStore(sysPropsStore);\n\nConfigRetriever retriever = ConfigRetriever.create(vertx, options);\n\n在后续章节会将更加详细的重载规则和其他可用的配置仓库设置一一展现。\n一旦成功实例化 Config Retriever, 可用如下代码获取配置：\nretriever.getConfig(ar -> {\n if (ar.failed()) {\n // Failed to retrieve the configuration\n } else {\n JsonObject config = ar.result();\n }\n});\n\n重载规则\n明确配置仓库的顺序对于重载极为重要。对于冲突的键名，后面的配置值将替换掉之前的。举个例子，比如我们有两个配置仓库：\n\nA 含有 {a:value, b:1}\nB 含有 {a:value2, c:2}\n\n如果我们配置的顺序是 (A, B)，那我们的配置结果将是：{a:value2, b:1, c:2}。如果我们将配置顺序颠倒为 (B, A)，我们最终得到的结果是：{a:value, b:1, c:2}。\n支持的配置仓库\nVert.x Config 提供了一系列的配置存储支持和格式支持。更多的种类支持以扩展组件的形式提供，当然你也可以实现自己的扩展组件。\n配置的数据结构\n声明每一个数据存储源就必须要指明存储类型（type）。它可以指定格式（format），默认将使用 JSON。\n一些配置仓库需要一些额外的配置项（比如路径）。我们可以通过 setConfig 方法传入一个 JsonObject 对象来进行上述的配置。\n文件\n此配置仓库仅仅从文件中读取配置，支持所有的格式。\nConfigStoreOptions file = new ConfigStoreOptions()\n .setType(\"file\")\n .setFormat(\"properties\")\n .setConfig(new JsonObject().put(\"path\", \"path-to-file.properties\"));\n\n其中 path 参数是必须的。\nJSON\nJSON 配置仓库仅支持通过给定的 JSON 对象（JsonObject）进行配置。\nConfigStoreOptions json = new ConfigStoreOptions()\n .setType(\"json\")\n .setConfig(new JsonObject().put(\"key\", \"value\"));\n\n本配置仓库仅支持 JSON 格式。\n环境变量\n此配置仓库将环境变量中的键值对映射成 JSON 对象传入，作为全局配置。\nConfigStoreOptions json = new ConfigStoreOptions()\n .setType(\"env\");\n\n此配置仓库不支持 format 配置项。\n系统属性\n此配置仓库将系统属性中的键值对映射成 JSON 对象传入，作为全局配置。\nConfigStoreOptions json = new ConfigStoreOptions()\n .setType(\"sys\")\n .setConfig(new JsonObject().put(\"cache\", \"false\"));\n\n此配置仓库不支持 format 配置项。\n您可以对 cache 属性进行配置（默认为 true）。此配置项决定是否在初次获取系统属性时对其进行缓存，并且在后面不会重新加载。\nHTTP\n此配置仓库会通过给定的 HTTP 地址获得配置，可以使用任何支持的格式。\nConfigStoreOptions http = new ConfigStoreOptions()\n .setType(\"http\")\n .setConfig(new JsonObject()\n .put(\"host\", \"localhost\")\n .put(\"port\", 8080)\n .put(\"path\", \"/A\"));\n\n它会创建一个Vert.x HTTP 客户端（HttpClient）来访问配置仓库（请看下面的代码）。你也可以通过配置 host、port 和 path 这些属性来简化这个过程。\nConfigStoreOptions http = new ConfigStoreOptions()\n .setType(\"http\")\n .setConfig(new JsonObject()\n .put(\"defaultHost\", \"localhost\")\n .put(\"defaultPort\", 8080)\n .put(\"ssl\", true)\n .put(\"path\", \"/A\"));\n\nEvent Bus\n此配置仓库会从 Event Bus 中获取配置。这种方式让你可以在本地和分布式组件中分发你的配置。\nConfigStoreOptions eb = new ConfigStoreOptions()\n .setType(\"event-bus\")\n .setConfig(new JsonObject()\n .put(\"address\", \"address-getting-the-conf\")\n );\n\n此配置仓库也支持所有的格式。\n目录\n这种配置仓库非常像 file 配置方式，但是不同的是，file 只读取一个配置文件，而这种方式会从一个目录中读取一批配置文件。\n此方式有两个必要的参数：\n\npath - 文件所在的根结点路径\n至少一个 fileset - 需要读取的文件列表（模式）\n\n每一个 fileset 都包含：pattern（匹配模式），即用于选取文件的Ant风格的匹配模式。此匹配模式使用相对路径确定配置文件位置。format（格式）作为可选的参数（每一个 fileset 都可以使用不同的格式，但是在一个 fileset 内的文件必须是同一种格式）。\nConfigStoreOptions dir = new ConfigStoreOptions()\n .setType(\"directory\")\n .setConfig(new JsonObject().put(\"path\", \"config\")\n .put(\"filesets\", new JsonArray()\n .add(new JsonObject().put(\"pattern\", \"dir/*json\"))\n .add(new JsonObject().put(\"pattern\", \"dir/*.properties\")\n .put(\"format\", \"properties\"))\n ));\n\n监听配置变更\nConfiguration Retriever 会定期地从配置仓库处读取配置。如果读取的结果和当前的配置不一样，那么应用就会重新进行配置，默认情况下，配置的刷新时间是 5 秒钟。\nConfigRetrieverOptions options = new ConfigRetrieverOptions()\n .setScanPeriod(2000)\n .addStore(store1)\n .addStore(store2);\n\nConfigRetriever retriever = ConfigRetriever.create(Vertx.vertx(), options);\nretriever.getConfig(json -> {\n // Initial retrieval of the configuration\n});\n\nretriever.listen(change -> {\n // Previous configuration\n JsonObject previous = change.getPreviousConfiguration();\n // New configuration\n JsonObject conf = change.getNewConfiguration();\n});\n\n检索最近一次获取的配置内容\n可以快速、无需“等待”地获得最近一次获取的配置内容：\nJsonObject last = retriever.getCachedConfig();\n\n使用流的方式读取配置\nConfigRetriever 提供流(Stream)的方式去获取配置。对应的流是 JsonObject 类型的可读流(ReadStream)。你可以注册相应的处理器(Handler)，来获得下面的事件通知：\n\n检索到新的配置\n获取新配置时发生错误\n当 ConfigRetriever 关闭时（endHandler 方法会被调用）\n\nConfigRetrieverOptions options = new ConfigRetrieverOptions()\n .setScanPeriod(2000)\n .addStore(store1)\n .addStore(store2);\n\nConfigRetriever retriever = ConfigRetriever.create(Vertx.vertx(), options);\nretriever.configStream()\n .endHandler(v -> {\n // 关闭时\n })\n .exceptionHandler(t -> {\n // 获取配置发生错误\n })\n .handler(conf -> {\n // 配置内容\n });\n\n使用 Future 方式读取配置\nConfigRetriever 也支持采用 Future 作为返回值的方式获取配置：\nFuture future = ConfigRetriever.getConfigAsFuture(retriever);\nfuture.setHandler(ar -> {\n if (ar.failed()) {\n // Failed to retrieve the configuration\n } else {\n JsonObject config = ar.result();\n }\n});\n\n扩展 Config Retriever\n你可以通过以下SPI对其进行扩展：\n\n实现 ConfigProcessor SPI，用来增加对新格式的支持\n实现 ConfigStoreFactory SPI，用来增加对配置仓库（读取配置的位置）的支持\n\n额外的配置格式\n除了上文所提到的一系列现成的格式支持以外，Vert.x Config 也提供额外的格式支持组件，并可以在你的应用中使用。\nHOCON 配置格式\nHOCON 配置格式组件是对 Vert.x Config 的扩展，并且提供 HOCON) 格式的支持。\n此格式支持 includes, json, properties, macros等。\n使用 HOCON 配置格式\n为了使用 HOCON 配置格式，您需要添加以下依赖：\n\nMaven (在 pom.xml 文件中): \n\n\n io.vertx\n vertx-config-hocon\n 3.4.1\n\n\n io.vertx\n vertx-config\n 3.4.1\n\n\n\nGradle (在 build.gradle 文件中):\n\ncompile 'io.vertx:vertx-config:3.4.1'\ncompile 'io.vertx:vertx-config-hocon:3.4.1'\n\n配置使用 HOCON 格式\n一旦添加完依赖，我们就需要配置 ConfigRetriever 来使用此格式：\nConfigStoreOptions store = new ConfigStoreOptions()\n .setType(\"file\")\n .setFormat(\"hocon\")\n .setConfig(new JsonObject()\n .put(\"path\", \"my-config.conf\")\n );\n\nConfigRetriever retriever = ConfigRetriever.create(vertx,\n new ConfigRetrieverOptions().addStore(store));\n\n你仅仅需要将 format 设置为 hocon。\nYAML 配置格式\nYAML 配置格式组件是对 Vert.x Config 的扩展，并且提供 YAML 格式的支持。\n使用 YAML 配置格式\n为了使用 YAML 配置格式，您需要添加以下依赖：\n\nMaven (在 pom.xml 文件中): \n\n\n io.vertx\n vertx-config-yaml\n 3.4.1\n\n\n io.vertx\n vertx-config\n 3.4.1\n\n\n\nGradle (在 build.gradle 文件中):\n\ncompile 'io.vertx:vertx-config:3.4.1'\ncompile 'io.vertx:vertx-config-yaml:3.4.1'\n\n配置使用 YAML 格式\n一旦添加完依赖，我们就需要配置 ConfigRetriever 来使用此格式：\nConfigStoreOptions store = new ConfigStoreOptions()\n .setType(\"file\")\n .setFormat(\"yaml\")\n .setConfig(new JsonObject()\n .put(\"path\", \"my-config.yaml\")\n );\n\nConfigRetriever retriever = ConfigRetriever.create(vertx,\n new ConfigRetrieverOptions().addStore(store));\n\n你仅仅需要将 format 设置为 yaml。\n额外的配置仓库\n除了上文所提到的一系列现成的配置仓库支持以外，Vert.x Config 也提供额外的配置仓库支持，并可以在你的应用中使用。\nGit 配置仓库\nGit 配置仓库组件是对 Vert.x Config 的扩展，支持从 Git 仓库(repository)中获取配置。\n使用 Git 配置仓库\n为了使用 Git 配置仓库，您需要添加以下依赖：\n\nMaven (在 pom.xml 文件中): \n\n\n io.vertx\n vertx-config-git\n 3.4.1\n\n\n io.vertx\n vertx-config\n 3.4.1\n\n\n\nGradle (在 build.gradle 文件中):\n\ncompile 'io.vertx:vertx-config:3.4.1'\ncompile 'io.vertx:vertx-config-git:3.4.1'\n\n对配置仓库进行配置\n一旦添加完依赖，我们就需要配置 ConfigRetriever 来使用此配置仓库：\nConfigStoreOptions git = new ConfigStoreOptions()\n .setType(\"git\")\n .setConfig(new JsonObject()\n .put(\"url\", \"https://github.com/cescoffier/vertx-config-test.git\")\n .put(\"path\", \"local\")\n .put(\"filesets\",\n new JsonArray().add(new JsonObject().put(\"pattern\", \"*.json\"))));\n\nConfigRetriever retriever = ConfigRetriever.create(vertx,\n new ConfigRetrieverOptions().addStore(git));\n\n此配置仓库需要以下几个参数： \n\n仓库(Git repository)的 url（地址）\n仓库克隆的 path（本地路径）\n至少一个 fileset —— 需要读取的文件列表（模式）（等同于目录配置仓库的配置方式）\n\n你也可以配置 branch(分支，默认为 master)，并且可以指定 remote（远程）仓库名称（默认读取 origin）\n它是如何工作的\n如果本地 path 不存在，那首先将配置的 Git 仓库克隆下来，然后从中读取匹配的文件集合。\n如果本地 path 存在，那首先尝试更新（如果需要切换分支就切换分支）。如果更新失败，那配置读取也会失败。\nVert.x Config会周期性的去检查变更并更新本地仓库。\nKubernetes ConfigMap 配置仓库\nKubernetes ConfigMap 配置仓库组件是对 Vert.x Config 的扩展。它提供了对 Kubernetes ConfigMap 和 Secrets 的支持。\n使用 Kubernetes ConfigMap 配置仓库\n为了使用 Kubernetes ConfigMap 配置仓库，您需要添加以下依赖：\n\nMaven (在 pom.xml 文件中): \n\n\n io.vertx\n vertx-config-kubernetes-configmap\n 3.4.1\n\n\n io.vertx\n vertx-config\n 3.4.1\n\n\n\nGradle (在 build.gradle 文件中):\n\ncompile 'io.vertx:vertx-config:3.4.1'\ncompile 'io.vertx:vertx-config-kubernetes-configmap:3.4.1'\n\n对配置仓库进行配置\n一旦添加完依赖，我们需要配置 ConfigRetriever 来使用此配置仓库：\nConfigStoreOptions store = new ConfigStoreOptions()\n .setType(\"configmap\")\n .setConfig(new JsonObject()\n .put(\"namespace\", \"my-project-namespace\")\n .put(\"name\", \"configmap-name\")\n );\n\nConfigRetriever retriever = ConfigRetriever.create(vertx,\n new ConfigRetrieverOptions().addStore(store));\n\n你需要对配置仓库进行配置，来找到正确的 ConfigMap：\n\nnamespace —— 项目的命名空间，默认是 default。如果环境变量中有 KUBERNETES_NAMESPACE，则会优先使用此值\nname —— ConfigMap 的名称。\n\n如果 ConfigMap 由多个元素部分构成，你可以使用 key 参数确定哪一个才是我们要读取的。另外，应用必须要拥有对 ConfigMap 的读权限。\n为了从 Secret 中读取数据，必须设置 secret 属性为 true：\nConfigStoreOptions store = new ConfigStoreOptions()\n .setType(\"configmap\")\n .setConfig(new JsonObject()\n .put(\"namespace\", \"my-project-namespace\")\n .put(\"name\", \"my-secret\")\n .put(\"secret\", true)\n );\n\nConfigRetriever retriever = ConfigRetriever.create(vertx,\n new ConfigRetrieverOptions().addStore(store));\n\nRedis 配置仓库\nRedis 配置仓库组件是对 Vert.x Config 的扩展，支持从 Redis 服务器中获取配置。\n使用 Redis 配置仓库\n为了使用 Redis 配置仓库，您需要添加以下依赖：\n\nMaven (在 pom.xml 文件中): \n\n\n io.vertx\n vertx-config-redis\n 3.4.1\n\n\n io.vertx\n vertx-config\n 3.4.1\n\n\n\nGradle (在 build.gradle 文件中):\n\ncompile 'io.vertx:vertx-config:3.4.1'\ncompile 'io.vertx:vertx-config-redis:3.4.1'\n\n对配置仓库进行配置\n一旦添加完依赖，我们需要配置 ConfigRetriever 来使用此配置仓库：\nConfigStoreOptions store = new ConfigStoreOptions()\n .setType(\"redis\")\n .setConfig(new JsonObject()\n .put(\"host\", \"localhost\")\n .put(\"port\", 6379)\n .put(\"key\", \"my-configuration\")\n );\n\nConfigRetriever retriever = ConfigRetriever.create(vertx,\n new ConfigRetrieverOptions().addStore(store));\n\n此配置仓库会创建一个 RedisClient 实例。关于此部分的配置可以参考 Vert.x Redis Client 文档。\n除此之外，你可以设置 key 参数用来指示存储配置对应的 field（字段），默认值是 configuration。\n最终创建的 RedisClient 实例将通过 HGETALL 命令来检索配置。\nZooKeeper 配置仓库\nZooKeeper 配置仓库组件是对 Vert.x Config 的扩展，支持从 ZooKeeper 服务器中获得配置。\n此组件底层使用 Apache Curator 作为访问 ZooKeeper 的客户端。\n使用 ZooKeeper 配置仓库\n为了使用 ZooKeeper 配置仓库，您需要添加以下依赖：\n\nMaven (在 pom.xml 文件中): \n\n\n io.vertx\n vertx-config-zookeeper\n 3.4.1\n\n\n io.vertx\n vertx-config\n 3.4.1\n\n\n\nGradle (在 build.gradle 文件中):\n\ncompile 'io.vertx:vertx-config:3.4.1'\ncompile 'io.vertx:vertx-config-zookeeper:3.4.1'\n\n对配置仓库进行配置\n一旦添加完依赖，我们需要配置 ConfigRetriever 来使用此配置仓库：\nConfigStoreOptions store = new ConfigStoreOptions()\n .setType(\"zookeeper\")\n .setConfig(new JsonObject()\n .put(\"connection\", \"localhost:2181\")\n .put(\"path\", \"/path/to/my/conf\")\n );\n\nConfigRetriever retriever = ConfigRetriever.create(vertx,\n new ConfigRetrieverOptions().addStore(store));\n\n使用此配置仓库通常需要配置 Apache Curator 客户端以及存储我们配置内容的 ZNode 路径（path）。此节点的数据格式可以是 JSON 或者其它任意支持的类型。\n此配置仓库需要传入一系列参数：configuration 属性包含连接 ZooKeeper 服务器的地址和包含我们所配置的节点 path 路径。\n额外可以配置的有：\n\nmaxRetries：尝试重新连接的次数，默认是 3\nbaseSleepTimeBetweenRetries： 在每一次重新尝试连接的间隔（Exponential Backoff 策略），默认是 1000 ms\n\nSpring Config Server 配置仓库\nSpring Config Server 配置仓库组件是对 Vert.x Config 的扩展，支持从 Spring Config Server 中获得配置。\n使用 Spring Config Server 配置仓库\n为了使用 Spring Config Server 配置仓库，您需要添加以下依赖：\n\nMaven (在 pom.xml 文件中): \n\n\n io.vertx\n vertx-config-spring-config-server\n 3.4.1\n\n\n io.vertx\n vertx-config\n 3.4.1\n\n\n\nGradle (在 build.gradle 文件中):\n\ncompile 'io.vertx:vertx-config:3.4.1'\ncompile 'io.vertx:vertx-config-spring-config-server:3.4.1'\n\n对配置仓库进行配置\n一旦添加完依赖，我们需要配置 ConfigRetriever 来使用此配置仓库。\nConfigStoreOptions store = new ConfigStoreOptions()\n .setType(\"spring-config-server\")\n .setConfig(new JsonObject().put(\"url\", \"http://localhost:8888/foo/development\"));\n\nConfigRetriever retriever = ConfigRetriever.create(vertx,\n new ConfigRetrieverOptions().addStore(store));\n\n以下的参数可供配置：\n\nurl: 读取配置的 url（必填）\ntimeout: 读取配置的超时时间，单位是毫秒，默认为 3000 ms\nuser: 用户（默认无权限）\npassword: 密码\nhttpClientConfiguration: 底层所使用的 HTTP 客户端的配置\n\n\n\n原文档最后更新于 2017-03-15 15:54:14 CET\n\n"},"devops/Devops.html":{"url":"devops/Devops.html","title":"Devops","keywords":"","body":"Vert.x Devops\n"},"devops/MetricsUsingDropwizard.html":{"url":"devops/MetricsUsingDropwizard.html","title":"Metrics Using Dropwizard","keywords":"","body":"Vert.x Metrics Using Dropwizard\n"},"devops/MetricsUsingHawkular.html":{"url":"devops/MetricsUsingHawkular.html","title":"Metrics Using Hawkular","keywords":"","body":"Vert.x Metrics Using Hawkular\n"},"devops/Shell.html":{"url":"devops/Shell.html","title":"Shell","keywords":"","body":"Vert.x Shell\n"},"devops/Docker.html":{"url":"devops/Docker.html","title":"Docker","keywords":"","body":"Vert.x Docker\n"},"devops/StackManager.html":{"url":"devops/StackManager.html","title":"Stack Manager","keywords":"","body":"Vert.x Stack Manager\n"},"testing/Testing.html":{"url":"testing/Testing.html","title":"Testing","keywords":"","body":"Vert.x Testing\n"},"clustering/Clustering.html":{"url":"clustering/Clustering.html","title":"Clustering","keywords":"","body":"Vert.x Clustering\n在 Vert.x 中，集群化与高可用均是开箱即用的。Vert.x 通过可插拔的集群管理器（cluster manager）来实现集群管理。在 Vert.x 中，采用 Hazelcast 作为默认的集群管理器。\n集群管理器\n集群管理器的介绍见 Vert.x Core 文档手册中的相关章节。\n集群管理器实现\n目前 Vert.x 提供了四种集群管理器实现：\n\nHazelcast（默认实现）\n文档手册\n组件源码\n\n\nInfinispan（预览版）\n文档手册\n组件源码\n\n\nApache Ignite\n文档手册\n组件源码\n\n\nApache Zookeeper（预览版）\n文档手册\n组件源码\n\n\n\n"},"clustering/Hazelcast.html":{"url":"clustering/Hazelcast.html","title":"Hazelcast","keywords":"","body":"Hazelcast Cluster Manager\n\n翻译：Ranger Tsao，校对 宋子豪、赵亮\n\nHazelcastClusterManager 是基于 Hazelcast 实现 ,是Vert.x 中集群管理器中的默认实现。由于 Vert.x 集群管理的可插拔性，也可轻易切换至其它的集群管理器。\n\nMaven(pom.xml)\n\n\n io.vertx\n vertx-hazelcast\n 3.4.1\n\n\n\nGradle(build.gradle)\n\ncompile 'io.vertx:vertx-hazelcast:3.4.1'\n\nVert.x 集群管理器包含一下几个功能：\n\n发现并管理集群中的节点\n管理集群端的主题订阅清单（这样就可以轻松得知集群中的那些节点订阅了那些 EventBus 地址）\n分布式 Map 支持\n分布式锁\n分布式计数器\n\n注意事项\nVert.x 集群器并不处理节点之间的通信，在 Vert.x 中节点中的通信是直接由 TCP 链接处理的。\n使用 Hazelcast cluster manager\n如果通过命令行来使用 Vert.x，对应集群管理器 jar 包( vertx-hazelcast-${version} )应该在 Vert.x 中安装包中。\n如果在 Maven 或者 Gradle 工程中使用 Vert.x ，只需要在工程依赖中加上相应的 ClusterManager 实现依赖：io.vertx:vertx-hazelcast:${version}。\n如果 vertx-hazelcast-${version} 在 classpath 中，Vert.x将自动检测到，并将其作为集群管理。需要注意的是，要确保 Vert.x 的 classpath 中没有其它的 ClusterManager 实现 jar 包。\n当然在内嵌 Vert.x 时，通过编程的方式创建 Vert.x 集群模式实例，调用 setClusterManager 方法显式指定集群管理器。\nClusterManager mgr = new HazelcastClusterManager();//创建ClusterManger对象\n\nVertxOptions options = new VertxOptions().setClusterManager(mgr);//设置到Vertx启动参数中\n\nVertx.clusteredVertx(options, res -> {\n if (res.succeeded()) {\n Vertx vertx = res.result();\n } else {\n // failed!\n }\n});\n\n配置 Hazelcast cluster manager\n通常情况下，集群管理器的相关配置是由打包的jar中的默认配置文件 default-cluster.xml 决定的。\n\ndefault-cluster.xml 还是下面需要提到的 cluster.xml 必须是一个 Hazelcast 配置文件，在 Hazelcast 的官方网站，可以找到具体的配置描述。\n\n如果要覆盖此配置，可以在 classpath 中添加一个 cluster.xml 文件。如果想在 fat jar 中内嵌 cluster.xml ，此文件必须在 fat jar 的根目录中。如果此文件是一个外部文件，则必须将其添加至 classpath 中。举个例子：\n# cluster.xml 在当前路径中\njava -jar ... -cp . -cluster\nvertx run MyVerticle -cp . -cluster\n\n# cluster.xml 在 conf 目录中\njava -jar ... -cp conf -cluster\n\n还有一种方式来覆盖默认的配置文件，那就是利用系统配置 vertx.hazelcast.config 来实现：\n# 指定一个外部文件为自定义配置文件\njava -Dvertx.hazelcast.config=./config/my-cluster-config.xml -jar ... -cluster\n\n# 从 classpath 中加载一个文件为自定义配置文件\njava -Dvertx.hazelcast.config=classpath:my/package/config/my-cluster-config.xml -jar ... -cluster\n\n如果 vertx.hazelcast.config 值不为空时，将覆盖 classpath 中所有的 cluster.xml 文件，但是如果加载 vertx.hazelcast.config 失败时，系统将选取 classpath 任意一个 cluster.xml ，甚至直接使用默认配置。\n\n注意：Vert.x 并不支持 -Dhazelcast.config 设置方式，请不要使用。\n\n同时也可以通过编程的形式达到配置的目的：\nConfig hazelcastConfig = new Config(); //创建hazelcast配置\n\n// 设置相关的hazlcast配置，在这里省略掉，不再赘述\n\nClusterManager mgr = new HazelcastClusterManager(hazelcastConfig);\n\nVertxOptions options = new VertxOptions().setClusterManager(mgr);\n\nVertx.clusteredVertx(options, res -> {\n if (res.succeeded()) {\n Vertx vertx = res.result();\n } else {\n // failed!\n }\n});\n\nHazelcast支持多种不同的传输协议，包括组播和TCP。默认配置中采用组播传输协议，因此您必须在网络上启用组播才能使其工作。\n具体详细配置，请参阅 Hazelcast 文档。\n使用已存在的 Hazelcast 集群\n可以在集群管理器通过设置 HazelcastInstance 来复用现有集群：\nHazelcastInstance instance = HazelcastClient.newHazelcastClient(\n new ClientConfig()\n .setGroupConfig(new GroupConfig(\"groupname\",\"password\")\n .setNetworkConfig(new ClientNetworkConfig().addAddress(\"hosts\")))); //创建HazelcastClient\nClusterManager mgr = new HazelcastClusterManager(hazelcastInstance);\nVertxOptions options = new VertxOptions().setClusterManager(mgr);\nVertx.clusteredVertx(options, res -> {\n if (res.succeeded()) {\n Vertx vertx = res.result();\n } else {\n // failed!\n }\n});\n\n在这种情况下，Vert.x不是 Hazelcast 群集的所有者，所以不要关闭 Vert.x 时关闭 Hazlecast 集群。\n请注意，自定义 Hazelcast 实例需要配置：\n\n false\n\n\n 1\n\n\n 0\n 0\n NONE\n 0\n 25\n com.hazelcast.map.merge.LatestUpdateMapMergePolicy\n\n\n 1\n\n\n重要提醒\n\n当 Vert.x 集群使用 HA（高可用或故障转移）时，请不要使用 Hazelcast 客户端，因为他们不会通知他们何时离开集群，同时有可能丢失数据，还有可能将集群置于不一致的状态。更多情况请翻阅 Issue 24\n同时要确保 Hazelcast 集群 先于 Vert.x 集群启动，后于 Vert.x 集群关闭。同时需要禁用 shutdownhook。参考上述的 xml 配置，或者通过 系统变量来实现。\n\n使用 Hazelcast async methods\nHazelcast 中的 IMap 、 IAtomicLong 接口(数据结构) 均有异步调用方法，其返回值为 ICompletableFuture，这与 Vert.x 的线程模型完美契合。但是即使这些接口已经存在一段时间，却没有通过 HazelcastInstance 公共 API 暴露。\n默认情况下，HazelcastClusterManager 使用公共 API。当在程序启动时，设置选项-Dvertx.hazelcast.async-api=true ，将代表系统在与 Hazelcast 集群通讯交互时，将采用 Hazelcast async API 。这意味着，Counter 计数操作、AsyncMap的 get put remove 操作都将通过 Vert.x EventLoop 线程来执行，而不是通过 Woker 线程的 vertx.executeBlocking 执行。\n故障排除\n如果默认的组播配置不能正常运行，通常有以下原因：\n机器禁用组播\nMacOS 默认禁用组播。Google一下启用组播。\n使用错误的网络接口\n如果机器上有多个网络接口（也有可能是在运行 VPN 的情况下），那么 Hazelcast 很有可能是使用了错误的网络接口。\n为了确保 Hazelcast 使用正确的网络接口，在配置文件中将 interface 设置为指定IP地址，同时确保 enabled 属性设置为 true 。 例如：\n\n 192.168.1.20\n\n\n当运行集群模式时，需要确保 Vert.x 使用正确的网络接口。当通过命令行模式时，可以设置 cluster-host 参数：\nvertx run myverticle.js -cluster -cluster-host your-ip-address\n\n其中 your-ip-address 必须与 Hazelcast 中的配置保持一致。\n当通过编程模式使用 Vert.x 时，可以调用方法 setClusterHost 来设置参数\n使用VPN\nVPN 软件通常通过创建不支持组播的虚拟网络接口来进行工作。在 VPN 环境中，如果 Hazelcast 与 Vert.x 不正确配置的话，VPN 接口将被选择，而不是正确的接口。\n所以，如果你的软件运行在 VPN 环境中，参考上述章节，设置正确的网络接口。\n组播不可用\n在某些情况下，因为特殊的运行环境，可能无法使用组播。在这种情况下，应该配置其他网络传输，例如在 TCP 上使用 TCP 套接字，在亚马逊云上使用 EC2 。\n有关 Hazelcast 更多传输方式，以及如何配置它们，请咨询 Hazelcast 文档。\n开启日志\n在排除故障时，开启 Hazelcast 日志，将会给予很大的帮助。在 classpath 中添加 vertx-default-jul-logging.properties 文件（默认的JUL记录时），这是一个标准 java.util.loging（JUL） 配置文件。具体配置如下：\ncom.hazelcast.level=INFO\njava.util.logging.ConsoleHandler.level=INFO\njava.util.logging.FileHandler.level=INFO\nHazelcast 日志配置\nHazelcast 的日志默认采用 JDK 实现（参考 JUL）。如果想切换至其他日志库，通过设置 azelcast.logging.type 即可达到目的。\n-Dhazelcast.logging.type=slf4j\n\n详细文档请参考 hazelcast documentation。\n使用其他 Hazelcast 版本\n当前的 Vert.x HazelcastClusterManager 使用的 Hazelcast 版本为 3.6.3 。如果开发者想使用其他版本的 Hazelcast，需要做以下工作：\n\n将目标版本的 Hazelcast 依赖添加至 classpath 中 \n如果是 fat jar 的形式，在构建工具中使用正确的版本\n\n参考代码如下：\n\nMaven(pom.xml)\n\n\n com.hazelcast\n hazelcast\n ENTER_YOUR_VERSION_HERE\n\n\n io.vertx\n vertx-hazelcast\n 3.4.1\n\n\n\nGradle(build.gradle)\n\ndependencies {\n compile (\"io.vertx:vertx-hazelcast:3.4.1\"){\n exclude group: 'com.hazelcast', module: 'hazelcast'\n }\n compile \"com.hazelcast:hazelcast:ENTER_YOUR_VERSION_HERE\"\n}\n\n"},"clustering/Infinispan.html":{"url":"clustering/Infinispan.html","title":"Infinispan","keywords":"","body":"Infinispan Cluster Manager\n\n请注意，当前版本还处于预览版，请慎重在生产环境中使用\n翻译：Ranger Tsao，校对 宋子豪、赵亮\n\nInfinispanClusterManager 是基于 Infinispan 实现。由于 Vert.x 集群管理的可插拔性，也可轻易切换至其它的集群管理器。\nInfinispanClusterManager 在组件 vertx-infinispan 中，通过构建工具可以轻松引入：\n\nMaven(pom.xml)\n\n\n io.vertx\n vertx-infinispan\n 3.4.1\n\n\n\nGradle(gradle.xml)\n\ncompile 'io.vertx:vertx-infinispan:3.4.1'\n\nVert.x 集群管理器包含以下几个功能：\n\n发现并管理集群中的节点\n管理集群端的主题订阅清单（这样就可以轻松得知集群中的那些节点订阅了那些 EventBus 地址）\n分布式 Map 支持\n分布式锁\n分布式计数器\n\n注意事项\nVert.x 集群器并不处理节点之间的通信，在 Vert.x 中节点中的通信是直接由 TCP 链接处理的。\n使用 Infinispan cluster manager\nVert.x 能够从 classpath 路径的 jar 自动检测并使用出 ClusterManager 的实现。不过需要确保在 classpath 没有其他的 ClusterManager 实现。\n通过命令行使用\n确保 vertx-infinispan-3.4.1.jar 在 Vert.x 的安装路径中的 lib 目录下。\n通过 Maven 或 Gradle 构建工具使用\n\nMaven(pom.xml)\n\n\n io.vertx\n vertx-infinispan\n 3.4.1\n\n\n\nGradle(gradle.xml)\n\ncompile 'io.vertx:vertx-infinispan:3.4.1'\n\n编程形式调用\n通过编码的形式，设置集群管理器实现，例子：\nClusterManager mgr = new InfinispanClusterManager();//创建 InfinispanClusterManager\nVertxOptions options = new VertxOptions().setClusterManager(mgr);// 设置集群管理器\nVertx.clusteredVertx(options, res -> {\n if (res.succeeded()) {\n Vertx vertx = res.result();\n } else {\n // failed!\n }\n});\n\n配置 Infinispan cluster manager\n通常情况下，InfinispanClusterManager 使用 jar 包中内嵌的两个文件来配置自身属性：\n\njgroup.xml\ninfinispan.xml\n\n如果要覆盖其中任意一个配置文件，可以在 classpath 中添加对应的文件。如果想在 fat jar 中内嵌相应的配置文件 ，此文件必须在 fat jar 的根目录中。如果此文件是一个外部文件，则必须将其添加至 classpath 中。举个例子：\n# infinispan.xml 在当前路径中\njava -jar ... -cp . -cluster\nvertx run MyVerticle -cp . -cluster\n\n# infinispan.xml 在 conf 目录中\njava -jar ... -cp conf -cluster\n\n还有一种方式来覆盖默认的配置文件，那就是利用系统配置 vertx.infinispan.config 来实现：\n# 指定一个外部文件为自定义配置文件\njava -Dvertx.infinispan.config=./config/my-infinispan.xml -jar ... -cluster\n\n# 从 classpath 中加载一个文件为自定义配置文件\njava -Dvertx.infinispan.config=my/package/config/my-infinispan.xml -jar ... -cluster\n\n如果系统变量 vertx.infinispan.config 值不为空时，将覆盖 classpath 中所有的 infinispan.xml 文件，但是如果加载 vertx.infinispan.config 失败时，系统将选取 classpath 任意一个 infinispan.xml ，甚至直接使用默认配置。\njgroup.xml 与 infinispan.xml 分别是 JGroups 、 Infinispan 配置文件。在对应的官方可以网站可以详细的配置攻略。\n同其他集群管理器，亦可通过编程的形式来进行配置，举例：\nClusterManager mgr = new InfinispanClusterManager(\"custom-infinispan.xml\");//加载自定义配置文件\n\nVertxOptions options = new VertxOptions().setClusterManager(mgr);\n\nVertx.clusteredVertx(options, res -> {\n if (res.succeeded()) {\n Vertx vertx = res.result();\n } else {\n // failed!\n }\n});\n\n使用已有 Infinispan Cache Manager\n开发者可以通过 DefaultCacheManager 来复用已经存在的 cache manager。\nClusterManager mgr = new InfinispanClusterManager(cacheManager);\nVertxOptions options = new VertxOptions().setClusterManager(mgr);\nVertx.clusteredVertx(options, res -> {\n if (res.succeeded()) {\n Vertx vertx = res.result();\n } else {\n // failed!\n }\n});\n\n在这种情况下，Vert.x 并不是 cache manager 的所有者，因此不能在关闭 Vert.x 时，停止 Infinispan 。\n需要注意的是，需要通过如下配置来自定义 Infinispan 实例：\n\n\n \n \n \n\n \n \n \n\n \n \n \n\n\n\n适配 Openshift 3\n为了使 Vert.x 集群能够正常运行在 Openshift 3，需要在配置以及依赖上做一些改动。\n首先，添加 JGroups KUBE_PING 协议依赖：\n\n org.jgroups.kubernetes\n kubernetes\n 0.9.0\n \n (1)\n undertow-core\n io.undertow\n \n \n\n\n\n\n去掉 undertow-core 依赖, 确保 KUBE_PING 能够在 JDK Http server 正常运行\n\n\n然后覆盖默认的 JGroups 配置，确保 KUBE_PING 成为其发现协议，代码如下：\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n\n\nKUBE_PING 默认监听 8080 端口, 因此在构建容器镜像时，需要显式声明：\nEXPOSE 8888\n\n同样需要设置项目命名空间作为发现范围：\nENV OPENSHIFT_KUBE_PING_NAMESPACE my-openshift3-project\n\n然后，通过设置系统变量，确保 JVM 采用 IPv4\n-Djava.net.preferIPv4Stack=true\n\n最后, 所有的设置需要一个服务账号：\noc policy add-role-to-user view system:serviceaccount:$(oc project -q):default -n $(oc project -q)\n\n有关更多配置详情，请参考 Kubernetes discovery protocol for JGroups 。\n适配 Docker Compose\n确认 JVM 在启动时 设置了下面两项配置：\n-Djava.net.preferIPv4Stack=true -Djgroups.tcp.address=NON_LOOPBACK\n通过上述两项系统配置，JGroups 才能正确的挑选出 Docker 创建的虚拟网络接口。\n故障排除\n组播未正常开启\nMacOS 默认禁用组播。Google一下启用组播。\n使用错误的网络接口\n如果机器上有多个网络接口（也有可能是在运行 VPN 的情况下），那么 JGroups 很有可能是使用了错误的网络接口。\n为了确保 JGroups 使用正确的网络接口，在配置文件中将 bind_addr 设置为指定IP地址。 例如：\n\n\n\n另外，如果需要修改打包好的 jgoups.xml 文件，可以通过设置 jgroups.tcp.address 系统变量来达到目的\n-Djgroups.tcp.address=192.168.1.20\n\n当运行集群模式时，需要确保 Vert.x 使用正确的网络接口。当通过命令行模式时，可以设置 cluster-host 参数：\nvertx run myverticle.js -cluster -cluster-host your-ip-address\n\n其中 your-ip-address 必须与 JGroup 中的配置保持一致。\n当通过编程模式使用 Vert.x 时，可以调用方法 setClusterHost 来设置参数\n使用VPN\nVPN软件通常通过创建不支持多播虚拟网络接口来进行工作。如果有一个 VPN 运行，如果 JGroups与 Vert.x 不正确配置的话，VPN接口将被选择，而不是正确的接口。\n所以，如果你运行在 VPN 环境中，参考上述章节，设置正确的网络接口。\n组播被禁用\n在某些情况下，因为特殊的运行环境，可能无法使用组播。在这种情况下，应该配置其他网络传输协议，例如在 TCP 上使用 TCPPING ，在亚马逊云上使用 S3_PING 。\n有关 JGroups 更多传输方式，以及如何配置它们，请咨询 JGroups文档 。\nIPv6 错误\n如果在 IPv6 地址配置有难点，请强制使用 IPv4:\n-Djava.net.preferIPv4Stack=true\n\nInfinispan 日志配置\nInfinispan 依赖与 JBoss Logging 。JBoss Logging 是一个与多种日志框架的桥接器。\nJBoss Logging 能够自动检测使用 classpath 中 JARS 中的日志框架实现。\n如果在 classpath 有多种日志框架，可以通过设置系统变量 org.jboss.logging.provider 来指定具体的实现，例子：\n-Dorg.jboss.logging.provider=log4j2\n\n更多配置信息请参考 JBoss Logging\nJGroups 日志配置\nJGroups 默认采用 JDK Logging 实现。同时也支持 log4j 与 log4j2 ，如果相应的 jar 包 在 classpath 中。\n如果想查阅更详细的信息，或实现自己的日志后端，请参考 JGroups 日志文档\n"},"clustering/ApacheIgnite.html":{"url":"clustering/ApacheIgnite.html","title":"Apache Ignite","keywords":"","body":"Ignite Cluster Manager\n\n翻译：Ranger Tsao，校对 宋子豪、赵亮\n\nIgniteClusterManager 是基于 Apache Ignite 实现。由于 Vert.x 集群管理的可插拔性，也可轻易切换至其它的集群管理器。\nVert.x 集群管理器包含以下几个功能：\n\n发现并管理集群中的节点\n管理集群端的主题订阅清单（这样就可以轻松得知集群中的那些节点订阅了那些 EventBus 地址）\n分布式 Map 支持\n分布式锁\n分布式计数器\n\n注意事项\nVert.x 集群器并不处理节点之间的通信，在 Vert.x 中节点中的通信是直接由 TCP 链接处理的。\n使用 Ignite cluster manager\nVert.x 能够从 classpath 路径的 jar 自动检测并使用出 ClusterManager 的实现。不过需要确保在 classpath 没有其他的 ClusterManager 实现。\n另外 Vert.x 可以通过设置 -Dvertx.clusterManagerFactory=io.vertx.spi.cluster.ignite.IgniteClusterManager 来使用指定的 集群管理器实现。\n通过命令行使用\n确保 vertx-ignite-3.4.1.jar 在 Vert.x 的安装路径中的 lib 目录下。\n通过 Maven 或 Gradle 构建工具使用\n\nMaven(pom.xml)\n\n\n io.vertx\n vertx-ignite\n 3.4.1\n\n\n\nGradle(gradle.xml)\n\ncompile 'io.vertx:vertx-ignite:3.4.1'\n\n编程形式调用\n通过编码的形式，设置集群管理器实现，例子：\nClusterManager clusterManager = new IgniteClusterManager();//创建 Ignite 集群管理器\n\nVertxOptions options = new VertxOptions().setClusterManager(clusterManager);//设置集群管理器实现\nVertx.clusteredVertx(options, res -> {\n if (res.succeeded()) {\n Vertx vertx = res.result();\n } else {\n // failed!\n }\n});\n\n配置 Ignite cluster manager\n使用配置文件\n在 vertx-ignite jar 中内嵌了一个默认配置文件 default-ignite.xml。\n如果需要覆盖此配置文件，需要在 classpath 路径中添加 ignite.xml\ndefault-ignite.xml 与 ignite.xml 必须是一个 Apache Ignite 配置文件，在 Apache Ignite 的官方中文文档中，可以找到具体的配置描述。\n编程配置\nIgniteConfiguration cfg = new IgniteConfiguration();\n// 配置 Ignite ，此处省略配置代码\n\nClusterManager clusterManager = new IgniteClusterManager(cfg);\n\nVertxOptions options = new VertxOptions().setClusterManager(clusterManager);\nVertx.clusteredVertx(options, res -> {\n if (res.succeeded()) {\n Vertx vertx = res.result();\n } else {\n // failed!\n }\n});\n\n自动发现及网络传输配置\n在默认配置中使用 TcpDiscoveryMulticastIpFinder 实现，这网络发现实现，需要开启组播。如果组播被禁用，可以采用 TcpDiscoveryVmIpFinder 替代，前提是在 ignite.xml 事先配置好 IP 地址列表。具体 Ignite 集群配置，可以参考文档 Apache Ignite。\n故障排除\n组播未正常开启\nMacOS 默认禁用组播。Google一下启用组播。\n使用错误的网络接口\n如果机器上有多个网络接口（也有可能是在运行 VPN 的情况下），那么 Ignite 很有可能是使用了错误的网络接口。\n为了确保 Ignite 使用正确的网络接口，在配置文件中将 IgniteConfiguration 设置为指定IP地址。 例如：\n\n \n\n\n当运行集群模式时，需要确保 Vert.x 使用正确的网络接口。当通过命令行模式时，可以设置 cluster-host 参数：\nvertx run myverticle.js -cluster -cluster-host your-ip-address\n\n其中 your-ip-address 必须与 Ignite 中的配置保持一致。\n当通过编程模式使用 Vert.x 时，可以调用方法 setClusterHost 来设置参数\n使用VPN\nVPN 软件通常通过创建不支持组播的虚拟网络接口来进行工作。在 VPN 环境中，如果 Ignite 与 Vert.x 不正确配置的话，VPN 接口将被选择，而不是正确的接口。\n所以，如果你的软件运行在 VPN 环境中，参考上述章节，设置正确的网络接口。\n组播被禁用\n在一些情况下，运行环境中，无法开启组播。在这种情况下，需要配置合适的 IP finder。TCP sockets 发现器 TcpDiscoveryVmIpFinder ，或者 Amazon S3 发现器 TcpDiscoveryS3IpFinder 。\n具体 Ignite 集群配置，可以参考文档 Apache Ignite。\n开启日志\n在排除故障时，开启 Ignite 日志，将会给予很大的帮助。在 classpath 中添加 vertx-default-jul-logging.properties 文件（默认的JUL记录时），这是一个标准 java.util.loging（JUL） 配置文件。具体配置如下：\norg.apache.ignite.level=INFO\njava.util.logging.ConsoleHandler.level=INFO\njava.util.logging.FileHandler.level=INFO\n"},"clustering/ApacheZookeeper.html":{"url":"clustering/ApacheZookeeper.html","title":"Apache Zookeeper","keywords":"","body":"Zookeeper Cluster Manager\n\n请注意，当前版本还处于预览版，请慎重在生产环境中使用\n翻译：Ranger Tsao，校对 宋子豪、赵亮\n\nZookeeperClusterManager 是基于 Apache Zookeeper 实现。由于 Vert.x 集群管理的可插拔性，也可轻易切换至其它的集群管理器。\nZookeeperClusterManager 在组件 vertx-zookeeper 中，通过构建工具可以轻松引入：\n\nMaven(pom.xml)\n\n\n io.vertx\n vertx-zookeeper\n 3.4.1\n\n\n\nGradle(gradle.xml)\n\ncompile 'io.vertx:vertx-zookeeper:3.4.1'\n\nVert.x 集群管理器包含以下几个功能：\n\n发现并管理集群中的节点\n管理集群端的主题订阅清单（这样就可以轻松得知集群中的那些节点订阅了那些 EventBus 地址）\n分布式 Map 支持\n分布式锁\n分布式计数器\n\n注意事项\nVert.x 集群器并不处理节点之间的通信，在 Vert.x 中节点中的通信是直接由 TCP 链接处理的。\n工作原理\nZookeeperClusterManager 使用 Apache Curator 框架而不是原生Zookeeper 客户端，因此需要依赖 guava 、 slf4j 、 zookeeper 等其他第三方 jar 包。\n由于 Zookeeper 采用字典树来存储数据，便可以以 root 路径作为命名空间，在默认的 zookeeper.json 中定义默认的根路径是 io.vertx，同时还有 5 个 子路径用来存储用于管理 Vert.x 集群的相关信息。所有的路径中，只有跟路径可以自定义配置。\n各路径作用为：\n\n/io.vertx/cluster/nodes/ 对应 Vert.x 节点信息\n/io.vertx/asyncMap/$name/ 存储通过接口 io.vertx.core.shareddata.AsyncMap 创建的 AsyncMap 记录\n/io.vertx/asyncMultiMap/$name/ 存储通过接口 io.vertx.core.spi.cluster.AsyncMultiMap 创建的 AsyncMultiMap 记录\n/io.vertx/locks/ 存储分布式锁\n/io.vertx/counters/ 存储分布式计数器\n\n使用 Zookeeper cluster manager\nVert.x 能够从 classpath 路径的 jar 自动检测并使用出 ClusterManager 的实现。不过需要确保在 classpath 没有其他的 ClusterManager 实现。\n通过命令行使用\n确保 vertx-zookeeper-3.4.1.jar 在 Vert.x 的安装路径中的 lib 目录下。\n通过 Maven 或 Gradle 构建工具使用\n\nMaven(pom.xml)\n\n\n io.vertx\n vertx-zookeeper\n 3.4.1\n\n\n\nGradle(gradle.xml)\n\ncompile 'io.vertx:vertx-zookeeper:3.4.1'\n\n编程形式调用\n通过编码的形式，设置集群管理器实现，例子：\nClusterManager mgr = new ZookeeperClusterManager();//创建 ZookeeperClusterManager\nVertxOptions options = new VertxOptions().setClusterManager(mgr);// 设置集群管理器\nVertx.clusteredVertx(options, res -> {\n if (res.succeeded()) {\n Vertx vertx = res.result();\n } else {\n // failed!\n }\n});\n\n配置 Zookeeper cluster manager\n通常情况下，ZookeeperClusterManager 使用 jar 包中内嵌的 default-zookeeper.json 设置相应的配置。\n如果要覆盖此配置，可以在 classpath 中添加一个 zookeeper.json 文件。如果想在 fat jar 中内嵌 zookeeper.json ，此文件必须在 fat jar 的根目录中。如果此文件是一个外部文件，则必须将其添加至 classpath 中。举个例子：\n# zookeeper.json 在当前路径中\njava -jar ... -cp . -cluster\nvertx run MyVerticle -cp . -cluster\n\n# zookeeper.json 在 conf 目录中\njava -jar ... -cp conf -cluster\n\n还有一种方式来覆盖默认的配置文件，那就是利用系统配置 vertx.zookeeper.config 来实现：\n# 指定一个外部文件为自定义配置文件\njava -Dvertx.zookeeper.config=./config/my-zookeeper-conf.json -jar ... -cluster\n\n# 从 classpath 中加载一个文件为自定义配置文件\njava -Dvertx.zookeeper.config=classpath:my/package/config/my-cluster-config.json -jar ... -cluster\n\n如果系统变量 vertx.zookeeper.config 值不为空时，将覆盖 classpath 中所有的 zookeeper.json 文件，但是如果加载 vertx.zookeeper.config 失败时，系统将选取 classpath 任意一个 zookeeper.json ，甚至直接使用默认配置。\n在配置文件 default-zookeeper.json 中已经通过注释的形式，详细说明每个配置项的作用。\n同其他集群管理器，亦可通过编程的形式来进行配置，举例：\nJsonObject zkConfig = new JsonObject();\n// 设置相关配置项\nzkConfig.put(\"zookeeperHosts\", \"127.0.0.1\");// zk host 地址\nzkConfig.put(\"rootPath\", \"io.vertx\");// 根路径\nzkConfig.put(\"retry\", new JsonObject() // 重试策略\n .put(\"initialSleepTime\", 3000)\n .put(\"maxTimes\", 3));\n\nClusterManager mgr = new ZookeeperClusterManager(zkConfig);\nVertxOptions options = new VertxOptions().setClusterManager(mgr);\n\nVertx.clusteredVertx(options, res -> {\n if (res.succeeded()) {\n Vertx vertx = res.result();\n } else {\n // failed!\n }\n});\n\n\n注意：通过系统变量 vertx.zookeeper.hosts 也可以达到配置 zookeeper hosts 的目的。\n\n开启日志\n在排除故障时，开启 Zookeeper 日志，将会给予很大的帮助。在 classpath 中添加 vertx-default-jul-logging.properties 文件（默认的JUL记录时），这是一个标准 java.util.loging（JUL） 配置文件。具体配置如下：\norg.apache.ignite.level=INFO\njava.util.logging.ConsoleHandler.level=INFO\njava.util.logging.FileHandler.level=INFO\nZookeeper 版本\nVert.x 使用 2.1.1 版本的 Curator ，其使用 3.4.8 版本的 Zookeeper，因此不支持 3.5.x 中的最新特性。\n"},"clustering/JGroups.html":{"url":"clustering/JGroups.html","title":"JGroups ","keywords":"","body":"\n从 Vert.x 3.4.0 开始，Vert.x 已经弃用 JGoups 实现，已经由 [infinispan]|(/clustering/Infinispan.md) 。不建议在生产或测试环境中使用\n\nJGroups Cluster Manager\n在构建工具中添加依赖即可：\n\nMaven(pom.xml)\n\n\n io.vertx\n vertx-jgroups\n 3.4.1\n\n\n\nGradle(build.gradle)\n\ncompile 'io.vertx:vertx-jgroups:3.4.1'\n如果通过命令行来使用Vert.x，jar包vertx-jgroups-3.4.1.jar，应该在Vert.x中安装包中。同时也要将jgroups 的jar加到lib目录中。\n如果 vertx-jgroups-3.4.1.jar 在 classpath 中，Vert.x将自动检测到，并将其作为集群管理。需要注意的是，要确保Vert.x的 classpath 中没有其它的 ClusterManager 实现 jar 包。也可以通过设置启动参数: -Dvertx.clusterManagerFactory=io.vertx.spi.cluster.jgroups.JGroupsClusterManager ,来指定集群管理器。\n同 [hazlcast]|(/clustering/Hazelcast.md)，也可以通过编程的方式来实现：\nClusterManager mgr = new JGroupsClusterManager();\nVertxOptions options = new VertxOptions().setClusterManager(mgr);\nVertx.clusteredVertx(options, res -> {\n if (res.succeeded()) {\n Vertx vertx = res.result();\n } else {\n // failed!\n }\n});\n\n配置\nJGroups 的配置文件 default-jgroups.xml 如下：\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\ndefault-jgroups.xml 内嵌在对应jar包中。\n如果要覆盖此配置，可以在 classpath 中添加一个 jgroups.xml 文件。此配置文件必须是一个 JGroups 配置文件，在 JGroups 的官方网站中，可以找到具体的配置描述。\nJGroups支持多种传播方式，包括多播与TCP。默认配置时多播方式，所以需要确保网络是否启用多播。\n故障排除\n如果默认的多播配置不能正常运行，通常有以下原因：\n机器禁用多播\n当使用UDP时，IP多播是必需的，在一些系统中，多播路由需要被添加到路由表中，否则，缺省路由将被使用，请注意，有些系统并不适用路由表中的IP组播路由，只为单播路由\nMac系统例子：\n# Adds a multicast route for 224.0.0.1-231.255.255.254\nsudo route add -net 224.0.0.0/5 127.0.0.1\n\n# Adds a multicast route for 232.0.0.1-239.255.255.254\nsudo route add -net 232.0.0.0/5 192.168.1.3\n错误配置的IPV6\n默认情况下，JVM 使用 IPv6，但路由表配置不正确，或使用 IPv4 解决方法：查看 IPv6 路由或强制使用 IPv4 （-Djava.net.preferIPv4Stack=TRUE）。有关这方面更多的细节可在https://developer.jboss.org/wiki/IPv6。\n使用错误的网络接口\n如果机器上上有多个网络接口（也有可能是在运行VPN的情况下），那么JGroups很有可能是使用了错误的网络接口。\n配置参数 jgroups.bind_addr 用来确定绑定的网络接口, 例如：jgroups.bind_addr=192.168.1.5。\n下面这些配置参数同样有效：\n\nglobal:挑选一个可用的全局地址。如果不能，使用 site_local 地址。\nsite_local:挑选一个本地（非路由）的IP地址，例如从192.168.0.0或10.0.0.0地址\nlink_local:挑选一个链接本地IP地址从169.254.1.0到169.254.254.255\nnon_loopback:挑选任何非回送地址\nloopback:挑选一个环回地址，例如127.0.0.1\nmatch-interface:挑选任何匹配网络接口名的地址，例如匹配接口：ETH\\ *\nmatch-host:挑选任何符合域名规则的地址，例如：linux.*\nmatch-address:挑选任务符合IP地址规则的地址，例如：192.168.*\n\n当运行集群模式时，需要确保Vert.x使用正确的网络接口。当通过命令行模式时，可以设置cluster-host参数：\nvertx run myverticle.js -cluster -cluster-host your-ip-address\n其中 your-ip-address 必须与 JGroups 中的配置保持一致。\n当通过编程模式使用 Vert.x 时，可以调用方法 setClusterHost 来设置参数\n使用VPN\nVPN软件通常通过创建不支持多播虚拟网络接口来进行工作。如果有一个 VPN 运行，如果 JGroups与 Vert.x 不正确配置的话，VPN接口将被选择，而不是正确的接口。\n所以，如果你运行在 VPN 环境中，参考上述章节，设置正确的网络接口。\n多播不可用\n在某些情况下，因为特殊的运行环境，可能无法使用多播。在这种情况下，应该配置其他网络传输，例如在 TCP 上使用 TCP 套接字，在亚马逊云上使用 EC2。\n有关 JGroups 更多传输方式，以及如何配置它们，请咨询JGroups文档。\n开启日志\n在排除故障时，开启JGroups日志，将会给予很大的帮助。在 classpath 中添加 vertx-default-jul-logging.properties 文件（默认的JUL记录时），这是一个标准 java.util.loging（JUL）配置文件。具体配置如下：\norg.jgroups.level=INFO\njava.util.logging.ConsoleHandler.level=INFO\njava.util.logging.FileHandler.level=INFO\n"},"services/Services.html":{"url":"services/Services.html","title":"Services","keywords":"","body":"Vert.x Services\n"},"services/ServiceFactories.html":{"url":"services/ServiceFactories.html","title":"Service Factories","keywords":"","body":"Vert.x Service Factories\n\n打包和部署vert.x的独立服务。\n翻译：赵亮，校对：Ranger Tsao、宋子豪\n\n\nsource使用手册\n\nvert.x service factory 是VerticleFactory 的一个实现，能根据服务id部署一个verticle 。\n注意这个factory与vert.x服务代理没有直接关系，而是一个关于部署单个组件的设施。\n服务名被用于查找JSON描述符文件，JSON描述符文件决定实际被部署的verticle，包含部署参数例如是否作为一个worker来运行等等。\n服务使用者从实际被部署的verticle中解耦是很有用的，并且允许服务提供默认的部署参数和配置。\n\n\n\nService 标识符\n\n服务名字是一个简单的字符串，可以随用户定义，但是建议用户使用域名反转的方式（如java包的定义），这样避免你类路径中的其他服务同名。例如：\n\n推荐命名：com.mycompany.services.clever-db-service,org.widgets.widget-processor\n不推荐但是有效的命名：accounting-service,foo\n\n\n使用\n\n当部署一个服务时使用service:，选择服务verticle工厂。这个verticle可以通过编程的方式部署,例如:\n\nvertx.deployVerticle(\"service:com.mycompany.clever-db-service\", options);\n\n\n也可以通过命令行的方式部署：\n\nvertx run service:com.mycompany-clever-db-service\n\n使其可用\n\nVert.x 服务要实现 VerticleFactory，所以需要你的classpath中确保vertx-service-factory 的jar文件。首先你需要添加verticle factory的maven依赖，如果你使用的是fat jar的方式，你可以用如下依赖：\n\n\nMaven(在你的pom.xml中)\nio.vertx\nvertx-service-factory\n3.2.1\n\n\nGradle(在你的build.gradle文件中)\n\ncompile 'io.vertx:vertx-service-factory:3.2.1'\n你也可以通过编程的方式用registerVerticleFactory方法注册VerticleFactory实例\nvertx.registerVerticleFactory(new ServiceVerticleFactory());\n服务描述符\n\n当部署一个服务时，这个服务工厂首先在classpath中查找这个文件描述符。这个文件描述器就是服务名加.json。\n例如：对于一个服务名：com.mycompany.clever-db-service,那么他的服务描述符文件为：`com.mycompany.clever-db-service.json\n文件描述符文件是一个简单的text文件，内容为有效的JSON对象。JSON中至少必须提供main属性，用于指定实际被部署的verticle，例如：\n\n{\n \"main\": \"com.mycompany.cleverdb.MainVerticle\"\n}\n\n或者\n{\n \"main\": \"app.js\"\n}\n\n或者你甚至可以重定向到一个不同的verticle工厂。例如，这个Maven verticle工厂在运行时动态的从Maven中加载服务：\n{\n \"main\": \"maven:com.mycompany:clever-db:1,2::clever-db-service\"\n}\n\nJSON还能提供options属性，可精确的被映射到DeploymentOptions对象中。\n{\n \"main\": \"com.mycompany.cleverdb.MainVerticle\",\n \"options\": {\n \"config\" : {\n \"foo\": \"bar\"\n },\n \"worker\": true,\n \"isolationGroup\": \"mygroup\"\n }\n}\n\n当使用服务描述符来部署一个服务时，任何属性如worker,isolationGroup等不能被在部署时传递的部署参数所覆盖。\n但是config是一个例外。任意的config在部署时传递的任何配置都将覆盖任何呈现在文件描述符文件中对应的属性。\n"},"services/ServiceProxies.html":{"url":"services/ServiceProxies.html","title":"Service Proxies","keywords":"","body":"Vert.x Service Proxy\n\n原文档\n组件源码\n组件示例\n\n当编写一个Vert.x应用时，你可能想将某个功能在某处隔离开来，并对应用的其它部分提供服务。\n这就是服务代理（service proxy）的目的。它允许你在Event Bus上暴露（expose）一个服务，所以，只要它们在服务发布时清楚服务的地址（address），其他任意的Vert.x组件都可以去调用它。\nVert.x用一个Java接口来描述一个 服务，这个接口包含的方法遵循异步模式。在底层，服务调用是通过调用端向Event Bus发送消息，被调用端收到消息调用服务并且返回结果来实现的。为了使其更容易使用，服务代理组件可以生成一个代理类，你可以直接调用这个代理（通过服务接口中的API）。\n使用Vert.x 服务代理组件\n要使用Vert.x Service Proxy组件，请先加入以下依赖：\n\nMaven(在 pom.xml 文件中)：\n\n\n io.vertx\n vertx-service-proxy\n 3.4.1\n\n\n\nGradle(在 build.gradle 文件中)：\n\ncompile 'io.vertx:vertx-service-proxy:3.4.1'\n\n要实现服务代理（译者注：即生成服务代理类），还需要加入以下依赖：\n\nMaven(在 pom.xml 文件中)：\n\n\n io.vertx\n vertx-codegen\n 3.4.1\n provided\n\n\n\nGradle(在 build.gradle 文件中)：\n\ncompileOnly 'io.vertx:vertx-codegen:3.4.1'\n\n注意服务代理机制依赖于代码生成，所以每次修改服务接口以后都需重新执行构建过程来重新生成代码。\n如果需要生成不同语言的服务代理代码，你需要添加对应的语言支持依赖，比如 Groovy 对应 vertx-lang-groovy。\n服务代理介绍\n让我们先看看服务代理并了解一下为什么它们有用。假设有一个数据库服务暴露在Event Bus上，你需要做以下的事情来调用服务：\nJsonObject message = new JsonObject();\nmessage.put(\"collection\", \"mycollection\")\n .put(\"document\", new JsonObject().put(\"name\", \"tim\"));\nDeliveryOptions options = new DeliveryOptions().addHeader(\"action\", \"save\");\nvertx.eventBus().send(\"database-service-address\", message, options, res2 -> {\n if (res2.succeeded()) {\n // 调用成功\n } else {\n // 调用失败\n }\n});\n\n当我们用这种方式写服务模块的时候，需要写很多重复的模板代码来监听Event Bus中的消息、将其分派到合适的方法并将结果返回到Event Bus。而有了Vert.x 服务代理组件，你就不必再写这么多的模板代码了，只需要专注服务的实现即可。\n你需要将服务接口抽象成一个Java接口，并且加上 @ProxyGen 注解，比如：\n@ProxyGen\npublic interface SomeDatabaseService {\n\n // 一些用于创建服务实例和服务代理实例的工厂方法\n static SomeDatabaseService create(Vertx vertx) {\n return new SomeDatabaseServiceImpl(vertx);\n }\n\n static SomeDatabaseService createProxy(Vertx vertx,\n String address) {\n return new SomeDatabaseServiceVertxEBProxy(vertx, address);\n }\n\n // 实际的服务方法\n void save(String collection, JsonObject document,\n Handler> resultHandler);\n}\n\n有了这个接口，Vert.x会生成所有需要的用于在Event Bus上访问你的服务的模板代码，同时也会生成对应的 调用端代理类（client side proxy），这样你的服务调用端就可以使用一个相当符合习惯的API（译者注：即相同的服务接口）进行服务调用，而不是去手动地向Event Bus发送消息。不管你的服务实际在哪个Event Bus上（可能是在不同的机器上），调用端代理类都能正常工作。\n也就是说，你可以通过以下方式进行服务调用：\nSomeDatabaseService service = SomeDatabaseService.createProxy(vertx,\n \"database-service-address\");\n\n// 使用代理类进行服务调用 —— 向数据库中存储一些数据\nservice.save(\"mycollection\", new JsonObject().put(\"name\", \"tim\"), res2 -> {\n if (res2.succeeded()) {\n // 调用完毕\n }\n});\n\n\n译者注：Vert.x 服务代理组件提供的功能其实就是一种 异步RPC 的功能，其底层实现依赖于Event Bus。\n\n你也可以将多语言API生成功能（@VertxGen注解）与 @ProxyGen 注解相结合，用于生成其它Vert.x支持的JVM语言对应的服务代理 —— 这意味着你可以只用Java编写你的服务一次，就可以在其他语言中以一种习惯的API风格进行服务调用，而不必管服务是在本地还是在Event Bus的别处。想要利用多语言代码生成功能，不要忘记添加对应支持语言的依赖。以下是使用示例：\n@ProxyGen // 生成服务代理\n@VertxGen // 生成其他语言的代码\npublic interface SomeDatabaseService {\n // ...\n}\n\n异步接口\n想要正确地生成服务代理类，服务接口的设计必须遵循一些规则。首先是需要遵循异步模式。如果需要返回结果，对应的方法需要包含一个 Handler> 类型的参数，其中 ResultType 可以是另一种代理类型（所以一个代理类可以作为另一个代理类的工厂）。\n例如：\n@ProxyGen\npublic interface SomeDatabaseService {\n\n // 一些用于创建服务实例和服务代理实例的工厂方法\n\n static SomeDatabaseService create(Vertx vertx) {\n return new SomeDatabaseServiceImpl(vertx);\n }\n\n static SomeDatabaseService createProxy(Vertx vertx, String address) {\n return new SomeDatabaseServiceVertxEBProxy(vertx, address);\n }\n\n // 异步方法，仅通知调用是否完成，不返回结果\n void save(String collection, JsonObject document,\n Handler> result);\n\n // 异步方法，包含JsonObject类型的返回结果\n void findOne(String collection, JsonObject query,\n Handler> result);\n\n // 创建连接\n void createConnection(String shoeSize,\n Handler> resultHandler);\n\n}\n\n以及：\n@ProxyGen\n@VertxGen\npublic interface MyDatabaseConnection {\n\n void insert(JsonObject someData);\n\n void commit(Handler> resultHandler);\n\n @ProxyClose\n void close();\n}\n\n你可以通过声明一个特殊方法，并给其加上 @ProxyClose 注解来注销代理。当此方法被调用时，代理实例被清除。\n更多服务接口的限制会在下面详解。\n代码生成\n被 @ProxyGen 注解的服务接口会触发生成对应的服务辅助类：\n\n服务代理类（service proxy）：一个编译时产生的代理类，用 EventBus 通过消息与服务交互。\n服务处理器类（service handler）： 一个编译时产生的 EventBus 处理器类，用于响应由服务代理发送的事件。\n\n产生的服务代理和处理器的命名是在类名的后面加相关的字段，例如，如果一个服务接口名为 MyService，则对应的处理器类命名为 MyServiceProxyHandler ，对应的服务代理类命名为 MyServiceVertxEBProxy。\n同时Vert.x Codegen也提供数据对象转换器（data object converter）的生成，这使得在服务代理中处理数据实体更加容易。生成的转换器提供了一个接受 JsonObject 的构造函数（译者注：用于将 JsonObject 转换为数据实体类）以及一个 toJson 函数（译者注：用于将数据实体类转换为 JsonObject），这些函数对于在服务代理中处理数据实体来说都是必要的。\nCodegen 注解处理器（annotation processor）会在编译期生成这些类。这是Java编译器的一个特性，所以不需要额外的步骤，只需要去配置一下对应的构建配置：\n只需要在构建配置中加上 io.vertx:vertx-service-proxy:processor 依赖。\n这是一个针对Maven的配置示例：\n\n io.vertx\n vertx-service-proxy\n 3.4.1\n processor\n\n\nGradle中也可以进行配置：\ncompile \"io.vertx:vertx-service-proxy:3.4.1:processor\"\n\nIDE通常会支持注解处理器。\nprocessor classifier会自动通过 META-INF/services 插件机制向jar包中添加服务代理注解处理器的配置。\n如果想要的话，你也可以通过正常的jar来使用注解处理器，但是你需要显式地声明注解处理器。比如在 Maven 中：\n\n maven-compiler-plugin\n \n \n io.vertx.serviceproxy.ServiceProxyProcessor\n \n \n\n\n暴露你的服务\n当你写好服务接口以后，执行构建操作以生成代码。然后你需要将你的服务“注册”到Event Bus上：\nSomeDatabaseService service = new SomeDatabaseServiceImpl();\n// 注册服务\nProxyHelper.registerService(SomeDatabaseService.class, vertx, service,\n \"database-service-address\");\n\n这个过程既可以在 Verticle 中完成，也可以在你的代码的任何其它位置完成。\n一旦注册了，这个服务就可用了。如果你的应用运行在集群上，则集群中节点都可访问。\n如果想注销这个服务，可使用 ProxyHelper.unregisterService 方法：\nSomeDatabaseService service = new SomeDatabaseServiceImpl();\n// 注册服务\nMessageConsumer consumer = ProxyHelper.registerService(SomeDatabaseService.class, vertx, service,\n \"database-service-address\");\n\n// ....\n\n// 注销服务\nProxyHelper.unregisterService(consumer);\n\n代理的创建\n当你的服务发布（expose）以后，你可能想要去调用它。这时，你需要创建一个服务代理，而代理的创建可以利用 ProxyHelper 类：\nSomeDatabaseService service = ProxyHelper.createProxy(SomeDatabaseService.class,\n vertx,\n \"database-service-address\");\n// 也可以指定消息传递的配置\nSomeDatabaseService service2 = ProxyHelper.createProxy(SomeDatabaseService.class,\n vertx,\n \"database-service-address\", options);\n\n其中第二个方法会接受一个 DeliveryOptions 实例，你可以在这里配置消息传递的相关参数（如 timeout）。\n你也可以使用生成的代理类，代理类名是服务接口类名加上 VertxEBProxy。比如你的服务接口类名是 SomeDatabaseService，则代理名就是 SomeDatabaseServiceVertxEBProxy。\n通常情况下，服务接口中会包含一个 createProxy 静态方法用来创建服务代理实例，但这不是必须的：\n@ProxyGen\npublic interface SomeDatabaseService {\n\n // 用于创建服务代理实例的方法\n static SomeDatabaseService createProxy(Vertx vertx, String address) {\n return new SomeDatabaseServiceVertxEBProxy(vertx, address);\n }\n\n // ...\n}\n\n错误处理\n服务方法可能会通过向方法的处理器（Handler）传递一个失败状态的 Future （包含一个 ServiceException 实例）来返回错误。一个 ServiceException 包含一个整形（int）的错误状态码、一条消息和一个可选的 JsonObject 对象（用于包含额外的重要信息）。为了方便起见，我们可以使用 ServiceException.fail 工厂方法来创建一个已经是失败状态并且包装着 ServiceException 实例的 Future。比如：\npublic class SomeDatabaseServiceImpl implements SomeDatabaseService {\nprivate static final BAD_SHOE_SIZE = 42;\nprivate static final CONNECTION_FAILED = 43;\n\n // 创建连接\n void createConnection(String shoeSize, Handler> resultHandler) {\n if (!shoeSize.equals(\"9\")) {\n resultHandler.handle(ServiceException.fail(BAD_SHOE_SIZE, \"The shoe size must be 9!\",\n new JsonObject().put(\"shoeSize\", shoeSize));\n } else {\n doDbConnection(result -> {\n if (result.succeeded()) {\n resultHandler.handle(Future.succeededFuture(result.result()));\n } else {\n resultHandler.handle(ServiceException.fail(CONNECTION_FAILED, result.cause().getMessage()));\n }\n });\n }\n }\n}\n\n服务调用端（client side）可以检查它接收到的失败状态的AsyncResult包含的Throwable对象是否为ServiceException实例。如果是的话，继续检查内部的特定的错误状态码。调用端可以通过这些信息来将业务逻辑错误与系统错误（如服务没有被注册到Event Bus上）区分开，以便确定到底发生了哪一种业务逻辑错误。下面是一个例子：\npublic void foo(String shoeSize, Handler> handler) {\n SomeDatabaseService service = SomeDatabaseService.createProxy(vertx, SERVICE_ADDRESS);\n service.createConnection(\"8\", result -> {\n if (result.succeeded()) {\n // 正常调用\n } else {\n if (result.cause() instanceof ServiceException) {\n ServiceException exc = (ServiceException) result.cause();\n if (exc.failureCode() == SomeDatabaseServiceImpl.BAD_SHOE_SIZE) {\n handler.handle(Future.failedFuture(\n new InvalidInputError(\"You provided a bad shoe size: \" +\n exc.getDebugInfo().getString(\"shoeSize\"))\n ));\n } else if (exc.failureCode() == SomeDatabaseServiceImpl.CONNECTION) {\n handler.handle(Future.failedFuture(\n new ConnectionError(\"Failed to connect to the DB\")));\n }\n } else {\n // 可能是一个系统错误(system error)，如服务代理没有对应的已注册的服务\n handler.handle(Future.failedFuture(\n new SystemError(\"An unexpected error occurred: + \" result.cause().getMessage())\n ));\n }\n }\n }\n}\n\n如果需要的话，服务实现的时候也可以返回ServiceException的子类，只要向Event Bus注册了对应的默认MessageCodec就可以。比如给定下面的ServiceException子类：\nclass ShoeSizeException extends ServiceException {\n public static final BAD_SHOE_SIZE_ERROR = 42;\n\n private final String shoeSize;\n\n public ShoeSizeException(String shoeSize) {\n super(BAD_SHOE_SIZE_ERROR, \"In invalid shoe size was received: \" + shoeSize);\n this.shoeSize = shoeSize;\n }\n\n public String getShoeSize() {\n return extra;\n }\n\n public static AsyncResult fail(int failureCode, String message, String shoeSize) {\n return Future.failedFuture(new MyServiceException(failureCode, message, shoeSize));\n }\n}\n\n只要向Event Bus注册了对应的MessageCodec，服务就可以直接向调用者返回自定义的异常类型：\npublic class SomeDatabaseServiceImpl implements SomeDatabaseService {\n public SomeDataBaseServiceImpl(Vertx vertx) {\n // 在服务端（被调用端）注册MessageCodec。如果运行在单机模式下这就足够了\n // 因为服务代理会共享同一个Vertx实例\n vertx.eventBus().registerDefaultCodec(ShoeSizeException.class,\n new ShoeSizeExceptionMessageCodec());\n }\n\n // 创建连接\n void createConnection(String shoeSize, Handler> resultHandler) {\n if (!shoeSize.equals(\"9\")) {\n resultHandler.handle(ShoeSizeException.fail(shoeSize));\n } else {\n resultHandler.Handle(Future.succeededFuture(myDbConnection));\n }\n }\n}\n\n最后调用端可以检查自定义的异常类型了：\npublic void foo(String shoeSize, Handler> handler) {\n // 如果运行在集群模式下，那么需要将ShoeSizeExceptionMessageCodec注册到当前节点的Event Bus下\n SomeDatabaseService service = SomeDatabaseService.createProxy(vertx, SERVICE_ADDRESS);\n service.createConnection(\"8\", result -> {\n if (result.succeeded()) {\n // 进行方法调用\n } else {\n if (result.cause() instanceof ShoeSizeException) {\n ShoeSizeException exc = (ShoeSizeException) result.cause();\n handler.handle(Future.failedFuture(\n new InvalidInputError(\"You provided a bad shoe size: \" + exc.getShoeSize())));\n } else {\n // 可能是一个系统错误(system error)，如服务代理没有对应的已注册的服务\n handler.handle(Future.failedFuture(\n new SystemError(\"An unexpected error occurred: + \" result.cause().getMessage())\n ));\n }\n }\n }\n}\n\n注意在Vert.x 集群模式下，你需要向集群中每个节点的Event Bus注册对应的自定义异常类型的MessageCodec实例。\n服务接口的约束\n在服务方法中可用的参数类型和返回值类型是有限制的，这样使得转化为Event Bus消息更加容易。下面我们就来看一下：\n方法返回类型\n返回类型必须是以下其中之一：\n\nvoid\n返回此服务实例的引用（this）并标注 @Fluent 注解：\n\n@Fluent\nSomeDatabaseService doSomething();\n\n这是因为方法不能阻塞，并且如果服务是远程的，不可能立即返回结果而不阻塞。\n参数类型和异步返回类型\n令 JSON = JsonObject | JsonArray，PRIMITIVE = 任意原生类型或包装的原生类型。\n参数类型可以是以下类型中任意一个：\n\nJSON\nPRIMITIVE\nList\nList\nSet\nSet\nMap\nMap\n任何枚举类型\n任何被 @DataObject 注解的类\n\n如果需要返回异步结果，可以提供一个 Handler> 类型的参数放到最后。其中类型R可以是：\n\nJSON\nPRIMITIVE\nList\nList\nSet\nSet\n任何枚举类型\n任何被 @DataObject 注解的类\n另一个代理类\n\n重载的方法\n服务接口中不允许有重载的服务方法（即方法名相同，参数列表不同）。\n通过Event Bus调用服务的约定（不使用服务代理的情况下）\n服务代理假定Event Bus中的消息遵循一定的格式，因此能被用于服务的调用。\n当然，如果不愿意的话，你也可以不用服务代理类来访问远程服务。被广泛接受的与服务交互的方式就是直接在Event Bus发送消息。\n为了使服务访问的方式一致，所有的服务都必须遵循以下的消息格式。格式非常简单：\n\n需要有一个名为 action 的 消息头(header)，作为要执行操作的名称\n消息体（message body）应该是一个 JsonObject 对象，里面需要包含操作需要的所有参数。\n\n举个例子，假如我们要去执行一个名为save的操作，此操作接受一个字符串类型的collection参数和一个JsonObject类型的document参数：\nHeaders:\n \"action\": \"save\"\nBody:\n {\n \"collection\": \"mycollection\",\n \"document\": {\n \"name\": \"tim\"\n }\n }\n\n无论有没有用到服务代理，都应该用上面这种方式编写服务，因为这样允许服务交互时保持一致性。\n在上面的例子中，action对应的值应该与服务接口的某个方法名称相对应，而消息体中每个 [key, value] 都要与服务方法中的某个 [arg_name, arg_value]相对应（译者注：key对应参数名，value对应参数值）。\n对于返回值，服务需使用 message.reply(…​) 方法去向调用端发送回一个返回值 —— 这个值可以是Event Bus支持的任何类型。如果需要表示调用失败，可以使用 message.fail(…​) 方法。\n如果你使用Vert.x 服务代理组件的话，生成的代码会自动帮你处理这些问题。\n\n\n原文档最后更新于 2017-03-15 15:54:14 CET\n\n"},"services/SockJSServiceProxies.html":{"url":"services/SockJSServiceProxies.html","title":"SockJS Service Proxies","keywords":"","body":"Vert.x SockJS Service Proxies\n"},"services/MavenServiceFactory.html":{"url":"services/MavenServiceFactory.html","title":"Maven Service Factory","keywords":"","body":"Vert.x Maven Service Factory\n"},"services/HTTPServiceFactory.html":{"url":"services/HTTPServiceFactory.html","title":"HTTP Service Factory","keywords":"","body":"Vert.x HTTP Service Factory\n"},"cloud/Cloud.html":{"url":"cloud/Cloud.html","title":"Cloud","keywords":"","body":"Vert.x Cloud\n"},"cloud/OpenShiftCartridge.html":{"url":"cloud/OpenShiftCartridge.html","title":"OpenShift Cartridge","keywords":"","body":"Vert.x OpenShift Cartridge\n"},"cloud/OpenShiftUsingDIYCartridge.html":{"url":"cloud/OpenShiftUsingDIYCartridge.html","title":"OpenShift Using DIY Cartridge","keywords":"","body":"Vert.x OpenShift Using DIY Cartridge\n"},"PLAN.html":{"url":"PLAN.html","title":"翻译计划","keywords":"","body":"Vert.x 官方文档翻译工作计划\n当前进度\n截至：2017-05-07\n对应版本：Vert.x 3.4.1\n\n[x] Vert.x Core：已翻译校对完成\n[x] Vert.x Web：已翻译校对完成\n[x] Vert.x Web Client：已翻译校对完成\n[x] Vert.x Data Access：已翻译校对完成\n[x] Vert.x Mongo Client：已翻译校对完成\n[x] Vert.x JDBC Client：已翻译校对完成\n[x] Vert.x Common SQL Interface：已翻译校对完成\n[x] Vert.x Redis Client：已翻译校对完成\n[x] Vert.x MySQL/PostgreSQL Client：已翻译校对完成\n\n\n[ ] Vert.x Integration\n[x] Vert.x Kafka Client：已翻译校对完成\n\n\n[x] Vert.x Microservices\n[x] Vert.x Circuit Breaker：已翻译校对完成\n[x] Vert.x Service Discovery：已翻译校对完成\n[x] Vert.x Config：已翻译校对完成\n\n\n[x] Vert.x Reactive：已翻译校对完成\n[x] Vert.x Service Proxy：已重新翻译\n[x] Vert.x Clustering：已翻译校对完成\n[ ] Vert.x Testing\n[ ] Vert.x Unit：计划中\n\n\n[ ] Vert.x IoT：计划中\n\n翻译计划\n2017-06\n待 Vert.x 3.4.2 发布后，更新相应的文档翻译。\n2017-05\n\nVert.x Unit：待认领\nVert.x IoT：lizhenxiang负责翻译，943470549@qq.com负责校对 \nVert.x Clustering：boliza负责翻译，wuziqiang负责校对\n\n本次计划预计五月下旬完成。\n2017-03-28\n\nCore： silentbalanceyh负责翻译，chengenzhao、kkkoko、gy、hxl、Toyer、漓江校对\nWeb： gy负责翻译，chengenzhao校对\nWebClient： chengenzhao负责翻译，zlf负责校对 \nMicroservices： troopson@163.com，me.yan.xia@qq.com负责翻译和校对 \nReactive： cet63负责翻译 \nIoT： lizhenxiang负责翻译，943470549@qq.com负责校对 \ndata access： DaC1989负责翻译，kkkoko校对 \nClustering： boliza负责翻译，wuziqiang负责校对 \n\n本次计划预计五月中旬完成。\n"}}} \ No newline at end of file diff --git a/docs/services/HTTPServiceFactory.html b/docs/services/HTTPServiceFactory.html deleted file mode 100644 index c3e5814..0000000 --- a/docs/services/HTTPServiceFactory.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - HTTP Service Factory · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                          -
                                                                                          - - - - - - - - -
                                                                                          - -
                                                                                          - -
                                                                                          - - - - - - - - -
                                                                                          -
                                                                                          - -
                                                                                          -
                                                                                          - -
                                                                                          - -

                                                                                          Vert.x HTTP Service Factory

                                                                                          - - -
                                                                                          - -
                                                                                          -
                                                                                          -
                                                                                          - -

                                                                                          results matching ""

                                                                                          -
                                                                                            - -
                                                                                            -
                                                                                            - -

                                                                                            No results matching ""

                                                                                            - -
                                                                                            -
                                                                                            -
                                                                                            - -
                                                                                            -
                                                                                            - -
                                                                                            - - - - - - - - - - - - - - -
                                                                                            - - -
                                                                                            - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/services/MavenServiceFactory.html b/docs/services/MavenServiceFactory.html deleted file mode 100644 index e80b51a..0000000 --- a/docs/services/MavenServiceFactory.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - Maven Service Factory · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                            -
                                                                                            - - - - - - - - -
                                                                                            - -
                                                                                            - -
                                                                                            - - - - - - - - -
                                                                                            -
                                                                                            - -
                                                                                            -
                                                                                            - -
                                                                                            - -

                                                                                            Vert.x Maven Service Factory

                                                                                            - - -
                                                                                            - -
                                                                                            -
                                                                                            -
                                                                                            - -

                                                                                            results matching ""

                                                                                            -
                                                                                              - -
                                                                                              -
                                                                                              - -

                                                                                              No results matching ""

                                                                                              - -
                                                                                              -
                                                                                              -
                                                                                              - -
                                                                                              -
                                                                                              - -
                                                                                              - - - - - - - - - - - - - - -
                                                                                              - - -
                                                                                              - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/services/ServiceFactories.html b/docs/services/ServiceFactories.html deleted file mode 100644 index bbaec9e..0000000 --- a/docs/services/ServiceFactories.html +++ /dev/null @@ -1,1142 +0,0 @@ - - - - - - - Service Factories · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                              -
                                                                                              - - - - - - - - -
                                                                                              - -
                                                                                              - -
                                                                                              - - - - - - - - -
                                                                                              -
                                                                                              - -
                                                                                              -
                                                                                              - -
                                                                                              - -

                                                                                              Vert.x Service Factories

                                                                                              -
                                                                                              -

                                                                                              打包和部署vert.x的独立服务。 -翻译：赵亮，校对：Ranger Tsao、宋子豪

                                                                                              -
                                                                                              -
                                                                                                -
                                                                                              • source

                                                                                                使用手册

                                                                                                -
                                                                                                -

                                                                                                vert.x service factory 是VerticleFactory 的一个实现，能根据服务id部署一个verticle 。 -注意这个factory与vert.x服务代理没有直接关系，而是一个关于部署单个组件的设施。 -服务名被用于查找JSON描述符文件，JSON描述符文件决定实际被部署的verticle，包含部署参数例如是否作为一个worker来运行等等。 -服务使用者从实际被部署的verticle中解耦是很有用的，并且允许服务提供默认的部署参数和配置。

                                                                                                -
                                                                                                -
                                                                                                • -
                                                                                              -

                                                                                              Service 标识符

                                                                                              -
                                                                                              -

                                                                                              服务名字是一个简单的字符串，可以随用户定义，但是建议用户使用域名反转的方式（如java包的定义），这样避免你类路径中的其他服务同名。例如：

                                                                                              -
                                                                                                -
                                                                                              • 推荐命名：com.mycompany.services.clever-db-service,org.widgets.widget-processor
                                                                                                • -
                                                                                              • 不推荐但是有效的命名：accounting-service,foo
                                                                                                • -
                                                                                              -
                                                                                              -

                                                                                              使用

                                                                                              -
                                                                                              -

                                                                                              当部署一个服务时使用service:，选择服务verticle工厂。这个verticle可以通过编程的方式部署,例如:

                                                                                              -
                                                                                              -
                                                                                              vertx.deployVerticle("service:com.mycompany.clever-db-service", options);
-
                                                                                              -
                                                                                              -

                                                                                              也可以通过命令行的方式部署：

                                                                                              -
                                                                                              -
                                                                                              vertx run service:com.mycompany-clever-db-service
-
                                                                                              -

                                                                                              使其可用

                                                                                              -
                                                                                              -

                                                                                              Vert.x 服务要实现 VerticleFactory，所以需要你的classpath中确保vertx-service-factory 的jar文件。首先你需要添加verticle factory的maven依赖，如果你使用的是fat jar的方式，你可以用如下依赖：

                                                                                              -
                                                                                              -
                                                                                                -
                                                                                              • Maven(在你的pom.xml中)
                                                                                                <dependency>
-<groupId>io.vertx</groupId>
-<artifactId>vertx-service-factory</artifactId>
-<version>3.2.1</version>
-</dependency>
-
                                                                                                • -
                                                                                              • Gradle(在你的build.gradle文件中)
                                                                                                • -
                                                                                              -
                                                                                              compile 'io.vertx:vertx-service-factory:3.2.1'
-

                                                                                              你也可以通过编程的方式用registerVerticleFactory方法注册VerticleFactory实例

                                                                                              -
                                                                                              vertx.registerVerticleFactory(new ServiceVerticleFactory());
-

                                                                                              服务描述符

                                                                                              -
                                                                                              -

                                                                                              当部署一个服务时，这个服务工厂首先在classpath中查找这个文件描述符。这个文件描述器就是服务名加.json。

                                                                                              -

                                                                                              例如：对于一个服务名：com.mycompany.clever-db-service,那么他的服务描述符文件为：`com.mycompany.clever-db-service.json

                                                                                              -

                                                                                              文件描述符文件是一个简单的text文件，内容为有效的JSON对象。JSON中至少必须提供main属性，用于指定实际被部署的verticle，例如：

                                                                                              -
                                                                                              -
                                                                                              {
- "main": "com.mycompany.cleverdb.MainVerticle"
-}
-
                                                                                              -

                                                                                              或者

                                                                                              -
                                                                                              {
-  "main": "app.js"
-}
-
                                                                                              -

                                                                                              或者你甚至可以重定向到一个不同的verticle工厂。例如，这个Maven verticle工厂在运行时动态的从Maven中加载服务：

                                                                                              -
                                                                                              {
- "main": "maven:com.mycompany:clever-db:1,2::clever-db-service"
-}
-
                                                                                              -

                                                                                              JSON还能提供options属性，可精确的被映射到DeploymentOptions对象中。

                                                                                              -
                                                                                              {
-  "main": "com.mycompany.cleverdb.MainVerticle",
-  "options": {
-    "config" : {
-     "foo": "bar"
-    },
-    "worker": true,
-    "isolationGroup": "mygroup"
-  }
-}
-
                                                                                              -

                                                                                              当使用服务描述符来部署一个服务时，任何属性如worker,isolationGroup等不能被在部署时传递的部署参数所覆盖。 -但是config是一个例外。任意的config在部署时传递的任何配置都将覆盖任何呈现在文件描述符文件中对应的属性。

                                                                                              - - -
                                                                                              - -
                                                                                              -
                                                                                              -
                                                                                              - -

                                                                                              results matching ""

                                                                                              -
                                                                                                - -
                                                                                                -
                                                                                                - -

                                                                                                No results matching ""

                                                                                                - -
                                                                                                -
                                                                                                -
                                                                                                - -
                                                                                                -
                                                                                                - -
                                                                                                - - - - - - - - - - - - - - -
                                                                                                - - -
                                                                                                - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/services/ServiceProxies.html b/docs/services/ServiceProxies.html deleted file mode 100644 index 7945711..0000000 --- a/docs/services/ServiceProxies.html +++ /dev/null @@ -1,1460 +0,0 @@ - - - - - - - Service Proxies · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                                -
                                                                                                - - - - - - - - -
                                                                                                - -
                                                                                                - -
                                                                                                - - - - - - - - -
                                                                                                -
                                                                                                - -
                                                                                                -
                                                                                                - -
                                                                                                - -

                                                                                                Vert.x Service Proxy

                                                                                                - -

                                                                                                当编写一个Vert.x应用时，你可能想将某个功能在某处隔离开来，并对应用的其它部分提供服务。

                                                                                                -

                                                                                                这就是服务代理（service proxy）的目的。它允许你在Event Bus上暴露（expose）一个服务，所以，只要它们在服务发布时清楚服务的地址（address），其他任意的Vert.x组件都可以去调用它。

                                                                                                -

                                                                                                Vert.x用一个Java接口来描述一个 服务，这个接口包含的方法遵循异步模式。在底层，服务调用是通过调用端向Event Bus发送消息，被调用端收到消息调用服务并且返回结果来实现的。为了使其更容易使用，服务代理组件可以生成一个代理类，你可以直接调用这个代理（通过服务接口中的API）。

                                                                                                -

                                                                                                使用Vert.x 服务代理组件

                                                                                                -

                                                                                                要使用Vert.x Service Proxy组件，请先加入以下依赖：

                                                                                                -
                                                                                                  -
                                                                                                • Maven(在 pom.xml 文件中)：
                                                                                                  • -
                                                                                                -
                                                                                                <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-service-proxy</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                                                -
                                                                                                  -
                                                                                                • Gradle(在 build.gradle 文件中)：
                                                                                                  • -
                                                                                                -
                                                                                                compile 'io.vertx:vertx-service-proxy:3.4.1'
-
                                                                                                -

                                                                                                要实现服务代理（译者注：即生成服务代理类），还需要加入以下依赖：

                                                                                                -
                                                                                                  -
                                                                                                • Maven(在 pom.xml 文件中)：
                                                                                                  • -
                                                                                                -
                                                                                                <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-codegen</artifactId>
-  <version>3.4.1</version>
-  <scope>provided</scope>
-</dependency>
-
                                                                                                -
                                                                                                  -
                                                                                                • Gradle(在 build.gradle 文件中)：
                                                                                                  • -
                                                                                                -
                                                                                                compileOnly 'io.vertx:vertx-codegen:3.4.1'
-
                                                                                                -

                                                                                                注意服务代理机制依赖于代码生成，所以每次修改服务接口以后都需重新执行构建过程来重新生成代码。

                                                                                                -

                                                                                                如果需要生成不同语言的服务代理代码，你需要添加对应的语言支持依赖，比如 Groovy 对应 vertx-lang-groovy。

                                                                                                -

                                                                                                服务代理介绍

                                                                                                -

                                                                                                让我们先看看服务代理并了解一下为什么它们有用。假设有一个数据库服务暴露在Event Bus上，你需要做以下的事情来调用服务：

                                                                                                -
                                                                                                JsonObject message = new JsonObject();
-message.put("collection", "mycollection")
-    .put("document", new JsonObject().put("name", "tim"));
-DeliveryOptions options = new DeliveryOptions().addHeader("action", "save");
-vertx.eventBus().send("database-service-address", message, options, res2 -> {
-  if (res2.succeeded()) {
-    // 调用成功
-  } else {
-    // 调用失败
-  }
-});
-
                                                                                                -

                                                                                                当我们用这种方式写服务模块的时候，需要写很多重复的模板代码来监听Event Bus中的消息、将其分派到合适的方法并将结果返回到Event Bus。而有了Vert.x 服务代理组件，你就不必再写这么多的模板代码了，只需要专注服务的实现即可。

                                                                                                -

                                                                                                你需要将服务接口抽象成一个Java接口，并且加上 @ProxyGen 注解，比如：

                                                                                                -
                                                                                                @ProxyGen
-public interface SomeDatabaseService {
-
-  // 一些用于创建服务实例和服务代理实例的工厂方法
-  static SomeDatabaseService create(Vertx vertx) {
-    return new SomeDatabaseServiceImpl(vertx);
-  }
-
-  static SomeDatabaseService createProxy(Vertx vertx,
-    String address) {
-    return new SomeDatabaseServiceVertxEBProxy(vertx, address);
-  }
-
- // 实际的服务方法
- void save(String collection, JsonObject document,
-   Handler<AsyncResult<Void>> resultHandler);
-}
-
                                                                                                -

                                                                                                有了这个接口，Vert.x会生成所有需要的用于在Event Bus上访问你的服务的模板代码，同时也会生成对应的 调用端代理类（client side proxy），这样你的服务调用端就可以使用一个相当符合习惯的API（译者注：即相同的服务接口）进行服务调用，而不是去手动地向Event Bus发送消息。不管你的服务实际在哪个Event Bus上（可能是在不同的机器上），调用端代理类都能正常工作。

                                                                                                -

                                                                                                也就是说，你可以通过以下方式进行服务调用：

                                                                                                -
                                                                                                SomeDatabaseService service = SomeDatabaseService.createProxy(vertx,
-    "database-service-address");
-
-// 使用代理类进行服务调用 —— 向数据库中存储一些数据
-service.save("mycollection", new JsonObject().put("name", "tim"), res2 -> {
-  if (res2.succeeded()) {
-    // 调用完毕
-  }
-});
-
                                                                                                -
                                                                                                -

                                                                                                译者注：Vert.x 服务代理组件提供的功能其实就是一种 异步RPC 的功能，其底层实现依赖于Event Bus。

                                                                                                -
                                                                                                -

                                                                                                你也可以将多语言API生成功能（@VertxGen注解）与 @ProxyGen 注解相结合，用于生成其它Vert.x支持的JVM语言对应的服务代理 —— 这意味着你可以只用Java编写你的服务一次，就可以在其他语言中以一种习惯的API风格进行服务调用，而不必管服务是在本地还是在Event Bus的别处。想要利用多语言代码生成功能，不要忘记添加对应支持语言的依赖。以下是使用示例：

                                                                                                -
                                                                                                @ProxyGen // 生成服务代理
-@VertxGen // 生成其他语言的代码
-public interface SomeDatabaseService {
-  // ...
-}
-
                                                                                                -

                                                                                                异步接口

                                                                                                -

                                                                                                想要正确地生成服务代理类，服务接口的设计必须遵循一些规则。首先是需要遵循异步模式。如果需要返回结果，对应的方法需要包含一个 Handler<AsyncResult<ResultType>> 类型的参数，其中 ResultType 可以是另一种代理类型（所以一个代理类可以作为另一个代理类的工厂）。

                                                                                                -

                                                                                                例如：

                                                                                                -
                                                                                                @ProxyGen
-public interface SomeDatabaseService {
-
- // 一些用于创建服务实例和服务代理实例的工厂方法
-
- static SomeDatabaseService create(Vertx vertx) {
-   return new SomeDatabaseServiceImpl(vertx);
- }
-
- static SomeDatabaseService createProxy(Vertx vertx, String address) {
-   return new SomeDatabaseServiceVertxEBProxy(vertx, address);
- }
-
- // 异步方法，仅通知调用是否完成，不返回结果
- void save(String collection, JsonObject document,
-   Handler<AsyncResult<Void>> result);
-
- // 异步方法，包含JsonObject类型的返回结果
- void findOne(String collection, JsonObject query,
-   Handler<AsyncResult<JsonObject>> result);
-
- // 创建连接
- void createConnection(String shoeSize,
-   Handler<AsyncResult<MyDatabaseConnection>> resultHandler);
-
-}
-
                                                                                                -

                                                                                                以及：

                                                                                                -
                                                                                                @ProxyGen
-@VertxGen
-public interface MyDatabaseConnection {
-
- void insert(JsonObject someData);
-
- void commit(Handler<AsyncResult<Void>> resultHandler);
-
- @ProxyClose
- void close();
-}
-
                                                                                                -

                                                                                                你可以通过声明一个特殊方法，并给其加上 @ProxyClose 注解来注销代理。当此方法被调用时，代理实例被清除。

                                                                                                -

                                                                                                更多服务接口的限制会在下面详解。

                                                                                                -

                                                                                                代码生成

                                                                                                -

                                                                                                被 @ProxyGen 注解的服务接口会触发生成对应的服务辅助类：

                                                                                                -
                                                                                                  -
                                                                                                • 服务代理类（service proxy）：一个编译时产生的代理类，用 EventBus 通过消息与服务交互。
                                                                                                  • -
                                                                                                • 服务处理器类（service handler）： 一个编译时产生的 EventBus 处理器类，用于响应由服务代理发送的事件。
                                                                                                  • -
                                                                                                -

                                                                                                产生的服务代理和处理器的命名是在类名的后面加相关的字段，例如，如果一个服务接口名为 MyService，则对应的处理器类命名为 MyServiceProxyHandler ，对应的服务代理类命名为 MyServiceVertxEBProxy。

                                                                                                -

                                                                                                同时Vert.x Codegen也提供数据对象转换器（data object converter）的生成，这使得在服务代理中处理数据实体更加容易。生成的转换器提供了一个接受 JsonObject 的构造函数（译者注：用于将 JsonObject 转换为数据实体类）以及一个 toJson 函数（译者注：用于将数据实体类转换为 JsonObject），这些函数对于在服务代理中处理数据实体来说都是必要的。

                                                                                                -

                                                                                                Codegen 注解处理器（annotation processor）会在编译期生成这些类。这是Java编译器的一个特性，所以不需要额外的步骤，只需要去配置一下对应的构建配置：

                                                                                                -

                                                                                                只需要在构建配置中加上 io.vertx:vertx-service-proxy:processor 依赖。

                                                                                                -

                                                                                                这是一个针对Maven的配置示例：

                                                                                                -
                                                                                                <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-service-proxy</artifactId>
-  <version>3.4.1</version>
-  <classifier>processor</classifier>
-</dependency>
-
                                                                                                -

                                                                                                Gradle中也可以进行配置：

                                                                                                -
                                                                                                compile "io.vertx:vertx-service-proxy:3.4.1:processor"
-
                                                                                                -

                                                                                                IDE通常会支持注解处理器。

                                                                                                -

                                                                                                processor classifier会自动通过 META-INF/services 插件机制向jar包中添加服务代理注解处理器的配置。

                                                                                                -

                                                                                                如果想要的话，你也可以通过正常的jar来使用注解处理器，但是你需要显式地声明注解处理器。比如在 Maven 中：

                                                                                                -
                                                                                                <plugin>
-  <artifactId>maven-compiler-plugin</artifactId>
-  <configuration>
-    <annotationProcessors>
-      <annotationProcessor>io.vertx.serviceproxy.ServiceProxyProcessor</annotationProcessor>
-    </annotationProcessors>
-  </configuration>
-</plugin>
-
                                                                                                -

                                                                                                暴露你的服务

                                                                                                -

                                                                                                当你写好服务接口以后，执行构建操作以生成代码。然后你需要将你的服务“注册”到Event Bus上：

                                                                                                -
                                                                                                SomeDatabaseService service = new SomeDatabaseServiceImpl();
-// 注册服务
-ProxyHelper.registerService(SomeDatabaseService.class, vertx, service,
-    "database-service-address");
-
                                                                                                -

                                                                                                这个过程既可以在 Verticle 中完成，也可以在你的代码的任何其它位置完成。

                                                                                                -

                                                                                                一旦注册了，这个服务就可用了。如果你的应用运行在集群上，则集群中节点都可访问。

                                                                                                -

                                                                                                如果想注销这个服务，可使用 ProxyHelper.unregisterService 方法：

                                                                                                -
                                                                                                SomeDatabaseService service = new SomeDatabaseServiceImpl();
-// 注册服务
-MessageConsumer<JsonObject> consumer = ProxyHelper.registerService(SomeDatabaseService.class, vertx, service,
-    "database-service-address");
-
-// ....
-
-// 注销服务
-ProxyHelper.unregisterService(consumer);
-
                                                                                                -

                                                                                                代理的创建

                                                                                                -

                                                                                                当你的服务发布（expose）以后，你可能想要去调用它。这时，你需要创建一个服务代理，而代理的创建可以利用 ProxyHelper 类：

                                                                                                -
                                                                                                SomeDatabaseService service = ProxyHelper.createProxy(SomeDatabaseService.class,
-    vertx,
-    "database-service-address");
-// 也可以指定消息传递的配置
-SomeDatabaseService service2 = ProxyHelper.createProxy(SomeDatabaseService.class,
-    vertx,
-    "database-service-address", options);
-
                                                                                                -

                                                                                                其中第二个方法会接受一个 DeliveryOptions 实例，你可以在这里配置消息传递的相关参数（如 timeout）。

                                                                                                -

                                                                                                你也可以使用生成的代理类，代理类名是服务接口类名加上 VertxEBProxy。比如你的服务接口类名是 SomeDatabaseService，则代理名就是 SomeDatabaseServiceVertxEBProxy。

                                                                                                -

                                                                                                通常情况下，服务接口中会包含一个 createProxy 静态方法用来创建服务代理实例，但这不是必须的：

                                                                                                -
                                                                                                @ProxyGen
-public interface SomeDatabaseService {
-
- // 用于创建服务代理实例的方法
- static SomeDatabaseService createProxy(Vertx vertx, String address) {
-   return new SomeDatabaseServiceVertxEBProxy(vertx, address);
- }
-
- // ...
-}
-
                                                                                                -

                                                                                                错误处理

                                                                                                -

                                                                                                服务方法可能会通过向方法的处理器（Handler）传递一个失败状态的 Future （包含一个 ServiceException 实例）来返回错误。一个 ServiceException 包含一个整形（int）的错误状态码、一条消息和一个可选的 JsonObject 对象（用于包含额外的重要信息）。为了方便起见，我们可以使用 ServiceException.fail 工厂方法来创建一个已经是失败状态并且包装着 ServiceException 实例的 Future。比如：

                                                                                                -
                                                                                                public class SomeDatabaseServiceImpl implements SomeDatabaseService {
-private static final BAD_SHOE_SIZE = 42;
-private static final CONNECTION_FAILED = 43;
-
-  // 创建连接
-  void createConnection(String shoeSize, Handler<AsyncResult<MyDatabaseConnection>> resultHandler) {
-    if (!shoeSize.equals("9")) {
-      resultHandler.handle(ServiceException.fail(BAD_SHOE_SIZE, "The shoe size must be 9!",
-        new JsonObject().put("shoeSize", shoeSize));
-     } else {
-        doDbConnection(result -> {
-          if (result.succeeded()) {
-            resultHandler.handle(Future.succeededFuture(result.result()));
-          } else {
-            resultHandler.handle(ServiceException.fail(CONNECTION_FAILED, result.cause().getMessage()));
-          }
-        });
-     }
-  }
-}
-
                                                                                                -

                                                                                                服务调用端（client side）可以检查它接收到的失败状态的AsyncResult包含的Throwable对象是否为ServiceException实例。如果是的话，继续检查内部的特定的错误状态码。调用端可以通过这些信息来将业务逻辑错误与系统错误（如服务没有被注册到Event Bus上）区分开，以便确定到底发生了哪一种业务逻辑错误。下面是一个例子：

                                                                                                -
                                                                                                public void foo(String shoeSize, Handler<AsyncResult<JsonObject>> handler) {
-  SomeDatabaseService service = SomeDatabaseService.createProxy(vertx, SERVICE_ADDRESS);
-  service.createConnection("8", result -> {
-    if (result.succeeded()) {
-      // 正常调用
-    } else {
-      if (result.cause() instanceof ServiceException) {
-        ServiceException exc = (ServiceException) result.cause();
-        if (exc.failureCode() == SomeDatabaseServiceImpl.BAD_SHOE_SIZE) {
-          handler.handle(Future.failedFuture(
-            new InvalidInputError("You provided a bad shoe size: " +
-              exc.getDebugInfo().getString("shoeSize"))
-          ));
-        } else if (exc.failureCode() == SomeDatabaseServiceImpl.CONNECTION) {
-          handler.handle(Future.failedFuture(
-            new ConnectionError("Failed to connect to the DB")));
-        }
-      } else {
-        // 可能是一个系统错误(system error)，如服务代理没有对应的已注册的服务
-        handler.handle(Future.failedFuture(
-          new SystemError("An unexpected error occurred: + " result.cause().getMessage())
-        ));
-      }
-    }
-  }
-}
-
                                                                                                -

                                                                                                如果需要的话，服务实现的时候也可以返回ServiceException的子类，只要向Event Bus注册了对应的默认MessageCodec就可以。比如给定下面的ServiceException子类：

                                                                                                -
                                                                                                class ShoeSizeException extends ServiceException {
-  public static final BAD_SHOE_SIZE_ERROR = 42;
-
-  private final String shoeSize;
-
-  public ShoeSizeException(String shoeSize) {
-    super(BAD_SHOE_SIZE_ERROR, "In invalid shoe size was received: " + shoeSize);
-    this.shoeSize = shoeSize;
-  }
-
-  public String getShoeSize() {
-    return extra;
-  }
-
-  public static <T> AsyncResult<T> fail(int failureCode, String message, String shoeSize) {
-    return Future.failedFuture(new MyServiceException(failureCode, message, shoeSize));
-  }
-}
-
                                                                                                -

                                                                                                只要向Event Bus注册了对应的MessageCodec，服务就可以直接向调用者返回自定义的异常类型：

                                                                                                -
                                                                                                public class SomeDatabaseServiceImpl implements SomeDatabaseService {
-  public SomeDataBaseServiceImpl(Vertx vertx) {
-    // 在服务端（被调用端）注册MessageCodec。如果运行在单机模式下这就足够了
-    // 因为服务代理会共享同一个Vertx实例
-    vertx.eventBus().registerDefaultCodec(ShoeSizeException.class,
-      new ShoeSizeExceptionMessageCodec());
-  }
-
-  // 创建连接
-  void createConnection(String shoeSize, Handler<AsyncResult<MyDatabaseConnection>> resultHandler) {
-    if (!shoeSize.equals("9")) {
-      resultHandler.handle(ShoeSizeException.fail(shoeSize));
-    } else {
-      resultHandler.Handle(Future.succeededFuture(myDbConnection));
-    }
-  }
-}
-
                                                                                                -

                                                                                                最后调用端可以检查自定义的异常类型了：

                                                                                                -
                                                                                                public void foo(String shoeSize, Handler<AsyncResult<JsonObject>> handler) {
-  // 如果运行在集群模式下，那么需要将ShoeSizeExceptionMessageCodec注册到当前节点的Event Bus下
-  SomeDatabaseService service = SomeDatabaseService.createProxy(vertx, SERVICE_ADDRESS);
-  service.createConnection("8", result -> {
-    if (result.succeeded()) {
-      // 进行方法调用
-    } else {
-      if (result.cause() instanceof ShoeSizeException) {
-        ShoeSizeException exc = (ShoeSizeException) result.cause();
-        handler.handle(Future.failedFuture(
-          new InvalidInputError("You provided a bad shoe size: " + exc.getShoeSize())));
-      } else {
-        // 可能是一个系统错误(system error)，如服务代理没有对应的已注册的服务
-        handler.handle(Future.failedFuture(
-          new SystemError("An unexpected error occurred: + " result.cause().getMessage())
-        ));
-      }
-    }
-  }
-}
-
                                                                                                -

                                                                                                注意在Vert.x 集群模式下，你需要向集群中每个节点的Event Bus注册对应的自定义异常类型的MessageCodec实例。

                                                                                                -

                                                                                                服务接口的约束

                                                                                                -

                                                                                                在服务方法中可用的参数类型和返回值类型是有限制的，这样使得转化为Event Bus消息更加容易。下面我们就来看一下：

                                                                                                -

                                                                                                方法返回类型

                                                                                                -

                                                                                                返回类型必须是以下其中之一：

                                                                                                -
                                                                                                  -
                                                                                                • void
                                                                                                  • -
                                                                                                • 返回此服务实例的引用（this）并标注 @Fluent 注解：
                                                                                                  • -
                                                                                                -
                                                                                                @Fluent
-SomeDatabaseService doSomething();
-
                                                                                                -

                                                                                                这是因为方法不能阻塞，并且如果服务是远程的，不可能立即返回结果而不阻塞。

                                                                                                -

                                                                                                参数类型和异步返回类型

                                                                                                -

                                                                                                令 JSON = JsonObject | JsonArray，PRIMITIVE = 任意原生类型或包装的原生类型。

                                                                                                -

                                                                                                参数类型可以是以下类型中任意一个：

                                                                                                -
                                                                                                  -
                                                                                                • JSON
                                                                                                  • -
                                                                                                • PRIMITIVE
                                                                                                  • -
                                                                                                • List<JSON>
                                                                                                  • -
                                                                                                • List<PRIMITIVE>
                                                                                                  • -
                                                                                                • Set<JSON>
                                                                                                  • -
                                                                                                • Set<PRIMITIVE>
                                                                                                  • -
                                                                                                • Map<String, JSON>
                                                                                                  • -
                                                                                                • Map<String, PRIMITIVE>
                                                                                                  • -
                                                                                                • 任何枚举类型
                                                                                                  • -
                                                                                                • 任何被 @DataObject 注解的类
                                                                                                  • -
                                                                                                -

                                                                                                如果需要返回异步结果，可以提供一个 Handler<AsyncResult<R>> 类型的参数放到最后。其中类型R可以是：

                                                                                                -
                                                                                                  -
                                                                                                • JSON
                                                                                                  • -
                                                                                                • PRIMITIVE
                                                                                                  • -
                                                                                                • List<JSON>
                                                                                                  • -
                                                                                                • List<PRIMITIVE>
                                                                                                  • -
                                                                                                • Set<JSON>
                                                                                                  • -
                                                                                                • Set<PRIMITIVE>
                                                                                                  • -
                                                                                                • 任何枚举类型
                                                                                                  • -
                                                                                                • 任何被 @DataObject 注解的类
                                                                                                  • -
                                                                                                • 另一个代理类
                                                                                                  • -
                                                                                                -

                                                                                                重载的方法

                                                                                                -

                                                                                                服务接口中不允许有重载的服务方法（即方法名相同，参数列表不同）。

                                                                                                -

                                                                                                通过Event Bus调用服务的约定（不使用服务代理的情况下）

                                                                                                -

                                                                                                服务代理假定Event Bus中的消息遵循一定的格式，因此能被用于服务的调用。

                                                                                                -

                                                                                                当然，如果不愿意的话，你也可以不用服务代理类来访问远程服务。被广泛接受的与服务交互的方式就是直接在Event Bus发送消息。

                                                                                                -

                                                                                                为了使服务访问的方式一致，所有的服务都必须遵循以下的消息格式。格式非常简单：

                                                                                                -
                                                                                                  -
                                                                                                • 需要有一个名为 action 的 消息头(header)，作为要执行操作的名称
                                                                                                  • -
                                                                                                • 消息体（message body）应该是一个 JsonObject 对象，里面需要包含操作需要的所有参数。
                                                                                                  • -
                                                                                                -

                                                                                                举个例子，假如我们要去执行一个名为save的操作，此操作接受一个字符串类型的collection参数和一个JsonObject类型的document参数：

                                                                                                -
                                                                                                Headers:
-    "action": "save"
-Body:
-    {
-        "collection": "mycollection",
-        "document": {
-            "name": "tim"
-        }
-    }
-
                                                                                                -

                                                                                                无论有没有用到服务代理，都应该用上面这种方式编写服务，因为这样允许服务交互时保持一致性。

                                                                                                -

                                                                                                在上面的例子中，action对应的值应该与服务接口的某个方法名称相对应，而消息体中每个 [key, value] 都要与服务方法中的某个 [arg_name, arg_value]相对应（译者注：key对应参数名，value对应参数值）。

                                                                                                -

                                                                                                对于返回值，服务需使用 message.reply(…​) 方法去向调用端发送回一个返回值 —— 这个值可以是Event Bus支持的任何类型。如果需要表示调用失败，可以使用 message.fail(…​) 方法。

                                                                                                -

                                                                                                如果你使用Vert.x 服务代理组件的话，生成的代码会自动帮你处理这些问题。

                                                                                                -
                                                                                                -
                                                                                                -

                                                                                                原文档最后更新于 2017-03-15 15:54:14 CET

                                                                                                -
                                                                                                - - -
                                                                                                - -
                                                                                                -
                                                                                                -
                                                                                                - -

                                                                                                results matching ""

                                                                                                -
                                                                                                  - -
                                                                                                  -
                                                                                                  - -

                                                                                                  No results matching ""

                                                                                                  - -
                                                                                                  -
                                                                                                  -
                                                                                                  - -
                                                                                                  -
                                                                                                  - -
                                                                                                  - - - - - - - - - - - - - - -
                                                                                                  - - -
                                                                                                  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/services/Services.html b/docs/services/Services.html deleted file mode 100644 index 9040399..0000000 --- a/docs/services/Services.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - Services · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                                  -
                                                                                                  - - - - - - - - -
                                                                                                  - -
                                                                                                  - -
                                                                                                  - - - - - - - - -
                                                                                                  -
                                                                                                  - -
                                                                                                  -
                                                                                                  - -
                                                                                                  - -

                                                                                                  Vert.x Services

                                                                                                  - - -
                                                                                                  - -
                                                                                                  -
                                                                                                  -
                                                                                                  - -

                                                                                                  results matching ""

                                                                                                  -
                                                                                                    - -
                                                                                                    -
                                                                                                    - -

                                                                                                    No results matching ""

                                                                                                    - -
                                                                                                    -
                                                                                                    -
                                                                                                    - -
                                                                                                    -
                                                                                                    - -
                                                                                                    - - - - - - - - - - - - - - -
                                                                                                    - - -
                                                                                                    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/services/SockJSServiceProxies.html b/docs/services/SockJSServiceProxies.html deleted file mode 100644 index 0b34a08..0000000 --- a/docs/services/SockJSServiceProxies.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - SockJS Service Proxies · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                                    -
                                                                                                    - - - - - - - - -
                                                                                                    - -
                                                                                                    - -
                                                                                                    - - - - - - - - -
                                                                                                    -
                                                                                                    - -
                                                                                                    -
                                                                                                    - -
                                                                                                    - -

                                                                                                    Vert.x SockJS Service Proxies

                                                                                                    - - -
                                                                                                    - -
                                                                                                    -
                                                                                                    -
                                                                                                    - -

                                                                                                    results matching ""

                                                                                                    -
                                                                                                      - -
                                                                                                      -
                                                                                                      - -

                                                                                                      No results matching ""

                                                                                                      - -
                                                                                                      -
                                                                                                      -
                                                                                                      - -
                                                                                                      -
                                                                                                      - -
                                                                                                      - - - - - - - - - - - - - - -
                                                                                                      - - -
                                                                                                      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/services/gRPC.md b/docs/services/gRPC.md deleted file mode 100644 index 3f6ee7e..0000000 --- a/docs/services/gRPC.md +++ /dev/null @@ -1 +0,0 @@ -# Vert.x gRPC diff --git a/docs/start/FAQ.html b/docs/start/FAQ.html deleted file mode 100644 index 688c087..0000000 --- a/docs/start/FAQ.html +++ /dev/null @@ -1,1324 +0,0 @@ - - - - - - - FAQ · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                                      -
                                                                                                      - - - - - - - - -
                                                                                                      - -
                                                                                                      - -
                                                                                                      - - - - - - - - -
                                                                                                      -
                                                                                                      - -
                                                                                                      -
                                                                                                      - -
                                                                                                      - -

                                                                                                      FAQ

                                                                                                      -

                                                                                                      此处会列出常见的关于Vert.x 各个组件的常见问题以及相应的注意事项和解决方案。

                                                                                                      -

                                                                                                      问：怎样正确理解Vert.x机制？

                                                                                                      -

                                                                                                      答：Vert.x其实就是建立了一个Verticle内部的线程安全机制，让用户可以排除多线程并发冲突的干扰，专注于业务逻辑上的实现，用了Vert.x，您就不用操心多线程和并发的问题了。Verticle内部代码，除非声明Verticle是Worker Verticle，否则Verticle内部环境全部都是线程安全的，不会出现多个线程同时访问同一个Verticle内部代码的情况。

                                                                                                      -
                                                                                                      -

                                                                                                      请注意：一般情况下，用了Vert.x的Verticle之后，原则上synchronized，Lock，volatile，static对象，java.util.concurrent, HashTable, Vector, Thread, Runnable, Callable, Executor, Task, ExecutorService等这些并发和线程相关的东西就不再需要使用了，可以由Verticle全面接管，如果您不得不在Vert.x代码中使用上诉内容，则多少暗示着您的设计或者使用Vert.x的姿势出现了问题，建议再斟酌商榷一下。

                                                                                                      -
                                                                                                      -

                                                                                                      问：Verticle对象和处理器（Handler）是什么关系？Vert.x如何保证Verticle内部线程安全？

                                                                                                      -

                                                                                                      答：Verticle对象往往包含有一个或者多个处理器（Handler），在Java代码中，后者经常是以Lambda也就是匿名函数的形式出现，比如：

                                                                                                      -
                                                                                                      vertx.createHttpServer().requestHandler(req->{
-    //blablabla            
-}).listen(8080);
-
                                                                                                      -

                                                                                                      这里的Lambda/匿名函数/req->{//blablabla}就是一个处理器（Handler），在随后的例子中，我们用1stHandler以及2ndHandler来指代具体的匿名函数，让代码更加清晰明了，放在Verticle中类似：

                                                                                                      -
                                                                                                      public class MyVerticle extends AbstractVerticle {
-    public void start() throws Exception {
-        vertx.createHttpServer().requestHandler(1stHandler).listen(8080);
-    vertx.createHttpServer().requestHandler(2ndHandler).listen(8081);
-    }
-}
-
                                                                                                      -

                                                                                                      Java中，Lambda本身也是一个对象，是一个@FunctionalInterface的对象，Verticle对象中包含了一个或者多个处理器（Handler）对象，比如上述例子中MyVerticle中就包含有两个handler。在Vert.x中，完成Verticle的部署之后，真正调用处理逻辑的入口往往是处理器（Handler），Vert.x保证同一个普通Verticle（也就是EventLoop Verticle，非Worker Verticle）内部的所有处理器（Handler）都只会由同一个EventLoop线程调用，由此保证Verticle内部的线程安全。所以我们可以放心地在Verticle内部声明各种线程不安全的属性变量，并在handler中分享他们，比如：

                                                                                                      -
                                                                                                      public class MyVerticle extends AbstractVerticle {
-    int i = 0;//属性变量
-
-    public void start() throws Exception {
-        vertx.createHttpServer().requestHandler(req->{
-            i++;
-        req.response().end();//要关闭请求，否则连接很快会被占满
-        }).listen(8080);
-
-        vertx.createHttpServer().requestHandler(req->{
-            System.out.println(i);
-        req.response().end(“”+i);
-        }).listen(8081);
-    }
-}
-
                                                                                                      -

                                                                                                      访问 http://localhost:8080 就会使计数器加1，访问 http://localhost:8081 将会看到具体的计数。同理，也可以将i替换成HashMap等线程不安全对象，不需要使用ConcurrentHashMap或HashTable，可在Verticle内部安全使用。

                                                                                                      -

                                                                                                      Vert.x的Handler内部是atomic/原子操作，Verticle内部是thread safe/线程安全的，Verticle之间传递的数据是immutable/不可改变的。

                                                                                                      -

                                                                                                      一个vert.x实例/进程内有多个Eventloop和Worker线程，每个线程会部署多个Verticle对象并对应执行Verticle内的Handler，每个Verticle内有多个Handler，普通Verticle会跟Eventloop绑定，而Worker Verticle对象则会被Worker线程所共享，会依次顺序访问，但不会并发同时访问，如果声明为Multiple Threaded Worker Verticle则没有此限制，需要开发者手工处理并发冲突，我们并不推荐这类操作。

                                                                                                      -

                                                                                                      问：什么是显著执行时间？什么是异步？如何正确理解文档中说的不要阻塞Eventloop？

                                                                                                      -

                                                                                                      答：初次接触Vert.x的开发人员往往会在异步，显著执行时间，阻塞等概念理解上遇到一定的困难，在此一并做个解释和说明。

                                                                                                      -

                                                                                                      注意：我们会尽量将原理讲得通俗易懂，但还是要求读者具备有线程，进程，内存，CPU，操作系统，数据库，算法等专业基础知识。

                                                                                                      -

                                                                                                      计算机本质上是计算的机器，任何一个指令的执行，都需要一定的时间予以完成，这个时间可能长可能短，而这些指令的执行，都会分配给一个具体的线程，并在线程中执行完成。在Vert.x中，黄金原则是不阻塞Eventloop线程，而Eventloop顾名思义，是一个事件的循环，可以认为是一个在Vert.x生命周期内，不停轮询事件是否发生，并将发生的事件交给Handler予以处理的无限调度循环线程。那么为了不停地检查事件是否发生，该线程需要在短时间内完成一个调度循环。如果Eventloop在完成一个调度循环的时间过长，就有可能导致新发生的事件得不到及时的处理，进而导致单次事件响应时间过长，影响客户体验。

                                                                                                      -

                                                                                                      为了在短时间内完成调度循环，就需要用户正确估算出，哪些程序代码会相对长时间地占用Eventloop线程的执行时间，然后将该部分代码的执行交由其它线程去处理。值得注意的是，这里所说的其它线程，可能是内核线程，也就是操作系统的线程，也有可能是用户线程，用户线程中包括了其它应用程序的线程，也就是其它进程中的线程，或者是我们用户自定义的线程。

                                                                                                      -

                                                                                                      一个简单粗暴的判断标准：任何涉及到IO操作的代码，都可以认为是可能造成阻塞的代码，纯粹内存操作的代码，只要执行时间没有明显超长（例如执行循环几万次的处理便可认为是执行时间超长），都可以认为是非阻塞代码。

                                                                                                      -

                                                                                                      我们来看一个简单的例子：某个程序要求，当前线程发送一个请求给网络上另外一个服务器，然后获取到结果之后作出相应的处理。那么此时有一个明显的IO操作，就是发送网络请求并等待对方返回结果。因为网络的速度要远远慢于内存处理的速度，所以此时的操作便是非纯粹内存操作，就有可能造成线程的阻塞，那么此时应该将这个操作交给其它线程予以处理，在处理完成之前，释放当前线程，等处理完成之后，再由当前线程执行回调函数。Vert.x自带的网络客户端（NetClient，HttpClient等）已经帮您包装好了这部分逻辑代码，直接使用NetClient等客户端，Vert.x就会将发送请求并等待返回结果这部分代码交给另外一个线程予以执行，此时这另外一个线程是内核线程，这部分的异步处理由JVM以及操作系统完成，您不需要自己定义一个线程并执行。类似的，数据库的处理同样涉及IO操作，所以Vert.x自带的JDBC客户端（JDBCClient）会帮您完成这部分的封装，您只需要直接调用JDBCClient的各种API便可完成操作，此时有可能是其它进程中的线程，比如PostgresQL会使用进程池来建立连接池，但是该线程亦不需要您去创建，Vert.x帮您完成了这些操作。类似的，硬盘上的操作，比如文件系统的API，也有可能造成阻塞，所以Vert.x的文件系统API提供了非阻塞API，但是值得说明的是，硬盘上的操作，如果只是少量操作，执行时间上也不会明显超长，所以Vert.x同时提供了硬盘操作的阻塞和非阻塞两种API。最后我们来看一个纯粹内存操作同时又是阻塞的例子。

                                                                                                      -

                                                                                                      假设我们拿到两个数万个节点的链表（LinkedList），要求删除两个链表的交集，那么在没有任何算法优化的前提下，该操作的时间复杂度是O(n^2)，又因为内存中该链表节点数庞大，多达数万个节点，所以如果在Eventloop中执行该操作，将有可能使得执行时间超长，此时需要将这部分代码交由其它线程予以执行，Vert.x提供了除了Eventloop线程池以外的线程池，名曰Worker线程池。此时就需要用户自行将该部分代码包装成Worker线程执行的代码，并交给Worker线程予以执行，执行完成之后再由Eventloop线程执行回调函数处理其结果。注意：Vert.x中将代码交给Worker线程执行的方式有两种，一种是通过executeBlocking函数包装，另外一种是写入Worker Verticle中。

                                                                                                      -

                                                                                                      问：为什么Verticle之间传递的消息要求是immutable（不可变）的？

                                                                                                      -

                                                                                                      答：因为immutable（不可变的）的东西线程安全，可以被多个线程安全地并发访问，线程在使用的时候拷贝一份也不会有并发问题，Java里面字符串（String）对象是immutable（不可变）的，所以缺省情况下事件总线（eventbus）上传递的消息是字符串，vert.x也实现了事件总线上消息类型的编解码器，除了字符串以外，还支持少量的其它类型，比如原始数据类型及其包装类，比如字节流（byte[]），比如Json对象（JsonObject, JsonArray）还有Buffer，这些对象在传递过程中是不可变的。

                                                                                                      -

                                                                                                      Vert.x线程模型保证Verticle内部代码线程安全，同时要求在Verticle之间传递的消息是不可变的，通过此方法保证Verticle之间传递的消息也是线程安全的，从而进一步保证Vert.x内部整体是线程安全的，从而将开发人员从繁琐的，容易错的各种多线程并发问题中解脱出来。

                                                                                                      -

                                                                                                      问：我刚拿到一个第三方类库（lib/jars），怎么判断这个类库中的方法是异步还是同步的？有没有简单粗暴的方法可以一眼看出来？

                                                                                                      -

                                                                                                      答：严格说来，要认真看代码文档，比如JavaDoc，来判断方法是异步还是同步的，如果文档中没有明确说明，则默认是同步的，异步API往往出现在IO相关的方法中，所谓IO一般认为是涉及到硬盘（比如在硬盘上存取文件），网络（通过网络发送一个请求并获取相应结果），其它进程的操作（操作数据库）等，一般纯粹的，本进程内的内存操作并不被认为是涉及IO操作，这个时候将方法或API制作成异步的并无实际意义，所以一般非IO相关操作都被认为是同步的，同时并不会占用显著执行时间，所以不会阻塞线程。

                                                                                                      -
                                                                                                      -

                                                                                                      请注意：Vert.x中绝大多数涉及IO操作除非有明确说明，例如以Sync后缀命名的方法，否则均是异步的，另外在Vert.x中，EventBus的相关操作也被认为是涉及IO操作。

                                                                                                      -
                                                                                                      -

                                                                                                      有一个粗暴简单的判断同步还是异步的方法，就看给出的API或者方法中，是否有回调函数，如果有回调函数，且这个回调函数的参数是AsyncResult，则可以判断该API或方法是异步的。

                                                                                                      -

                                                                                                      问：Vert.x中各种Client该如何正确使用，用完是否需要关闭？

                                                                                                      -

                                                                                                      答：Vert.x中提供了各种预设客户端，例如HttpClient，JDBCClient，WebClient，MongoClient等，一般情况下，建议将客户端与Verticle对象绑定，一个Verticle对象内保留一个特定客户端的引用，并在start方法中将其实例化，这样Vert.x会在执行deployVerticle的时候执行start方法，实例化并保存该对象，在Verticle生命周期内，不需要频繁创建和关闭同类型的客户端，建议在Verticle的生命周期内对于特定领域，只创建一个客户端并复用该客户端，例如：

                                                                                                      -
                                                                                                      import io.vertx.core.AbstractVerticle;
-import io.vertx.core.http.HttpClient;
-import io.vertx.core.json.JsonObject;
-import io.vertx.ext.jdbc.JDBCClient;
-import io.vertx.ext.web.client.WebClient;
-
-/**
- * Created by chengen on 21/04/2017.
- */
-public class TheVerticle extends AbstractVerticle{
-    //将客户端对象与Verticle对象绑定，这里选取了三种不同的客户端作为示范
-    HttpClient httpClient;
-    WebClient webClient;
-    JDBCClient jdbcClient;
-
-    public void start(){
-          //创建客户端
-        httpClient = vertx.createHttpClient();
-
-        webClient = WebClient.wrap(httpClient);
-
-        JsonObject config = new JsonObject()
-                .put("jdbcUrl", "...")
-                .put("maximumPoolSize", 30)
-                .put("username", "db user name")
-                .put("password", "***")
-                .put("provider_class", "...");
-
-        jdbcClient = JDBCClient.createShared(vertx, config);
-
-          //using clients 
-    }
-}
-
                                                                                                      -

                                                                                                      每次使用客户端完之后，无需调用client.close();方法关闭客户端，频繁创建销毁客户端会在一定程度上消耗系统资源，降低性能，同时增加开发人员的负担，Vert.x提供客户端的目的就在于复用连接以减少资源消耗，提升性能，同时简化代码，减轻开发人员的负担。如您关闭客户端，在下一次使用该客户端的时候，需要重新创建客户端。

                                                                                                      -

                                                                                                      问：Vert.x中Future该如何正确使用，怎样规避回调地狱？

                                                                                                      -

                                                                                                      答：Future对象提供了一种异步结果的包装，用户可使用Future类中的setHandler方法来保存回调函数，然后在原先使用该回调函数的地方用completer方法予以填充，这样便可将回调函数从原参数中取出，以减少回调缩进，从而规避回调地狱，来看一个简单的例子：

                                                                                                      -
                                                                                                      //未使用future时，回调函数嵌在send方法内部，以匿名函数的形式作为send的参数
-vertx.eventBus().send("address","message", asyncResult->{
-    System.out.println(asyncResult.result().body()); 
-});
-
                                                                                                      -

                                                                                                      以上是未使用future时的代码，以下是使用future改造后的代码：

                                                                                                      -
                                                                                                      Future<Message<String>> future = Future.future();
-//将回调函数存入future中，从而实现代码的扁平化
-future.setHandler(asyncResult -> {
-    System.out.println(asyncResult.result().body());
-});
-//使用future之后，用completer方法填充参数
-vertx.eventBus().send("address","message", future.completer());
-
                                                                                                      -

                                                                                                      一个复杂一点的例子：

                                                                                                      -
                                                                                                      //以下程序先向address1发送一个message，然后等address1回复之后，将address1的回复消息发送给address2，最后将address2的回复打印到控制台上
-vertx.eventBus().send("address1","message", asyncResult->{
-    vertx.eventBus().send("address2", asyncResult.result().body(), asyncResult2->{
-        System.out.println(asyncResult2.result().body());
-    });
-});
-
                                                                                                      -

                                                                                                      可以看到此时为了保证顺序结构，产生了两层缩进，回调金字塔开始形成，多次缩进之后便会出现所谓的回调地狱，这便是异步开发中为了保证顺序所可能会遇到的问题，那么我们可以通过以下方式解决代码过多缩进的问题：

                                                                                                      -
                                                                                                      Future<Message<String>> future1 = Future.future();
-Future<Message<String>> future2 = Future.future();
-
-future1.setHandler(asyncResult -> {
-   vertx.eventBus().send("address2", asyncResult.result().body(), future2);
-});
-
-future2.setHandler(asyncResult-> {
-    System.out.println(asyncResult.result().body());
-});
-
-vertx.eventBus().send("address1","message", future1);
-
                                                                                                      -

                                                                                                      可以看到，使用了future之后，原先的两层缩进被抽取出来，变成了最多单层的缩进，从而使得代码可读性更强，更加美观。

                                                                                                      -

                                                                                                      值得注意的是，示范代码可能会抛出NullPointerException，因为当操作失败时，asyncResult.result()方法返回值为null，此时调用.body()方法会抛出空指针异常，在生产环境中正确写法应该是：

                                                                                                      -
                                                                                                      if(asyncResult.succeeded()){
-    System.out.println(asyncResult.result().body());
-}else if(asyncResult.failed()){
-    System.out.println(asyncResult.cause());
-}else{
-    System.out.println("Why am I here?");
-}
-

                                                                                                      示范代码中为了解释future的用法简写了代码。

                                                                                                      -

                                                                                                      使用 Future 来包装异步代码块 (3.4.0+)

                                                                                                      -

                                                                                                      早期版本的 Future，针对每一个异步的过程，需要在代码中声明中间变量 future 来对应异步回调，例如上文例子中的：

                                                                                                      -
                                                                                                      Future<Message<String>> future1 = Future.future();
-Future<Message<String>> future2 = Future.future();
-
                                                                                                      -

                                                                                                      在最新的版本中(3.4.0+)，可以通过 Future.future 方法以函数式的方式直接用 Future 来包装一个异步的代码块，例如：

                                                                                                      -
                                                                                                      Future.<Message<String>>future((future) ->
-  vertx.eventBus().send("address1", "someMessage", future)
-);
-
                                                                                                      -

                                                                                                      该方法的输入参数是一个 Function，该 Function 会以一个新的 Future 实例为参数被调用。由于 Future 自身实现了 Handler<AsyncResult>，因此你可以将它直接作为回调的 Handler 传入到异步方法里。该方法的返回值是提供给异步调用使用的 Future 实例。由此可以避免为嵌套的多个异步操作定义不同的 Future 变量，使代码更为简洁。

                                                                                                      -

                                                                                                      以下两种写法是等效的：

                                                                                                      -
                                                                                                      vertx.eventBus().send("address","message", future.completer());
-//或
-vertx.eventBus().send("address","message", future);
-
                                                                                                      -

                                                                                                      复杂一点的例子：

                                                                                                      -
                                                                                                      future.compose(message ->
-  Future.<Message<String>>future(f ->
-    vertx.eventBus().send("address", message.body(), f)
-  )
-);
-//以上和以下两种写法是等效的
-future.compose(message ->{
-  Future<Message<String>> f = Future.future();
-  vertx.eventBus().send("address",message.body(),f.completer());
-  return f;
-});
-
                                                                                                      -

                                                                                                      使用组合来实现链式调用 (3.4.0+)

                                                                                                      -

                                                                                                      Future 接口提供了 compose 方法来链式地组合多个异步操作。在介绍这个方法的用途时，我们先考虑一个传统的同步操作和异常处理的方式。假设我们有一个同步的方法 send 会抛出一些异常（注意，以下代码只是同步代码的示例，和 vert.x 无关）：

                                                                                                      -
                                                                                                      try {
-    String msg1 = send('address1', 'message');
-    String msg2 = send('address2', msg1);
-    String msg3 = send('address3', msg2);
-    //deal with result
-} catch (Exception e) {
-    //deal with exception
-}
-
                                                                                                      -

                                                                                                      在这个例子里，如果任意一个 send 方法抛出异常，则会立即跳转到 catch 的代码块中。

                                                                                                      -

                                                                                                      下面我们将这个 send 方法通过 compose 替换为 vert.x 的异步版本，如下：

                                                                                                      -
                                                                                                      Future.<Message<String>>future(f ->
-  vertx.eventBus().send("address1", "message", f)
-).compose((msg) ->
-  Future.<Message<String>>future(f ->
-    vertx.eventBus().send("address2", msg.body(), f)
-  )
-).compose((msg) ->
-  Future.<Message<String>>future(f ->
-    vertx.eventBus().send("address3", msg.body(), f)
-  )
-).setHandler((res) -> {
-  if (res.failed()) {
-    //deal with exception
-    return;
-  }
-  //deal with the result
-});
-
                                                                                                      -

                                                                                                      每一个 compose 方法需要传入一个 Function，Function 的输入是前一个异步过程的返回值（此处的返回值不是 AsyncResult，而是具体的返回内容），需要返回一个新的需要链接的 Future。 该 Function方法当且仅当前一个异步流程执行成功时才会被调用。

                                                                                                      -

                                                                                                      上述的例子描述了这样一个流程：

                                                                                                      -
                                                                                                        -
                                                                                                      1. 首先通过 eventbus 发送消息 message 到 address1
                                                                                                        2. -
                                                                                                      2. 如果第一步成功，则发送第一步的消息的返回值到 address2
                                                                                                        3. -
                                                                                                      3. 如果第二步成功，则发送第二部的消息的返回值到 address3
                                                                                                        4. -
                                                                                                      4. 如果以上任何一步失败，则不会继续执行下一个异步流程，直接执行最终的 Handler ，并且 res.successed() 为 false，可以通过 res.cause() 来获得异常对象
                                                                                                        5. -
                                                                                                      5. 如果以上三步全都成功，则同样执行 Handler，res.successed() 为 true，可以通过 res.result() 获取最后一步的结果。
                                                                                                        6. -
                                                                                                      -

                                                                                                      通过 compose 方法来组织代码最大的价值在于可以 让异步代码的执行顺序和代码的编写顺序看起来一致，并在任何一步抛出异常时直接退出到最后一个 handler 来处理，不需要针对每一个异步操作都编写异常处理的逻辑。这对于编写复杂的异步流程时是非常有用的。

                                                                                                      -

                                                                                                      Future.compose 这个方法的行为现在非常接近于 JDK1.8 提供的 CompletableFuture.thenCompose()，也很接近于 EcmaScript6 的 Promise API 的的接口约定，其实都是关于 Promise 模式的应用。关于更多 Promise 模式的信息还可以参考这里 https://en.wikipedia.org/wiki/Futures_and_promises

                                                                                                      -

                                                                                                      问：Vert.x Web中如何将根路径对应到某个特定的html文件？

                                                                                                      -

                                                                                                      答：用reroute和staticHandler：

                                                                                                      -
                                                                                                      router.route("/").handler(ctx->ctx.reroute("/static/index.html"));
-
                                                                                                      -

                                                                                                      问：我之前有过Spring，Akka，Node.js或Go的经验，请问Vert.x的概念有我熟悉的吗？

                                                                                                      -

                                                                                                      答：严格说来，不同框架和语言之间的概念无法一一对应，但如果我们不那么严格地去深究细节，Vert.x定义的概念可以从其它框架以及语言中找到一些痕迹，以下是Vert.x中定义概念跟其它框架和语言定义概念的比较，同一行中的概念可被认为是相似的：

                                                                                                      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                                      Vert.xAkkaSpringEJBNode.jsGo
                                                                                                      Standard Verticle---Reactor-
                                                                                                      Worker Verticle--Stateless Session Bean--
                                                                                                      Multiple Threaded
                                                                                                      Worker Verticle                                                                                                      		-Bean(Singleton)---
                                                                                                      HandlerActor---Goroutine
                                                                                                      - - -
                                                                                                      - -
                                                                                                      -
                                                                                                      -
                                                                                                      - -

                                                                                                      results matching ""

                                                                                                      -
                                                                                                        - -
                                                                                                        -
                                                                                                        - -

                                                                                                        No results matching ""

                                                                                                        - -
                                                                                                        -
                                                                                                        -
                                                                                                        - -
                                                                                                        -
                                                                                                        - -
                                                                                                        - - - - - - - - - - - - - - -
                                                                                                        - - -
                                                                                                        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/start/SimpleStart.html b/docs/start/SimpleStart.html deleted file mode 100644 index 89e9a2d..0000000 --- a/docs/start/SimpleStart.html +++ /dev/null @@ -1,1192 +0,0 @@ - - - - - - - 简易教程 · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                                        -
                                                                                                        - - - - - - - - -
                                                                                                        - -
                                                                                                        - -
                                                                                                        - - - - - - - - -
                                                                                                        -
                                                                                                        - -
                                                                                                        -
                                                                                                        - -
                                                                                                        - -

                                                                                                        SimpleStart

                                                                                                        -

                                                                                                        Hello World

                                                                                                        -

                                                                                                        Stay Hungry. Stay Foolish. 如果您是Java新手，对于命令行感到发怵的话，我们特意为您准备了可视化傻瓜化入门教程，以降低Vert.x的入门门槛。但是再怎么傻瓜，也还是需要您具备有基本的Java语法知识，我们并不会在此介绍任何关于Java的语法知识，尤其是Java 1.8版本的基础知识，因为Vert.x 3以上版本要求Java 8以上版本方可运行，且大量应用了1.8加入的新语法糖，比如匿名函数Lambda。

                                                                                                        -

                                                                                                        本文将会建立一个基本的HTTP服务器，并监听8080端口，对于任何发往该服务器以及端口的请求，服务器会返回一个Hello World字符串。与Start部分不同的是：

                                                                                                        -
                                                                                                          -

                                                                                                        1. SimpleStart将会使用IDE，也就是集成开发环境来简化开发流程；

                                                                                                          -
                                                                                                          2. -

                                                                                                        2. SimpleStart将会使用Gradle，而非Maven来简化相关设置。

                                                                                                          -
                                                                                                          3. -
                                                                                                        -

                                                                                                        首先去JetBrain官方网站：www.jetbrains.com 免费下载集成开发环境（IDE）IntelliJ IDEA，有两个版本，社区版（Community）和终极版（Ultimate），后者需要付费使用，相比起前者而言，多了很多Java EE的支持，幸运的是，我们不需要使用这些貌似很牛逼其实无用的功能，用社区版就好了。下载后安装。

                                                                                                        -

                                                                                                        然后启动IntelliJ IDEA，选择创建新项目->Gradle项目->next->填入GroupId（也就是你所在组织的名字，例如io.example）和ArtifactID（也就是项目的名字，例如VertxExample）->next->勾选Use auto-import（自动引入）以及Create directories for empty content roots automatically（为空内容建立文件夹结构）->next ...-> finish，随后会建立以下文件结构，跟Maven文件夹结构几乎一样：

                                                                                                        -
                                                                                                        ├── src
-│   ├── main
-│   │   ├── java
-│   │   └── resources
-│   └── test
-│       └── java
-├── build.gradle
-├── settings.gradle
-

                                                                                                        随后修改build.gradle为：

                                                                                                        -
                                                                                                        group 'io.example'//对应刚刚向导中输入的 GroupId，ArtifactId在settings.gradle中
-version '1.0-SNAPSHOT'
-
-apply plugin: 'java'
-
-sourceCompatibility = 1.8
-targetCompatibility = 1.8//新增
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    compile 'io.vertx:vertx-core:3.4.1'//新增 vert.x core的依赖
-    testCompile group: 'junit', name: 'junit', version: '4.12'
-}
-
-//以下部分新增
-jar {
-    manifest {
-        attributes "Main-Class": "io.example.Main"//指定Main函数所在的类
-    }
-
-    from {
-        configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
-    }
-}
-
                                                                                                        -

                                                                                                        然后我们在src/main/java/io/example目录（是的，您需要新建io和example两级文件夹）下新建两个java文件，分别是Main.java和MyFirstVerticle.java，代码如下：

                                                                                                        -

                                                                                                        Main.java

                                                                                                        -
                                                                                                        package io.example;
-
-import io.vertx.core.Vertx;
-
-/**
- * Created by chengen on 26/04/2017.
- */
-public class Main {
-    public static void main(String[] args){
-        Vertx vertx = Vertx.vertx();
-
-        vertx.deployVerticle(MyFirstVerticle.class.getName());
-    }
-}
-
                                                                                                        -

                                                                                                        MyFirstVerticle.java

                                                                                                        -
                                                                                                        package io.example;
-
-import io.vertx.core.AbstractVerticle;
-
-/**
- * Created by chengen on 26/04/2017.
- */
-public class MyFirstVerticle extends AbstractVerticle {
-    public void start() {
-        vertx.createHttpServer().requestHandler(req -> {
-            req.response()
-                    .putHeader("content-type", "text/plain")
-                    .end("Hello World!");
-        }).listen(8080);
-    }
-}
-
                                                                                                        -

                                                                                                        随后点开IDE右边的Gradle窗口->Tasks->build->jar，双击执行，便可在build/libs文件夹下生成可执行的jar文件，我生成的是VertxExample-1.0-SNAPSHOT.jar，在有图形界面的操作系统中，您可双击执行，或者用以下命令：java -jar VertxExample-1.0-SNAPSHOT.jar执行。

                                                                                                        -

                                                                                                        随后打开浏览器，在浏览器的地址栏中输入：http://localhost:8080/ 便可看到熟悉的Hello World!啦。

                                                                                                        -

                                                                                                        启动器

                                                                                                        -

                                                                                                        我们也可以使用Launcher来替代Main类，这也是官方推荐的方式，修改build.gradle如下：

                                                                                                        -
                                                                                                        group 'io.example'
-version '1.0-SNAPSHOT'
-
-apply plugin: 'java'
-
-sourceCompatibility = 1.8
-targetCompatibility = 1.8
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    compile 'io.vertx:vertx-core:3.4.1'
-    testCompile group: 'junit', name: 'junit', version: '4.12'
-}
-
-jar {
-    manifest {
-        attributes "Main-Class": "io.vertx.core.Launcher",//改为Launcher
-                "Main-Verticle": "io.example.MainVerticle"//新增Main Verticle属性，对应MainVerticle类
-   }
-
-    from {
-        configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
-    }
-}
-
                                                                                                        -

                                                                                                        然后在src/main/java/io/example目录下新增MainVerticle.java文件，代码如下：

                                                                                                        -
                                                                                                        package io.example;
-
-import io.vertx.core.AbstractVerticle;
-
-/**
- * Created by chengen on 26/04/2017.
- */
-public class MainVerticle extends AbstractVerticle {
-    public void start() {
-        vertx.deployVerticle(MyFirstVerticle.class.getName());
-    }
-}
-
                                                                                                        -

                                                                                                        然后重新打包后执行，便可再次看到Hello World!。

                                                                                                        -

                                                                                                        至此，大功告成，欢迎来到Vert.x的世界。

                                                                                                        -

                                                                                                        一点知识

                                                                                                        -

                                                                                                        jar文件本质上就是一个zip文件，可以用打开zip的压缩工具解压，读者可自行解压拆开jar包，看看相关依赖的文件是否在里面。比如例子中的代码除了生成io.example.MyFirstVerticle.class和io.example.MainVerticle.class文件以外，还同时将依赖的io.vertx.core中的内容压入jar包。

                                                                                                        - - -
                                                                                                        - -
                                                                                                        -
                                                                                                        -
                                                                                                        - -

                                                                                                        results matching ""

                                                                                                        -
                                                                                                          - -
                                                                                                          -
                                                                                                          - -

                                                                                                          No results matching ""

                                                                                                          - -
                                                                                                          -
                                                                                                          -
                                                                                                          - -
                                                                                                          -
                                                                                                          - -
                                                                                                          - - - - - - - - - - - - - - -
                                                                                                          - - -
                                                                                                          - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/start/Start.html b/docs/start/Start.html deleted file mode 100644 index 77830f9..0000000 --- a/docs/start/Start.html +++ /dev/null @@ -1,1389 +0,0 @@ - - - - - - - 开始使用 · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                                          -
                                                                                                          - - - - - - - - -
                                                                                                          - -
                                                                                                          - -
                                                                                                          - - - - - - - - -
                                                                                                          -
                                                                                                          - -
                                                                                                          -
                                                                                                          - -
                                                                                                          - -

                                                                                                          Start

                                                                                                          -

                                                                                                          Hello World

                                                                                                          -

                                                                                                          欢迎来到Vert.x的世界，相信您在接触Vert.x的同时，迫不及待想动手试一试，如您在学习计算机其它知识一样，总是从Hello World开始，下面我们将引导您制作一个最基本简单的Hello World例子，但在此之前，我们需要您具备有以下基础知识：

                                                                                                          -
                                                                                                            -

                                                                                                          1. Java基础知识，您不需要了解Java EE或者是Java ME的知识，但是需要您对Java有所了解，在此文档中，我们不会介绍任何关于Java SE又称Core Java的知识点。请注意：Vert.x 3以上版本需要Java 8以上版本方能运行；

                                                                                                            -
                                                                                                            2. -

                                                                                                          2. Maven相关知识，您需要知道什么Maven是做什么用的，以及如何使用Maven；

                                                                                                            -
                                                                                                            3. -

                                                                                                          3. 互联网的基础知识，知道什么是网络协议，尤其是TCP，HTTP协议。

                                                                                                            -
                                                                                                            4. -
                                                                                                          -

                                                                                                          本文将会建立一个基本的HTTP服务器，并监听8080端口，对于任何发往该服务器以及端口的请求，服务器会返回一个Hello World字符串。

                                                                                                          -

                                                                                                          首先新建一个Maven项目，一个基本的Maven项目目录结构如下所示：

                                                                                                          -
                                                                                                          ├── pom.xml
-├── src
-│   ├── main
-│   │   ├── java
-│   │   └── resources
-│   └── test
-│       └── java
-

                                                                                                          随后在pom.xml中加入相关的依赖和插件，如下所示：

                                                                                                          -
                                                                                                          <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <groupId>io.example</groupId>
-    <artifactId>vertx-example</artifactId>
-    <version>1.0-SNAPSHOT</version>
-
-    <properties>
-        <vertx.version>3.4.1</vertx.version>
-        <main.class>io.example.Main</main.class>
-    </properties>
-
-    <dependencies>
-        <dependency>
-            <groupId>io.vertx</groupId>
-            <artifactId>vertx-core</artifactId>
-            <version>${vertx.version}</version>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.3</version>
-                <configuration>
-                    <source>1.8</source>
-                    <target>1.8</target>
-                </configuration>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <version>2.4.2</version>
-                <executions>
-                    <execution>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                        <configuration>
-                            <transformers>
-                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
-                                    <manifestEntries>
-                                        <Main-Class>${main.class}</Main-Class>
-                                    </manifestEntries>
-                                </transformer>
-                            </transformers>
-                            <artifactSet />
-                            <outputFile>${project.build.directory}/${project.artifactId}-${project.version}-prod.jar</outputFile>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-    </build>
-</project>
-
                                                                                                          -

                                                                                                          跟其它Maven项目一样，我们首先定义了项目的GroupId，ArtifactId以及版本号，随后我们定义了两个属性，分别是：vertx.version，也就是Vert.x的版本号，此处我们使用最新的Vert.x版本，也就是3.4.1；以及main.class，也就是我们要使用的包含有main函数的主类。之后我们引入了两个Maven插件，分别是maven-compiler-plugin和maven-shade-plugin，前者用来将.java的源文件编译成.class的字节码文件，后者可将编译后的.class字节码文件打包成可执行的jar文件，俗称fat-jar。

                                                                                                          -

                                                                                                          然后我们在src/main/java/io/example目录下新建两个java文件，分别是Main.java和MyFirstVerticle.java，代码如下：

                                                                                                          -

                                                                                                          Main.java

                                                                                                          -
                                                                                                          package io.example;
-
-import io.vertx.core.Vertx;
-
-/**
- * Created by chengen on 26/04/2017.
- */
-public class Main {
-    public static void main(String[] args){
-        Vertx vertx = Vertx.vertx();
-
-        vertx.deployVerticle(MyFirstVerticle.class.getName());
-    }
-}
-
                                                                                                          -

                                                                                                          MyFirstVerticle.java

                                                                                                          -
                                                                                                          package io.example;
-
-import io.vertx.core.AbstractVerticle;
-
-/**
- * Created by chengen on 26/04/2017.
- */
-public class MyFirstVerticle extends AbstractVerticle {
-    public void start() {
-        vertx.createHttpServer().requestHandler(req -> {
-            req.response()
-                    .putHeader("content-type", "text/plain")
-                    .end("Hello World!");
-        }).listen(8080);
-    }
-}
-
                                                                                                          -

                                                                                                          然后用Maven的mvn package命令打包，随后在src的同级目录下会出现target目录，进入之后，会出现vert-example-1.0-SNAPSHOT.jar和vert-example-1.0-SNAPSHOT-prod.jar两个jar文件，后者是可执行文件，在有图形界面的操作系统中，您可双击执行，或者用以下命令：java -jar vert-example-1.0-SNAPSHOT-prod.jar执行。

                                                                                                          -

                                                                                                          随后打开浏览器，在浏览器的地址栏中输入：http://localhost:8080/ 便可看到熟悉的Hello World!啦。

                                                                                                          -

                                                                                                          启动器

                                                                                                          -

                                                                                                          我们也可以使用Launcher来替代Main类，这也是官方推荐的方式，在pom.xml中加入main.verticle属性，并将该属性值设置为maven-shade-plugin插件的manifestEntries的Main-Verticle对应的值，最后修改main.class为io.vertx.core.Launcher，修改后的pom.xml如下：

                                                                                                          -
                                                                                                          <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <groupId>io.example</groupId>
-    <artifactId>vertx-example</artifactId>
-    <version>1.0-SNAPSHOT</version>
-
-    <properties>
-        <vertx.version>3.4.1</vertx.version>
-        <main.class>io.vertx.core.Launcher</main.class>
-        <main.verticle>io.example.MainVerticle</main.verticle>
-    </properties>
-
-    <dependencies>
-        <dependency>
-            <groupId>io.vertx</groupId>
-            <artifactId>vertx-core</artifactId>
-            <version>${vertx.version}</version>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.3</version>
-                <configuration>
-                    <source>1.8</source>
-                    <target>1.8</target>
-                </configuration>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <version>2.4.2</version>
-                <executions>
-                    <execution>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                        <configuration>
-                            <transformers>
-                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
-                                    <manifestEntries>
-                                        <Main-Class>${main.class}</Main-Class>
-                                        <Main-Verticle>${main.verticle}</Main-Verticle>
-                                    </manifestEntries>
-                                </transformer>
-                            </transformers>
-                            <artifactSet />
-                            <outputFile>${project.build.directory}/${project.artifactId}-${project.version}-prod.jar</outputFile>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-    </build>
-</project>
-
                                                                                                          -

                                                                                                          然后在src/main/java/io/example目录下新增MainVerticle.java文件，代码如下：

                                                                                                          -
                                                                                                          package io.example;
-
-import io.vertx.core.AbstractVerticle;
-
-/**
- * Created by chengen on 26/04/2017.
- */
-public class MainVerticle extends AbstractVerticle {
-    public void start() {
-        vertx.deployVerticle(MyFirstVerticle.class.getName());
-    }
-}
-
                                                                                                          -

                                                                                                          然后重新打包后执行，便可再次看到Hello World!。

                                                                                                          -
                                                                                                          -

                                                                                                          请注意：重新打包之前，您可能需要清除之前编译后留下的文件，用mvn clean package命令打包。

                                                                                                          -
                                                                                                          -

                                                                                                          测试

                                                                                                          -

                                                                                                          下面我们将会介绍测试部分，首先引入两个新的测试依赖，修改后的pom.xml如下：

                                                                                                          -
                                                                                                          <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <groupId>io.example</groupId>
-    <artifactId>vertx-example</artifactId>
-    <version>1.0-SNAPSHOT</version>
-
-    <properties>
-        <vertx.version>3.4.1</vertx.version>
-        <main.class>io.vertx.core.Launcher</main.class>
-        <main.verticle>io.example.MainVerticle</main.verticle>
-    </properties>
-
-    <dependencies>
-        <dependency>
-            <groupId>io.vertx</groupId>
-            <artifactId>vertx-core</artifactId>
-            <version>${vertx.version}</version>
-        </dependency>
-
-        <dependency>
-            <groupId>io.vertx</groupId>
-            <artifactId>vertx-unit</artifactId>
-            <version>${vertx.version}</version>
-            <scope>test</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.12</version>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.3</version>
-                <configuration>
-                    <source>1.8</source>
-                    <target>1.8</target>
-                </configuration>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <version>2.4.2</version>
-                <executions>
-                    <execution>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                        <configuration>
-                            <transformers>
-                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
-                                    <manifestEntries>
-                                        <Main-Class>${main.class}</Main-Class>
-                                        <Main-Verticle>${main.verticle}</Main-Verticle>
-                                    </manifestEntries>
-                                </transformer>
-                            </transformers>
-                            <artifactSet />
-                            <outputFile>${project.build.directory}/${project.artifactId}-${project.version}-prod.jar</outputFile>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-    </build>
-</project>
-
                                                                                                          -

                                                                                                          随后在src/test/java/io/example目录下新增MyFirstVerticleTest.java文件：

                                                                                                          -
                                                                                                          package io.example;
-
-import io.vertx.core.Vertx;
-import io.vertx.ext.unit.Async;
-import io.vertx.ext.unit.TestContext;
-import io.vertx.ext.unit.junit.VertxUnitRunner;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-/**
- * Created by chengen on 26/04/2017.
- */
-@RunWith(VertxUnitRunner.class)
-public class MyFirstVerticleTest {
-
-    private Vertx vertx;
-
-    @Before
-    public void setUp(TestContext context) {
-        vertx = Vertx.vertx();
-        vertx.deployVerticle(MyFirstVerticle.class.getName(), context.asyncAssertSuccess());
-    }
-
-    @After
-    public void tearDown(TestContext context) {
-        vertx.close(context.asyncAssertSuccess());
-    }
-
-    @Test
-    public void testApplication(TestContext context) {
-        final Async async = context.async();
-
-        vertx.createHttpClient().getNow(8080, "localhost", "/", response -> {
-            response.handler(body -> {
-                context.assertTrue(body.toString().contains("Hello"));
-                async.complete();
-            });
-        });
-    }
-}
-
                                                                                                          -

                                                                                                          执行该测试案例便可得到期望的结果，理解测试代码并不难，留给读者作为练习。

                                                                                                          -

                                                                                                          至此，大功告成，欢迎来到Vert.x的世界。

                                                                                                          - - -
                                                                                                          - -
                                                                                                          -
                                                                                                          -
                                                                                                          - -

                                                                                                          results matching ""

                                                                                                          -
                                                                                                            - -
                                                                                                            -
                                                                                                            - -

                                                                                                            No results matching ""

                                                                                                            - -
                                                                                                            -
                                                                                                            -
                                                                                                            - -
                                                                                                            -
                                                                                                            - -
                                                                                                            - - - - - - - - - - - - - - -
                                                                                                            - - -
                                                                                                            - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/start/Start/comments-for-reader.md b/docs/start/Start/comments-for-reader.md deleted file mode 100644 index 5567aea..0000000 --- a/docs/start/Start/comments-for-reader.md +++ /dev/null @@ -1,44 +0,0 @@ -# Rules for Translation - -## 文档结构 - -每一篇文章分为五个部分：中英对照表、正文、引用、注解、总结； - -* **中英对照表**：文章中出现过的专用名词在中英对照表中说明，使用list方式呈现。 -* **正文**：正文位于第二部分，参考下边正文部分内容。 -* **引用**：如果系统中存在外部链接，使用引用格式处理，引用使用脚标（参考本文最下边）：\[1\]。 -* **注解**：注解中添加一些作者辅助理解的文字说明，正文保持干净整洁，注解可直接参考注解部分，使用圆括号：\(1\)。 -* **总结**：总结部分为本文的最终说明，Summary结束语。 - -## 文档状态 - -* 每一份文档在最开始的Title中加入状态后缀，只有Release的版本可省略不加。 -* 状态主要如下： - * Draft：草稿，翻译者完成文档翻译过后提交第一个版本为草稿，等待校对。 - * Review：正在校对的版本，一旦文档开始校对则将文档改动成Review状态，校对可交叉进行。 - * Internal：最终校对一致通过的版本，内部完善版本。 - * Release：最终发布版，没有明显错误，可大规模提供给读者阅读的版本。 - -## 正文规则 - -1. **中英文共存**：如果有些内容不容易翻译，并且使用频率不高，没有出现在中英对照表中，则在正文部分使用（E）格式提供英文原文，这种使用主要用于小频率单词且带有协变意义的单词部分，且标注时仅标注第一次出现的地方。 - 共享数据（Shared Data）——当然这个只是个例子，这里可以直接使用SharedData（Vert.X中的专用类）来表示。 - -2. **专用名词**：有些常用的专用名词不需要翻译，如：Java API，Vert.X Core等。 - -3. **补齐文字**：有些文本中英文的指代部分若已经完结，而中文部分不容易处理时直接使用括号补齐，正文本身内容保证“直译”为主，还原文档的原始状态。 - -4. **标点符号**：一句完整的话结尾尽可能不使用分号，而是用句号代替，并且注意将英文中有些逗号改成中文顿号。 - -5. **分类说明**：有些通篇英文是按照一点一点叙述，这种情况如果有需要使用list方式呈现，每一个知识点使用一个list进行说明。 - -6. **原文注释**：Vert.X的官方文档中有NOTE部分，这部分内容用引用Quote处理，格式统一为 请注意：之后文字斜体处理，如在文字中包含有Note字样，则翻译成注意：之后文字用斜体处理便可。 - -7. **代码注释**：代码中的注释部分需要翻译，有相当一部分注释包含了重要的指引讯息，故需要翻译。 - -## 引用 - -1. Enter footnote here - - - diff --git a/docs/testing/Testing.html b/docs/testing/Testing.html deleted file mode 100644 index 31897be..0000000 --- a/docs/testing/Testing.html +++ /dev/null @@ -1,1059 +0,0 @@ - - - - - - - Testing · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                                            -
                                                                                                            - - - - - - - - -
                                                                                                            - -
                                                                                                            - -
                                                                                                            - - - - - - - - -
                                                                                                            -
                                                                                                            - -
                                                                                                            -
                                                                                                            - -
                                                                                                            - -

                                                                                                            Vert.x Testing

                                                                                                            - - -
                                                                                                            - -
                                                                                                            -
                                                                                                            -
                                                                                                            - -

                                                                                                            results matching ""

                                                                                                            -
                                                                                                              - -
                                                                                                              -
                                                                                                              - -

                                                                                                              No results matching ""

                                                                                                              - -
                                                                                                              -
                                                                                                              -
                                                                                                              - -
                                                                                                              -
                                                                                                              - -
                                                                                                              - - - - - - - - - - - - - - -
                                                                                                              - - -
                                                                                                              - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/web/Web.html b/docs/web/Web.html deleted file mode 100644 index f6f7685..0000000 --- a/docs/web/Web.html +++ /dev/null @@ -1,2786 +0,0 @@ - - - - - - - Web · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                                              -
                                                                                                              - - - - - - - - -
                                                                                                              - -
                                                                                                              - -
                                                                                                              - - - - - - - - -
                                                                                                              -
                                                                                                              - -
                                                                                                              -
                                                                                                              - -
                                                                                                              - -

                                                                                                              Vert.x Web

                                                                                                              -

                                                                                                              中英对照表

                                                                                                              -
                                                                                                                -
                                                                                                              • Container：容器
                                                                                                                • -
                                                                                                              • Micro-service：微服务
                                                                                                                • -
                                                                                                              • Bridge：桥接
                                                                                                                • -
                                                                                                              • Router：路由器
                                                                                                                • -
                                                                                                              • Route：路由
                                                                                                                • -
                                                                                                              • Sub-Route: 子路由
                                                                                                                • -
                                                                                                              • Handler：处理器，某些特定的地方未翻译
                                                                                                                • -
                                                                                                              • Blocking：阻塞式
                                                                                                                • -
                                                                                                              • Context：上下文。非特别说明指代路由的上下文 routing context，不同于 Vert.x core 的 Context
                                                                                                                • -
                                                                                                              • Application：应用
                                                                                                                • -
                                                                                                              • Header：消息头
                                                                                                                • -
                                                                                                              • Body：消息体
                                                                                                                • -
                                                                                                              • MIME types：互联网媒体类型
                                                                                                                • -
                                                                                                              • Load-Balancer：负载均衡器
                                                                                                                • -
                                                                                                              • Socket：套接字
                                                                                                                • -
                                                                                                              • Mount：挂载
                                                                                                                • -
                                                                                                              -

                                                                                                              组件介绍

                                                                                                              -

                                                                                                              Vert.x Web 是一系列用于基于 Vert.x 构建 Web 应用的构建模块。

                                                                                                              -

                                                                                                              可以把它想象成一把构建现代的、可伸缩的 Web 应用的瑞士军刀。

                                                                                                              -

                                                                                                              Vert.x Core 提供了一系列底层的功能用于操作 HTTP，对于一部分应用来是足够的。

                                                                                                              -

                                                                                                              Vert.x Web 基于 Vert.x Core，提供了一系列更丰富的功能以便更容易地开发实际的 Web 应用。

                                                                                                              -

                                                                                                              它继承了 Vert.x 2.x 里的 Yoke 的特点，灵感来自于 Node.js 的框架 Express 和 Ruby 的框架 Sinatra 等等。

                                                                                                              -

                                                                                                              Vert.x Web 的设计是强大的，非侵入式的，并且是完全可插拔的。Vert.x Web 不是一个容器，您可以只使用您需要的部分。

                                                                                                              -

                                                                                                              您可以使用 Vert.x Web 来构建经典的服务端 Web 应用、RESTful 应用、实时的（服务端推送）Web 应用，或任何类型的您所能想到的 Web 应用。应用类型的选择取决于您，而不是 Vert.x Web。

                                                                                                              -

                                                                                                              Vert.x Web 非常适合编写 RESTful HTTP 微服务，但我们不强制您必须把应用实现成这样。

                                                                                                              -

                                                                                                              Vert.x Web 的一部分关键特性有：

                                                                                                              -
                                                                                                                -
                                                                                                              • 路由（基于方法(1)、路径等）
                                                                                                                • -
                                                                                                              • 基于正则表达式的路径匹配
                                                                                                                • -
                                                                                                              • 从路径中提取参数
                                                                                                                • -
                                                                                                              • 内容协商(2)
                                                                                                                • -
                                                                                                              • 处理消息体
                                                                                                                • -
                                                                                                              • 消息体的长度限制
                                                                                                                • -
                                                                                                              • 接收和解析 Cookie
                                                                                                                • -
                                                                                                              • Multipart 表单
                                                                                                                • -
                                                                                                              • Multipart 文件上传
                                                                                                                • -
                                                                                                              • 子路由
                                                                                                                • -
                                                                                                              • 支持本地会话和集群会话
                                                                                                                • -
                                                                                                              • 支持 CORS（跨域资源共享）
                                                                                                                • -
                                                                                                              • 错误页面处理器
                                                                                                                • -
                                                                                                              • HTTP基本认证
                                                                                                                • -
                                                                                                              • 基于重定向的认证
                                                                                                                • -
                                                                                                              • 授权处理器
                                                                                                                • -
                                                                                                              • 基于 JWT 的授权
                                                                                                                • -
                                                                                                              • 用户/角色/权限授权
                                                                                                                • -
                                                                                                              • 网页图标处理器
                                                                                                                • -
                                                                                                              • 支持服务端模板渲染，包括以下开箱即用的模板引擎：
                                                                                                                  -
                                                                                                                • Handlebars
                                                                                                                  • -
                                                                                                                • Jade
                                                                                                                  • -
                                                                                                                • MVEL
                                                                                                                  • -
                                                                                                                • Thymeleaf
                                                                                                                  • -
                                                                                                                • Apache FreeMarker
                                                                                                                  • -
                                                                                                                • Pebble
                                                                                                                  • -
                                                                                                                -
                                                                                                                • -
                                                                                                              • 响应时间处理器
                                                                                                                • -
                                                                                                              • 静态文件服务，包括缓存逻辑以及目录监听
                                                                                                                • -
                                                                                                              • 支持请求超时
                                                                                                                • -
                                                                                                              • 支持 SockJS
                                                                                                                • -
                                                                                                              • 桥接 Event-bus
                                                                                                                • -
                                                                                                              • CSRF 跨域请求伪造
                                                                                                                • -
                                                                                                              • 虚拟主机
                                                                                                                • -
                                                                                                              -

                                                                                                              Vert.x Web 的大多数特性被实现为了处理器（Handler），因此您随时可以实现您自己的处理器。我们预计随着时间的推移会有更多的处理器被实现。

                                                                                                              -

                                                                                                              我们会在本手册里讨论所有上述的特性。

                                                                                                              -

                                                                                                              使用 Vert.x Web

                                                                                                              -

                                                                                                              在使用 Vert.x Web 之前，需要为您的构建工具在描述文件中添加依赖项：

                                                                                                              -
                                                                                                                -
                                                                                                              • Maven（在 pom.xml 文件中）：
                                                                                                                • -
                                                                                                              -
                                                                                                              <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-web</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                                                              -
                                                                                                                -
                                                                                                              • Gradle（在 build.gradle 文件中）：
                                                                                                                • -
                                                                                                              -
                                                                                                              dependencies {
-  compile 'io.vertx:vertx-web:3.4.1'
-}
-
                                                                                                              -

                                                                                                              回顾 Vert.x Core 的 HTTP 服务端

                                                                                                              -

                                                                                                              Vert.x Web 使用了 Vert.x Core 暴露的 API，所以熟悉基于 Vert.x Core 编写 HTTP 服务端的基本概念是很有价值的。

                                                                                                              -

                                                                                                              Vert.x Core 的 HTTP 文档 有很多关于这方面的细节。

                                                                                                              -

                                                                                                              下面是一个使用 Vert.x Core 编写的 Hello World Web 服务器，暂不涉及 Vert.x Web：

                                                                                                              -
                                                                                                              HttpServer server = vertx.createHttpServer();
-
-server.requestHandler(request -> {
-
-  // 所有的请求都会调用这个处理器处理
-  HttpServerResponse response = request.response();
-  response.putHeader("content-type", "text/plain");
-
-  // 写入响应并结束处理
-  response.end("Hello World!");
-});
-
-server.listen(8080);
-
                                                                                                              -

                                                                                                              我们创建了一个 HTTP 服务端，并设置了一个请求处理器。所有的请求都会调用这个处理器处理。

                                                                                                              -

                                                                                                              当请求到达时，我们设置了响应的 Content Type 为 text/plain 并写入了 Hello World! 然后结束了处理。

                                                                                                              -

                                                                                                              之后，我们告诉服务器监听 8080 端口（默认的主机名是 localhost）。

                                                                                                              -

                                                                                                              您可以执行这段代码，并打开浏览器访问 http://localhost:8080 来验证它是否如预期的一样工作。

                                                                                                              -

                                                                                                              Vert.x Web 的基本概念

                                                                                                              -

                                                                                                              Router 是 Vert.x Web 的核心概念之一。它是一个维护了零或多个 Route 的对象。

                                                                                                              -

                                                                                                              Router 接收 HTTP 请求，并查找首个匹配该请求的 Route，然后将请求传递给这个 Route。

                                                                                                              -

                                                                                                              Route 可以持有一个与之关联的处理器用于接收请求。您可以通过这个处理器对请求做一些事情，然后结束响应或者把请求传递给下一个匹配的处理器。

                                                                                                              -

                                                                                                              以下是一个简单的路由示例：

                                                                                                              -
                                                                                                              HttpServer server = vertx.createHttpServer();
-
-Router router = Router.router(vertx);
-
-router.route().handler(routingContext -> {
-
-  // 所有的请求都会调用这个处理器处理
-  HttpServerResponse response = routingContext.response();
-  response.putHeader("content-type", "text/plain");
-
-  // 写入响应并结束处理
-  response.end("Hello World from Vert.x-Web!");
-});
-
-server.requestHandler(router::accept).listen(8080);
-
                                                                                                              -

                                                                                                              它做了和上文使用 Vert.x Core 实现的 HTTP 服务器基本相同的事情，只是这一次换成了 Vert.x Web。

                                                                                                              -

                                                                                                              和上文一样，我们创建了一个 HTTP 服务器，然后创建了一个 Router。在这之后，我们创建了一个没有匹配条件的 Route，这个 route 会匹配所有到达这个服务器的请求。

                                                                                                              -

                                                                                                              之后，我们为这个 route 指定了一个处理器，所有的请求都会调用这个处理器处理。

                                                                                                              -

                                                                                                              调用处理器的参数是一个 RoutingContext 对象。它不仅包含了 Vert.x 中标准的 HttpServerRequest 和 -HttpServerResponse，还包含了各种用于简化 Vert.x Web 使用的东西。

                                                                                                              -

                                                                                                              每一个被路由的请求对应一个唯一的 RoutingContext，这个实例会被传递到所有处理这个请求的处理器上。

                                                                                                              -

                                                                                                              当我们创建了处理器之后，我们设置了 HTTP 服务器的请求处理器，使所有的请求都通过 accept(3)处理。

                                                                                                              -

                                                                                                              这些是最基本的，下面我们来看一下更多的细节：

                                                                                                              -

                                                                                                              处理请求并调用下一个处理器

                                                                                                              -

                                                                                                              当 Vert.x Web 决定路由一个请求到匹配的 route 上，它会使用一个 RoutingContext 调用对应处理器。

                                                                                                              -

                                                                                                              如果您不在处理器里结束这个响应，您需要调用 next 方法让其他匹配的 Route 来处理请求（如果有）。

                                                                                                              -

                                                                                                              您不需要在处理器执行完毕时调用 next 方法。您可以在之后您需要的时间点调用它：

                                                                                                              -
                                                                                                              Route route1 = router.route("/some/path/").handler(routingContext -> {
-
-  HttpServerResponse response = routingContext.response();
-  // 由于我们会在不同的处理器里写入响应，因此需要启用分块传输
-  // 仅当需要通过多个处理器输出响应时才需要
-  response.setChunked(true);
-
-  response.write("route1\n");
-
-  // 5 秒后调用下一个处理器
-  routingContext.vertx().setTimer(5000, tid -> routingContext.next());
-});
-
-Route route2 = router.route("/some/path/").handler(routingContext -> {
-
-  HttpServerResponse response = routingContext.response();
-  response.write("route2\n");
-
-  // 5 秒后调用下一个处理器
-  routingContext.vertx().setTimer(5000, tid ->  routingContext.next());
-});
-
-Route route3 = router.route("/some/path/").handler(routingContext -> {
-
-  HttpServerResponse response = routingContext.response();
-  response.write("route3");
-
-  // 结束响应
-  routingContext.response().end();
-});
-
                                                                                                              -

                                                                                                              在上述的例子中，route1 向响应里写入了数据，5秒之后 route2 向响应里写入了数据，再5秒之后 route3 向响应里写入了数据并结束了响应。

                                                                                                              -

                                                                                                              注意，所有发生的这些没有线程阻塞。

                                                                                                              -

                                                                                                              使用阻塞式处理器

                                                                                                              -

                                                                                                              某些时候您可能需要在处理器里执行一些需要阻塞 Event Loop 的操作，比如调用某个传统的阻塞式 API 或者执行密集计算。

                                                                                                              -

                                                                                                              您不能在普通的处理器里执行这些操作，所以我们提供了向 Route 设置阻塞式处理器的能力。

                                                                                                              -

                                                                                                              阻塞式处理器和普通处理器的区别是 Vert.x 会使用 Worker Pool 中的线程而不是 Event Loop 线程来处理请求。

                                                                                                              -

                                                                                                              您可以使用 blockingHandler 方法来设置阻塞式处理器。下面是一个例子：

                                                                                                              -
                                                                                                              router.route().blockingHandler(routingContext -> {
-
-  // 执行某些同步的耗时操作
-  service.doSomethingThatBlocks();
-
-  // 调用下一个处理器
-  routingContext.next();
-
-});
-
                                                                                                              -

                                                                                                              默认情况下在一个 Context（Vert.x Core 的 Context，例如同一个 Verticle 实例） 上执行的所有阻塞式处理器的执行是顺序的，也就意味着只有一个处理器执行完了才会继续执行下一个。 -如果您不关心执行的顺序，并且不介意阻塞式处理器以并行的方式执行，您可以在调用 blockingHandler 方法时将 ordered 设置为 false。

                                                                                                              -

                                                                                                              注意，如果您需要在一个阻塞处理器中处理一个 multipart 类型的表单数据，您需要首先使用一个非阻塞的处理器来调用 setExpectMultipart(true)。 下面是一个例子：

                                                                                                              -
                                                                                                              router.post("/some/endpoint").handler(ctx -> {
-  ctx.request().setExpectMultipart(true);
-  ctx.next();
-}).blockingHandler(ctx -> {
-  // 执行某些阻塞操作
-});
-
                                                                                                              -

                                                                                                              基于精确路径的路由

                                                                                                              -

                                                                                                              可以将 Route 设置为只匹配指定的 URI。在这种情况下它只会匹配路径和该路径一致的请求。

                                                                                                              -

                                                                                                              在下面这个例子中会被路径为 /some/path/ 的请求调用。我们会忽略结尾的 /，所以路径 /some/path 或者 /some/path// 的请求也是匹配的：

                                                                                                              -
                                                                                                              Route route = router.route().path("/some/path/");
-
-route.handler(routingContext -> {
-  // 所有以下路径的请求都会调用这个处理器:
-
-  // `/some/path`
-  // `/some/path/`
-  // `/some/path//`
-  //
-  // 但不包括：
-  // `/some/path/subdir`
-});
-
                                                                                                              -

                                                                                                              基于路径前缀的路由

                                                                                                              -

                                                                                                              您经常需要为所有以某些路径开始的请求设置 Route。您可以使用正则表达式来实现，但更简单的方式是在声明 Route 的路径时使用一个 * 作为结尾。

                                                                                                              -

                                                                                                              在下面的例子中处理器会匹配所有 URI 以 /some/path 开头的请求。

                                                                                                              -

                                                                                                              例如 /some/path/foo.html 和 /some/path/otherdir/blah.css 都会匹配。

                                                                                                              -
                                                                                                              Route route = router.route().path("/some/path/*");
-
-route.handler(routingContext -> {
-  // 所有路径以 `/some/path/` 开头的请求都会调用这个处理器处理，例如：
-
-  // `/some/path`
-  // `/some/path/`
-  // `/some/path/subdir`
-  // `/some/path/subdir/blah.html`
-  //
-  // 但不包括：
-  // `/some/bath`
-});
-
                                                                                                              -

                                                                                                              也可以在创建 Route 的时候指定任意的路径：

                                                                                                              -
                                                                                                              Route route = router.route("/some/path/*");
-
-route.handler(routingContext -> {
-  // 这个路由器的调用规则和上面的例子一样
-});
-
                                                                                                              -

                                                                                                              捕捉路径参数

                                                                                                              -

                                                                                                              可以通过占位符声明路径参数并在处理请求时通过 params 方法获取：

                                                                                                              -

                                                                                                              以下是一个例子：

                                                                                                              -
                                                                                                              Route route = router.route(HttpMethod.POST, "/catalogue/products/:producttype/:productid/");
-
-route.handler(routingContext -> {
-
-  String productType = routingContext.request().getParam("producttype");
-  String productID = routingContext.request().getParam("productid");
-
-  // 执行某些操作...
-});
-
                                                                                                              -

                                                                                                              占位符由 : 和参数名构成。参数名由字母、数字和下划线构成。

                                                                                                              -

                                                                                                              在上述的例子中，如果一个 POST 请求的路径为 /catalogue/products/tools/drill123/，那么会匹配这个 Route，并且会接收到参数 productType 的值为 tools，参数 productID 的值为 drill123。

                                                                                                              -

                                                                                                              基于正则表达式的路由

                                                                                                              -

                                                                                                              正则表达式同样也可用于在路由时匹配 URI 路径。

                                                                                                              -
                                                                                                              Route route = router.route().pathRegex(".*foo");
-
-route.handler(routingContext -> {
-
-  // 以下路径的请求都会调用这个处理器:
-
-  // /some/path/foo
-  // /foo
-  // /foo/bar/wibble/foo
-  // /bar/foo
-
-  // 但不包括:
-  // /bar/wibble
-});
-
                                                                                                              -

                                                                                                              或者在创建 Route 时指定正则表达式：

                                                                                                              -
                                                                                                              Route route = router.routeWithRegex(".*foo");
-
-route.handler(routingContext -> {
-
-  // 这个路由器的调用规则和上面的例子一样
-
-});
-
                                                                                                              -

                                                                                                              通过正则表达式捕捉路径参数

                                                                                                              -

                                                                                                              您也可以捕捉通过正则表达式声明的路径参数，下面是一个例子：

                                                                                                              -
                                                                                                              Route route = router.routeWithRegex(".*foo");
-
-// 这个正则表达式可以匹配路径类似于 `/foo/bar` 的请求
-// `foo` 可以通过参数 param0 获取，`bar` 可以通过参数 param1 获取
-route.pathRegex("\\/([^\\/]+)\\/([^\\/]+)").handler(routingContext -> {
-
-  String productType = routingContext.request().getParam("param0");
-  String productID = routingContext.request().getParam("param1");
-
-  // 执行某些操作
-});
-
                                                                                                              -

                                                                                                              在上面的例子中，如果一个请求的路径为 /tools/drill123/，那么会匹配这个 route，并且会接收到参数 productType 的值为 tools，参数 productID 的值为 drill123。

                                                                                                              -

                                                                                                              基于 HTTP Method 的路由

                                                                                                              -

                                                                                                              默认的，Route 会匹配所有 HTTP Method。

                                                                                                              -

                                                                                                              如果您需要 Route 只匹配指定的 HTTP Method，您可以使用 method 方法。

                                                                                                              -
                                                                                                              Route route = router.route().method(HttpMethod.POST);
-
-route.handler(routingContext -> {
-
-  // 所有的 POST 请求都会调用这个处理器
-
-});
-
                                                                                                              -

                                                                                                              或者可以在创建这个 Route 时和路径一起指定：

                                                                                                              -
                                                                                                              Route route = router.route(HttpMethod.POST, "/some/path/");
-
-route.handler(routingContext -> {
-
-  // 所有路径为 `/some/path/` 的 POST 请求都会调用这个处理器
-
-});
-
                                                                                                              -

                                                                                                              如果您想让 Route 指定的 HTTP Method ，您也可以使用对应的 get、post、put 等方法。下面是一个例子：

                                                                                                              -
                                                                                                              router.get().handler(routingContext -> {
-
-  // 所有 GET 请求都会调用这个处理器
-
-});
-
-router.get("/some/path/").handler(routingContext -> {
-
-  // 所有路径为 `/some/path/` 的 GET 请求都会调用这个处理器
-
-});
-
-router.getWithRegex(".*foo").handler(routingContext -> {
-
-  // 所有路径以 `foo` 结尾的 GET 请求都会调用这个处理器
-
-});
-
                                                                                                              -

                                                                                                              如果您想要让一个路由匹配不止一个 HTTP Method，您可以调用 method 方法多次：

                                                                                                              -
                                                                                                              Route route = router.route().method(HttpMethod.POST).method(HttpMethod.PUT);
-
-route.handler(routingContext -> {
-
-  // 所有 GET 或 POST 请求都会调用这个处理器
-
-});
-
                                                                                                              -

                                                                                                              路由顺序

                                                                                                              -

                                                                                                              默认的路由的匹配顺序与添加到 Router 的顺序一致。

                                                                                                              -

                                                                                                              当一个请求到达时，Router 会一步一步检查每一个 Route 是否匹配，如果匹配则对应的处理器会被调用。

                                                                                                              -

                                                                                                              如果处理器随后调用了 next，则下一个匹配的 Route 对应的处理器（如果有）会被调用，以此类推。

                                                                                                              -

                                                                                                              下面的例子展示了这个过程：

                                                                                                              -
                                                                                                              Route route1 = router.route("/some/path/").handler(routingContext -> {
-
-  HttpServerResponse response = routingContext.response();
-  // 由于我们会在不同的处理器里写入响应，因此需要启用分块传输
-  // 仅当需要通过多个处理器输出响应时才需要
-  response.setChunked(true);
-
-  response.write("route1\n");
-
-  // 调用下一个匹配的 route
-  routingContext.next();
-});
-
-Route route2 = router.route("/some/path/").handler(routingContext -> {
-
-  HttpServerResponse response = routingContext.response();
-  response.write("route2\n");
-
-  // 调用下一个匹配的 route
-  routingContext.next();
-});
-
-Route route3 = router.route("/some/path/").handler(routingContext -> {
-
-  HttpServerResponse response = routingContext.response();
-  response.write("route3");
-
-  // 结束响应
-  routingContext.response().end();
-});
-
                                                                                                              -

                                                                                                              在上面的例子里，响应中会包含：

                                                                                                              -
                                                                                                              route1
-route2
-route3
-

                                                                                                              对于任意以 /some/path 开头的请求，Route会被依次调用。

                                                                                                              -

                                                                                                              如果您想覆盖路由默认的顺序，您可以通过 order 方法为每一个路由指定一个 integer 值。

                                                                                                              -

                                                                                                              当 Route 被创建时 order 会被赋值为其被添加到 Router 时的序号，例如第一个 Route 是 0，第二个是 1，以此类推。

                                                                                                              -

                                                                                                              您可以使用特定的顺序值覆盖默认的顺序。如果您需要确保一个 Route 在顺序 0 的 Route 之前执行，可以将其指定为负值。

                                                                                                              -

                                                                                                              让我们改变 route2 的值使其能在 route1 之前执行：

                                                                                                              -
                                                                                                              Route route1 = router.route("/some/path/").handler(routingContext -> {
-
-  HttpServerResponse response = routingContext.response();
-  response.write("route1\n");
-
-  // 调用下一个匹配的 route
-  routingContext.next();
-});
-
-Route route2 = router.route("/some/path/").handler(routingContext -> {
-
-  HttpServerResponse response = routingContext.response();
-  // 由于我们会在不同的处理器里写入响应，因此需要启用分块传输
-  // 仅当需要通过多个处理器输出响应时才需要
-  response.setChunked(true);
-
-  response.write("route2\n");
-
-  // 调用下一个匹配的 route
-  routingContext.next();
-});
-
-Route route3 = router.route("/some/path/").handler(routingContext -> {
-
-  HttpServerResponse response = routingContext.response();
-  response.write("route3");
-
-  // 结束响应
-  routingContext.response().end();
-});
-
-// 更改 route2 的顺序使其可以在 route1 之前执行
-route2.order(-1);
-
                                                                                                              -

                                                                                                              此时响应内容会是：

                                                                                                              -
                                                                                                              route2
-route1
-route3
-
                                                                                                              -

                                                                                                              如果两个匹配的 Route 有相同的顺序值，则会按照添加它们的顺序来调用。

                                                                                                              -

                                                                                                              您也可以通过 last 方法来指定 Route 最后执行。

                                                                                                              -

                                                                                                              基于请求媒体类型（MIME types）的路由

                                                                                                              -

                                                                                                              您可以使用 consumes 方法指定 Route 匹配对应 MIME 类型的请求。

                                                                                                              -

                                                                                                              在这种情况下，如果请求中包含了消息头 content-type 声明了消息体的 MIME 类型。则它会与通过 consumes 方法声明的值进行比较。

                                                                                                              -

                                                                                                              一般来说，consumes 描述了处理器能够处理的 MIME 类型。

                                                                                                              -

                                                                                                              MIME Type 的匹配过程是精确的：

                                                                                                              -
                                                                                                              router.route().consumes("text/html").handler(routingContext -> {
-
-  // 所有 `content-type` 消息头的值为 `text/html` 的请求会调用这个处理器
-
-});
-
                                                                                                              -

                                                                                                              也可以匹配多个精确的值（MIME 类型）：

                                                                                                              -
                                                                                                              router.route().consumes("text/html").consumes("text/plain").handler(routingContext -> {
-
-  // 所有 `content-type` 消息头的值为 `text/html` 或 `text/plain` 的请求会调用这个处理器
-
-});
-
                                                                                                              -

                                                                                                              基于通配符的子类型匹配也是支持的：

                                                                                                              -
                                                                                                              router.route().consumes("text/*").handler(routingContext -> {
-
-  // 所有 `content-type` 消息头的顶级类型为 `text` 的请求会调用这个处理器
-  // 例如 `content-type` 消息头设置为 `text/html` 或 `text/plain` 都会匹配
-
-});
-
                                                                                                              -

                                                                                                              您也可以用通配符匹配顶级的类型（top level type）：

                                                                                                              -
                                                                                                              router.route().consumes("*/json").handler(routingContext -> {
-
-  // 所有 `content-type` 消息头的子类型为 `json` 的请求会调用这个处理器
-  // 例如 `content-type` 消息头设置为 `text/json` 或 `application/json` 都会匹配
-
-});
-
                                                                                                              -

                                                                                                              如果您没有在 consumers 中包含 /，则意味着是一个子类型（sub-type）。

                                                                                                              -

                                                                                                              基于客户端可接受媒体类型（MIME types acceptable）的路由

                                                                                                              -

                                                                                                              HTTP 的 accept 消息头用于表示哪些 MIME 类型的响应是客户端可接受的。

                                                                                                              -

                                                                                                              一个 accept 消息头可以包含多个用 , 分隔的 MIME 类型。

                                                                                                              -

                                                                                                              如果在 accept 消息头中匹配了不止一个 MIME 类型，则可以为每一个 MIME 类型追加一个 q 值来表示权重。q 的取值范围由 0 到 1.0。缺省值为 1.0。

                                                                                                              -

                                                                                                              例如，下面的 accept 消息头表示客户端只接受 text/plain 类型的响应。

                                                                                                              -
                                                                                                              Accept: text/plain
-

                                                                                                              以下 accept 表示客户端会无偏好地接受 text/plain 或 text/html。

                                                                                                              -
                                                                                                              Accept: text/plain, text/html
-

                                                                                                              以下 accept 表示客户端会接受 text/plain 或 text/html，但会更倾向于 text/html，因为其具有更高的 q 值（默认值为 1.0）。

                                                                                                              -
                                                                                                              Accept: text/plain; q=0.9, text/html
-

                                                                                                              在这种情况下，如果服务器可以同时提供 text/plain 和 text/html，它需要提供 text/html。

                                                                                                              -

                                                                                                              您可以使用 produces 来定义 Route 可以提供哪些 MIME 类型。例如以下处理器可以提供 MIME 类型为 application/json 的响应。

                                                                                                              -
                                                                                                              router.route().produces("application/json").handler(routingContext -> {
-
-  HttpServerResponse response = routingContext.response();
-  response.putHeader("content-type", "application/json");
-  response.write(someJSON).end();
-
-});
-
                                                                                                              -

                                                                                                              在这种情况下这个 Route 会匹配任何 accept 消息头匹配 application/json 的请求。例如：

                                                                                                              -
                                                                                                              Accept: application/json
-Accept: application/*
-Accept: application/json, text/html
-Accept: application/json;q=0.7, text/html;q=0.8, text/plain
-

                                                                                                              您也可以标记您的 Route 提供不止一种 MIME 类型。在这种情况下，您可以使用 getAcceptableContentType 方法来找出真正被接受的 MIME 类型。

                                                                                                              -
                                                                                                              router.route().produces("application/json").produces("text/html").handler(routingContext -> {
-
-  HttpServerResponse response = routingContext.response();
-
-  // 获取最终匹配到的 MIME type
-  String acceptableContentType = routingContext.getAcceptableContentType();
-
-  response.putHeader("content-type", acceptableContentType);
-  response.write(whatever).end();
-});
-
                                                                                                              -

                                                                                                              在上述例子中，如果您发送一个包含如下 accept 消息头的请求：

                                                                                                              -
                                                                                                              Accept: application/json; q=0.7, text/html
-

                                                                                                              那么会匹配上面的 Route，并且 acceptableContentType 的值会是 text/html 因为其具有更高的 q 值。

                                                                                                              -

                                                                                                              组合路由规则

                                                                                                              -

                                                                                                              您可以用不同的方式来组合上述的路由规则，例如：

                                                                                                              -
                                                                                                              Route route = router.route(HttpMethod.PUT, "myapi/orders")
-                    .consumes("application/json")
-                    .produces("application/json");
-
-route.handler(routingContext -> {
-
-  // 这会匹配所有路径以 `/myapi/orders` 开头，`content-type` 值为 `application/json` 并且 `accept` 值为 `application/json` 的 PUT 请求
-
-});
-
                                                                                                              -

                                                                                                              启用和停用 Route

                                                                                                              -

                                                                                                              您可以通过 disable 方法来停用一个 Route。停用的 Route 在匹配时会被忽略。

                                                                                                              -

                                                                                                              您可以用 enable 方法来重新启用它。

                                                                                                              -

                                                                                                              上下文数据

                                                                                                              -

                                                                                                              在请求的生命周期中，您可以通过路由上下文 RoutingContext 来维护任何您希望在处理器之间共享的数据。

                                                                                                              -

                                                                                                              以下是一个例子，一个处理器设置了一些数据，另一个处理器获取它：

                                                                                                              -

                                                                                                              您可以使用 put 方法向上下文设置任何对象，使用 get 方法从上下文中获取任何对象。

                                                                                                              -

                                                                                                              一个路径为 /some/path/other 的请求会同时匹配两个 Route:

                                                                                                              -
                                                                                                              router.get("/some/path/*").handler(routingContext -> {
-
-  routingContext.put("foo", "bar");
-  routingContext.next();
-
-});
-
-router.get("/some/path/other").handler(routingContext -> {
-
-  String bar = routingContext.get("foo");
-  // 执行某些操作
-  routingContext.response().end();
-
-});
-
                                                                                                              -

                                                                                                              另一种您可以访问上下文数据的方式是使用 data 方法。

                                                                                                              -

                                                                                                              转发

                                                                                                              -

                                                                                                              (4) 到目前为止，通过上述的路由机制您可以顺序地处理您的请求，但某些情况下您可能需要回退。由于处理器的顺序是动态的，路由上下文并没有暴露出任何关于前一个或后一个处理器的信息。唯一的方式是在当前的 Router 里重启 Route的流程。

                                                                                                              -
                                                                                                              router.get("/some/path").handler(routingContext -> {
-
-  routingContext.put("foo", "bar");
-  routingContext.next();
-
-});
-
-router.get("/some/path/B").handler(routingContext -> {
-  routingContext.response().end();
-});
-
-router.get("/some/path").handler(routingContext -> {
-  routingContext.reroute("/some/path/B");
-});
-
                                                                                                              -

                                                                                                              从代码中可以看到，如果一个到达的请求包含路径 /some/path，首先第一个处理器向上下文添加了值，然后路由到了下一个处理器。第二个处理器转发到了路径 /some/path/B，该处理器最后结束了响应。

                                                                                                              -

                                                                                                              您可以使用路径或者同时使用路径和方法来转发。注意，基于方法的重定向可能会带来安全问题，例如将一个通常安全的 GET 请求可能会成为 DELETE。

                                                                                                              -

                                                                                                              也可以在失败处理器中转发。由于转发的性质，在这种情况下，当前的状态码和失败原因也会被重置。因此在转发后的处理器应该根据需要生成正确的状态码，例如：

                                                                                                              -
                                                                                                              router.get("/my-pretty-notfound-handler").handler(ctx -> {
-  ctx.response()
-          .setStatusCode(404)
-          .end("NOT FOUND fancy html here!!!");
-});
-
-router.get().failureHandler(ctx -> {
-  if (ctx.statusCode() == 404) {
-    ctx.reroute("/my-pretty-notfound-handler");
-  } else {
-    ctx.next();
-  }
-});
-
                                                                                                              -

                                                                                                              子路由

                                                                                                              -

                                                                                                              当您有很多处理器的情况下，合理的方式是将它们分隔为多个 Router。这也有利于您在多个不用的应用中通过设置不同的根路径来复用处理器。

                                                                                                              -

                                                                                                              您可以通过将一个 Router 挂载到另一个 Router 的挂载点上来实现。挂载的 Router 被称为子路由（Sub Router）。Sub router 上也可以挂载其他的 sub router。因此，您可以包含若干级别的 sub router。

                                                                                                              -

                                                                                                              让我们看一个 sub router 挂载到另一个 Router 上的例子：

                                                                                                              -

                                                                                                              这个 sub router 维护了一系列处理器，对应了一个虚构的 REST API。我们会将它挂载到另一个 Router 上。 -例子忽略了 REST API 的具体实现：

                                                                                                              -
                                                                                                              Router restAPI = Router.router(vertx);
-
-restAPI.get("/products/:productID").handler(rc -> {
-
-  // TODO 查找产品信息
-  rc.response().write(productJSON);
-
-});
-
-restAPI.put("/products/:productID").handler(rc -> {
-
-  // TODO 添加新的产品
-  rc.response().end();
-
-});
-
-restAPI.delete("/products/:productID").handler(rc -> {
-
-  // TODO 删除产品
-  rc.response().end();
-
-});
-
                                                                                                              -

                                                                                                              如果这个 Router 是一个顶级的 Router，那么例如 /products/product1234 这种 URL 的 GET/PUT/DELETE 请求都会调用这个 API。

                                                                                                              -

                                                                                                              如果我们已经有了一个网站包含以下的 Router：

                                                                                                              -
                                                                                                              Router mainRouter = Router.router(vertx);
-
-// 处理静态资源
-mainRouter.route("/static/*").handler(myStaticHandler);
-
-mainRouter.route(".*\\.templ").handler(myTemplateHandler);
-
                                                                                                              -

                                                                                                              我们可以将这个 sub router 通过一个挂载点挂载到主 router 上，这个例子使用了 /preoductAPI：

                                                                                                              -
                                                                                                              mainRouter.mountSubRouter("/productsAPI", restAPI);
-
                                                                                                              -

                                                                                                              这意味着这个 REST API 现在可以通过这种路径访问：/productsAPI/products/product1234。

                                                                                                              -

                                                                                                              本地化

                                                                                                              -

                                                                                                              Vert.x Web 解析 Accept-Language 消息头并提供了一些识别客户端偏好的语言，以及提供通过 quality 排序的语言偏好列表的方法。

                                                                                                              -
                                                                                                              Route route = router.get("/localized").handler( rc -> {
-  //虽然通过一个 switch 循环有点奇怪，我们必须按顺序选择正确的本地化方式
-  for (LanguageHeader language : rc.acceptableLanguages()) {
-    switch (language.tag()) {
-      case "en":
-        rc.response().end("Hello!");
-        return;
-      case "fr":
-        rc.response().end("Bonjour!");
-        return;
-      case "pt":
-        rc.response().end("Olá!");
-        return;
-      case "es":
-        rc.response().end("Hola!");
-        return;
-    }
-  }
-  // 我们不知道用户的语言，因此返回这个信息：
-  rc.response().end("Sorry we don't speak: " + rc.preferredLocale());
-});
-
                                                                                                              -

                                                                                                              方法 acceptableLocales 会返回客户端能够理解的排序好的语言列表。 -如果您只关心用户偏好的语言，那么使用 preferredLocale 会返回列表的第一个元素。 -如果用户没有提供，则返回空。

                                                                                                              -

                                                                                                              默认的 404 处理器

                                                                                                              -

                                                                                                              如果没有为请求匹配到任何路由，Vert.x Web 会声明一个 404 错误。

                                                                                                              -

                                                                                                              这可以被您自己实现的处理器处理，或者被我们提供的专用错误处理器（failureHandler）处理。 -如果没有提供错误处理器，Vert.x Web 会发送一个基本的 404 (Not Found) 响应。

                                                                                                              -

                                                                                                              错误处理

                                                                                                              -

                                                                                                              和设置处理器处理请求一样，您可以设置处理器处理路由过程中的失败。

                                                                                                              -

                                                                                                              失败处理器和普通的处理器具有完全一样的路由匹配规则。

                                                                                                              -

                                                                                                              例如您可以提供一个失败处理器只处理在某个路径上发生的失败，或某个 HTTP 方法。

                                                                                                              -

                                                                                                              这允许您在应用的不同部分设置不同的失败处理器。

                                                                                                              -

                                                                                                              下面例子中的失败处理器只会在路由路径为 /somepath/ 的 GET 请求失败时被调用：

                                                                                                              -
                                                                                                              Route route = router.get("/somepath/*");
-
-route.failureHandler(frc -> {
-
-  // 如果在处理路径以 `/somepath/` 开头的请求过程中发生错误，会调用这个处理器
-
-});
-
                                                                                                              -

                                                                                                              当一个处理器抛出异常，或者一个处理器通过了 fail 方法指定了 HTTP 状态码时，会执行路由的失败处理。

                                                                                                              -

                                                                                                              从一个处理器捕捉到异常时会标记一个状态码为 500 的错误。

                                                                                                              -

                                                                                                              在处理这个错误时，RoutingContext 会被传递到失败处理器里，失败处理器可以通过获取到的错误或错误编码来构造失败的响应内容。

                                                                                                              -
                                                                                                              Route route1 = router.get("/somepath/path1/");
-
-route1.handler(routingContext -> {
-
-  // 这里抛出一个 RuntimeException
-  throw new RuntimeException("something happened!");
-
-});
-
-Route route2 = router.get("/somepath/path2");
-
-route2.handler(routingContext -> {
-  // 这里故意将请求处理为失败状态
-  // 例如 403 - 禁止访问
-  routingContext.fail(403);
-
-});
-
-// 定义一个失败处理器，上述的处理器发生错误时会调用这个处理器
-Route route3 = router.get("/somepath/*");
-
-route3.failureHandler(failureRoutingContext -> {
-
-  int statusCode = failureRoutingContext.statusCode();
-
-  // 对于 RuntimeException 状态码会是 500，否则是 403
-  HttpServerResponse response = failureRoutingContext.response();
-  response.setStatusCode(statusCode).end("Sorry! Not today");
-
-});
-
                                                                                                              -

                                                                                                              某些情况下失败处理器会由于使用了不支持的字符集作为状态消息而导致错误。在这种情况下，Vert.x Web 会将状态消息替换为状态码的默认消息。 -这是为了保证 HTTP 协议的语义，而不至于崩溃并断开 socket 导致协议运行的不完整。

                                                                                                              -

                                                                                                              处理请求消息体

                                                                                                              -

                                                                                                              您可以使用消息体处理器 BodyHandler 来获取请求的消息体，限制消息体大小，或者处理文件上传。

                                                                                                              -

                                                                                                              您需要保证消息体处理器能够匹配到所有您需要这个功能的请求。

                                                                                                              -

                                                                                                              由于它需要在所有异步执行之前处理请求的消息体，因此这个处理器要尽可能早地设置到 router 上。

                                                                                                              -
                                                                                                              router.route().handler(BodyHandler.create());
-
                                                                                                              -

                                                                                                              获取请求的消息体

                                                                                                              -

                                                                                                              如果您知道消息体的类型是 JSON，您可以使用 getBodyAsJson；如果您知道它的类型是字符串，您可以使用 getBodyAsString；否则可以通过 getBody 作为 Buffer 来处理。

                                                                                                              -

                                                                                                              限制消息体大小

                                                                                                              -

                                                                                                              如果要限制请求消息体的大小，可以在创建消息体处理器时使用 setBodyLimit 来指定消息体的最大字节数。这对于规避由于过大的消息体导致的内存溢出的问题很有用。

                                                                                                              -

                                                                                                              如果尝试发送一个大于最大值的消息体，则会得到一个 HTTP 状态码 413 - Request Entity Too Large 的响应。

                                                                                                              -

                                                                                                              默认的没有消息体大小限制。

                                                                                                              -

                                                                                                              合并表单属性

                                                                                                              -

                                                                                                              消息体处理器默认地会合并表单属性到请求的参数里。 -如果您不需要这个行为，可以通过 setMergeFormAttributes 来禁用。

                                                                                                              -

                                                                                                              处理文件上传

                                                                                                              -

                                                                                                              消息体处理器也可以用于处理 Multipart 的文件上传。

                                                                                                              -

                                                                                                              当消息体处理器匹配到请求时，所有上传的文件会被自动地写入到上传目录中，默认的该目录为 file-uploads。

                                                                                                              -

                                                                                                              每一个上传的文件会被自动生成一个文件名，并可以通过 RoutingContext 的 fileUploads 来获得。

                                                                                                              -

                                                                                                              以下是一个例子：

                                                                                                              -
                                                                                                              router.route().handler(BodyHandler.create());
-
-router.post("/some/path/uploads").handler(routingContext -> {
-
-  Set<FileUpload> uploads = routingContext.fileUploads();
-
-  // 执行上传处理
-
-});
-
                                                                                                              -

                                                                                                              每一个上传的文件通过一个 FileUpload 对象来描述，通过这个对象可以获得名称、文件名、大小等属性。

                                                                                                              - -

                                                                                                              Vert.x Web 通过 Cookie 处理器 CookieHandler 来支持 cookie。

                                                                                                              -

                                                                                                              您需要保证 cookie 处理器器能够匹配到所有您需要这个功能的请求。

                                                                                                              -
                                                                                                              router.route().handler(CookieHandler.create());
-
                                                                                                              - -

                                                                                                              您可以使用 getCookie 来通过名称获取 cookie 值，或者使用 cookies 获取整个集合。

                                                                                                              -

                                                                                                              使用 removeCookie 来删除 cookie。

                                                                                                              -

                                                                                                              使用 addCookie 来添加 cookie。

                                                                                                              -

                                                                                                              当向响应中写入响应消息头时，cookie 的集合会自动被回写到响应里，这样浏览器就可以存储下来。

                                                                                                              -

                                                                                                              cookie 是使用 Cookie 对象来表述的。您可以通过它来获取名称、值、域名、路径或 cookie 的其他属性。

                                                                                                              -

                                                                                                              以下是一个查询和添加 cookie 的例子：

                                                                                                              -
                                                                                                              router.route().handler(CookieHandler.create());
-
-router.route("some/path/").handler(routingContext -> {
-
-  Cookie someCookie = routingContext.getCookie("mycookie");
-  String cookieValue = someCookie.getValue();
-
-  // 使用 cookie 执行某些操作
-
-  // 添加一个 cookie，会自动回写到响应里
-  routingContext.addCookie(Cookie.cookie("othercookie", "somevalue"));
-});
-
                                                                                                              -

                                                                                                              处理会话

                                                                                                              -

                                                                                                              Vert.x Web 提供了开箱即用的会话(session)支持。

                                                                                                              -

                                                                                                              会话维持了 HTTP 请求和浏览器会话之间的关系，并提供了可以设置会话范围的信息的能力，例如一个购物篮。

                                                                                                              -

                                                                                                              Vert.x Web 使用会话 cookie(5) 来标示一个会话。会话 cookie 是临时的，当浏览器关闭时会被删除。

                                                                                                              -

                                                                                                              我们不会在会话 cookie 中设置实际的会话数据，这个 cookie 只是在服务器上查找实际的会话数据时使用的标示。这个标示是一个通过安全的随机过程生成的 UUID，因此它是无法推测的(6)。

                                                                                                              -

                                                                                                              Cookie 会在 HTTP 请求和响应之间传递。因此通过 HTTPS 来使用会话功能是明智的。如果您尝试直接通过 HTTP 使用会话，Vert.x Web 会给于警告。

                                                                                                              -

                                                                                                              您需要在匹配的 Route 上注册会话处理器 SessionHandler 来启用会话功能，并确保它能够在应用逻辑之前执行。

                                                                                                              -

                                                                                                              会话处理器会创建会话 Cookie 并查找会话信息，您不需要自己来实现。

                                                                                                              -

                                                                                                              会话存储

                                                                                                              -

                                                                                                              您需要提供一个会话存储对象来创建会话处理器。会话存储用于维持会话数据。

                                                                                                              -

                                                                                                              会话存储持有一个伪随机数生成器（PRNG）用于安全地生成会话标示。PRNG 是独立于存储的，这意味着对于给定的存储 A 的会话标示是不能够派发出存储 B 的会话标示的，因为他们具有不同的种子和状态。

                                                                                                              -

                                                                                                              PRNG 默认使用混合模式，阻塞式地刷新种子，非阻塞式地生成随机数(7)。PRNG 会每隔 5 分钟使用一个新的 64 位的熵作为种子。这个策略可以通过系统属性来设置：

                                                                                                              -
                                                                                                                -
                                                                                                              • io.vertx.ext.auth.prng.algorithm e.g.: SHA1PRNG
                                                                                                                • -
                                                                                                              • io.vertx.ext.auth.prng.seed.interval e.g.: 1000 (every second)
                                                                                                                • -
                                                                                                              • io.vertx.ext.auth.prng.seed.bits e.g.: 128
                                                                                                                • -
                                                                                                              -

                                                                                                              大多数用户并不需要配置这些值，除非您发现应用的性能被 PRNG 的算法所影响。

                                                                                                              -

                                                                                                              Vert.x Web 提供了两种开箱即用的会话存储实现，您也可以编写您自己的实现。

                                                                                                              -

                                                                                                              本地会话存储

                                                                                                              -

                                                                                                              该存储将会话保存在内存中，并只在当前实例中有效。

                                                                                                              -

                                                                                                              这个存储适用于您只有一个 Vert.x 实例的情况，或者您正在使用粘性会话。也就是说您可以配置您的负载均衡器来确保所有请求（来自同一用户的）永远被派发到同一个 Vert.x 实例上。

                                                                                                              -

                                                                                                              如果您不能够保证这一点，那么就不要使用这个存储。这会导致请求被派发到无法识别这个会话的服务器上。

                                                                                                              -

                                                                                                              本地会话存储基于本地的共享 Map来实现，并包含了一个用于清理过期会话的回收器。

                                                                                                              -

                                                                                                              回收的周期可以通过 LocalSessionStore.create 来配置。

                                                                                                              -

                                                                                                              以下是一些创建 LocalSessionStore 的例子：

                                                                                                              -
                                                                                                              SessionStore store1 = LocalSessionStore.create(vertx);
-
-// 通过指定的 Map 名称创建了一个本地会话存储
-// 这适用于您在同一个 Vert.x 实例中有多个应用，并且希望不同的应用使用不同的 Map 的情况
-SessionStore store2 = LocalSessionStore.create(vertx, "myapp3.sessionmap");
-
-// 通过指定的 Map 名称创建了一个本地会话存储
-// 设置了会话的过期时间为 10 秒
-SessionStore store3 = LocalSessionStore.create(vertx, "myapp3.sessionmap", 10000);
-
                                                                                                              -

                                                                                                              集群会话存储

                                                                                                              -

                                                                                                              该存储将会话保存在分布式 Map 中，该 Map 可以在 Vert.x 集群中共享访问。

                                                                                                              -

                                                                                                              这个存储适用于您没有使用粘性会话的情况。比如您的负载均衡器会将来自同一个浏览器的不同请求转发到不同的服务器上。

                                                                                                              -

                                                                                                              通过这个存储，您的会话可以被集群中的任何节点访问。

                                                                                                              -

                                                                                                              如果要使用集群会话存储，您需要确保您的 Vert.x 实例是集群模式的。

                                                                                                              -

                                                                                                              以下是一些创建 ClusteredSessionStore 的例子：

                                                                                                              -
                                                                                                              Vertx.clusteredVertx(new VertxOptions().setClustered(true), res -> {
-
-  Vertx vertx = res.result();
-
-  // 创建了一个默认的集群会话存储
-  SessionStore store1 = ClusteredSessionStore.create(vertx);
-
-  // 通过指定的 Map 名称创建了一个集群会话存储
-  // 这适用于您在集群中有多个应用，并且希望不同的应用使用不同的 Map 的情况
-  SessionStore store2 = ClusteredSessionStore.create(vertx, "myclusteredapp3.sessionmap");
-});
-
                                                                                                              -

                                                                                                              创建会话处理器

                                                                                                              -

                                                                                                              当您创建会话存储之后，您可以创建一个会话处理器，并添加到 Route 上。您需要确保会话处理器在您的应用处理器之前被执行。

                                                                                                              -

                                                                                                              由于会话处理器需要使用 Cookie 来查找会话，因此您还需要包含一个 Cookie 处理器。这个 Cookie 处理器需要在会话处理器之前被执行。

                                                                                                              -

                                                                                                              以下是例子：

                                                                                                              -
                                                                                                              Router router = Router.router(vertx);
-
-// 我们首先需要一个 cookie 处理器
-router.route().handler(CookieHandler.create());
-
-// 用默认值创建一个集群会话存储
-SessionStore store = ClusteredSessionStore.create(vertx);
-
-SessionHandler sessionHandler = SessionHandler.create(store);
-
-// 确保所有请求都会经过 session 处理器
-router.route().handler(sessionHandler);
-
-// 您自己的应用处理器
-router.route("/somepath/blah/").handler(routingContext -> {
-
-  Session session = routingContext.session();
-  session.put("foo", "bar");
-  // etc
-
-});
-
                                                                                                              -

                                                                                                              会话处理器会自动从会话存储中查找会话（如果没有则创建），并在您的应用处理器执行之前设置在上下文中。

                                                                                                              -

                                                                                                              使用会话

                                                                                                              -

                                                                                                              在您的处理器中，您可以通过 session 方法来访问会话对象。

                                                                                                              -

                                                                                                              您可以通过 put 方法来向会话中设置数据，通过 get 方法来获取数据，通过 remove 方法来删除数据。

                                                                                                              -

                                                                                                              会话中的键的类型必须是字符串。本地会话存储的值可以是任何类型；集群会话存储的值类型可以是基本类型，或者 Buffer、JsonObject、JsonArray 或可序列化对象。因为这些值需要在集群中进行序列化。

                                                                                                              -

                                                                                                              以下是操作会话数据的例子：

                                                                                                              -
                                                                                                              router.route().handler(CookieHandler.create());
-router.route().handler(sessionHandler);
-
-// 您的应用处理器
-router.route("/somepath/blah").handler(routingContext -> {
-
-  Session session = routingContext.session();
-
-  // 向会话中设置值
-  session.put("foo", "bar");
-
-  // 从会话中获取值
-  int age = session.get("age");
-
-  // 从会话中删除值
-  JsonObject obj = session.remove("myobj");
-
-});
-
                                                                                                              -

                                                                                                              在响应完成后会话会自动回写到存储中。

                                                                                                              -

                                                                                                              您可以使用 destroy 方法来销毁一个会话。这会将这个会话同时从上下文和存储中删除。注意，在删除会话之后，下一次通过浏览器访问并经过会话处理器处理时，会自动创建新的会话。

                                                                                                              -

                                                                                                              会话超时

                                                                                                              -

                                                                                                              如果会话在指定的周期内没有被访问，则会超时。

                                                                                                              -

                                                                                                              当请求到达，访问了会话，并且在响应完成向会话存储回写会话时，会话会被标记为被访问的。

                                                                                                              -

                                                                                                              您也可以通过 setAccessed 来人工指定会话被访问。

                                                                                                              -

                                                                                                              可以在创建会话处理器时配置超时时间。默认的超时时间是 30 分钟。

                                                                                                              -

                                                                                                              认证/授权

                                                                                                              -

                                                                                                              Vert.x Web 提供了若干开箱即用的处理器来处理认证和授权。

                                                                                                              -

                                                                                                              创建认证处理器

                                                                                                              -

                                                                                                              您需要一个 AuthProvider 实例来创建认证处理器。Auth Provider 用于为用户提供认证和授权。Vert.x 在 vertx-auth 项目中提供了若干开箱即用的 Auth Provider。完整的 Auth Provider 的配置和用法请参考 Vertx Auth 的文档。

                                                                                                              -

                                                                                                              以下是一个使用 Auth Provider 来创建认证处理器的例子：

                                                                                                              -
                                                                                                              router.route().handler(CookieHandler.create());
-router.route().handler(SessionHandler.create(LocalSessionStore.create(vertx)));
-
-AuthHandler basicAuthHandler = BasicAuthHandler.create(authProvider);
-
                                                                                                              -

                                                                                                              在您的应用中处理认证

                                                                                                              -

                                                                                                              我们来假设您希望所有路径为 /private 的请求都需要认证控制。为了实现这个，您需要确保您的认证处理器匹配这个路径，并在您的应用处理器之前执行：

                                                                                                              -
                                                                                                              router.route().handler(CookieHandler.create());
-router.route().handler(SessionHandler.create(LocalSessionStore.create(vertx)));
-router.route().handler(UserSessionHandler.create(authProvider));
-
-AuthHandler basicAuthHandler = BasicAuthHandler.create(authProvider);
-
-// 所有路径以 `/private` 开头的请求会被保护
-router.route("/private/*").handler(basicAuthHandler);
-
-router.route("/someotherpath").handler(routingContext -> {
-
-  // 此处是公开的，不需要登录
-
-});
-
-router.route("/private/somepath").handler(routingContext -> {
-
-  // 此处需要登录
-
-  // 这个值会返回 true
-  boolean isAuthenticated = routingContext.user() != null;
-
-});
-
                                                                                                              -

                                                                                                              如果认证处理器完成了授权和认证，它会向 RoutingContext 中注入一个 User 对象。您可以通过 user 方法在您的处理器中获取到该对象。

                                                                                                              -

                                                                                                              如果您希望在回话中存储用户对象，以避免对所有的请求都执行认证过程，您需要使用会话处理器。确保它匹配了对应的路径，并且会在认证处理器之前执行。

                                                                                                              -

                                                                                                              一旦您获取到了 user 对象，您可以通过编程的方式来使用它的相关方法为用户授权。

                                                                                                              -

                                                                                                              如果您希望用户登出，您可以调用上下文的 clearUser 方法。

                                                                                                              -

                                                                                                              HTTP 基础认证

                                                                                                              -

                                                                                                              HTTP基础认证是适用于简单应用的简单认证手段。

                                                                                                              -

                                                                                                              在这种认证方式下， 证书会以非加密的形式在 HTTP 请求中传输。因此，使用 HTTPS 而非 HTTP 来实现您的应用是非常必要的。

                                                                                                              -

                                                                                                              当用户请求一个需要授权的资源，基础认证处理器会返回一个包含 WWW-Authenticate 消息头的 401 响应。浏览器会显示一个登录窗口并提示用户输入他们的用户名和密码。

                                                                                                              -

                                                                                                              在这之后，浏览器会重新发送这个请求，并将用户名和密码以 Base64 编码的形式包含在请求的 Authorization 消息头里。

                                                                                                              -

                                                                                                              当基础认证处理器收到了这些信息，它会使用用户名和密码调用配置的 AuthProvider 来认证用户。如果认证成功则该处理器会尝试用户授权，如果也成功了则允许这个请求路由到后续的处理器里处理。否则，会返回一个 403 的响应拒绝访问。

                                                                                                              -

                                                                                                              在设置认证处理器时可以指定一系列访问资源时需要的权限。

                                                                                                              -

                                                                                                              重定向认证处理器

                                                                                                              -

                                                                                                              重定向认证处理器用于当未登录的用户尝试访问受保护的资源时将他们重定向到登录页上。

                                                                                                              -

                                                                                                              当用户提交登录表单，服务器会处理用户认证。如果成功，则将用户重定向到原始的资源上。

                                                                                                              -

                                                                                                              则您可以配置一个 RedirectAuthHandler 对象来使用重定向处理器。

                                                                                                              -

                                                                                                              您还需要配置用于处理登录页面的处理器，以及实际处理登录的处理器。我们提供了一个内置的处理器 FormLoginHandler 来处理登录的问题。

                                                                                                              -

                                                                                                              这里是一个简单的例子，使用了一个重定向认证处理器并使用默认的重定向 url /loginpage。

                                                                                                              -
                                                                                                              router.route().handler(CookieHandler.create());
-router.route().handler(SessionHandler.create(LocalSessionStore.create(vertx)));
-router.route().handler(UserSessionHandler.create(authProvider));
-
-AuthHandler redirectAuthHandler = RedirectAuthHandler.create(authProvider);
-
-// 所有路径以 `/private` 开头的请求会被保护
-router.route("/private/*").handler(redirectAuthHandler);
-
-// 处理登录请求
-// 您的登录页需要 POST 登录表单数据
-router.post("/login").handler(FormLoginHandler.create(authProvider));
-
-// 处理静态资源，例如您的登录页
-router.route().handler(StaticHandler.create());
-
-router.route("/someotherpath").handler(routingContext -> {
-  // 此处是公开的，不需要登录
-});
-
-router.route("/private/somepath").handler(routingContext -> {
-
-  // 此处需要登录
-
-  // 这个值会返回 true
-  boolean isAuthenticated = routingContext.user() != null;
-
-});
-
                                                                                                              -

                                                                                                              JWT 授权

                                                                                                              -

                                                                                                              JWT 授权通过权限来保护资源不被未为授权的用户访问。

                                                                                                              -

                                                                                                              使用这个处理器涉及 2 个步骤：

                                                                                                              -
                                                                                                                -
                                                                                                              • 配置一个处理器用于颁发令牌（或依靠第三方）
                                                                                                                • -
                                                                                                              • 配置授权处理器来过滤请求
                                                                                                                • -
                                                                                                              -

                                                                                                              注意，这两个处理器应该只能通过 HTTPS 访问。否则可能会引起由流量嗅探引起的会话劫持。

                                                                                                              -

                                                                                                              这里是一个派发令牌的例子：

                                                                                                              -
                                                                                                              Router router = Router.router(vertx);
-
-JsonObject authConfig = new JsonObject().put("keyStore", new JsonObject()
-    .put("type", "jceks")
-    .put("path", "keystore.jceks")
-    .put("password", "secret"));
-
-JWTAuth authProvider = JWTAuth.create(vertx, authConfig);
-
-router.route("/login").handler(ctx -> {
-  // 这是一个例子，认证会由另一个 provider 执行
-  if ("paulo".equals(ctx.request().getParam("username")) && "secret".equals(ctx.request().getParam("password"))) {
-    ctx.response().end(authProvider.generateToken(new JsonObject().put("sub", "paulo"), new JWTOptions()));
-  } else {
-    ctx.fail(401);
-  }
-});
-
                                                                                                              -

                                                                                                              注意，对于持有令牌的客户端，唯一需要做的是在 所有 后续的的 HTTP 请求中包含消息头 Authoriztion 并写入 Bearer <token>，例如：

                                                                                                              -
                                                                                                              Router router = Router.router(vertx);
-
-JsonObject authConfig = new JsonObject().put("keyStore", new JsonObject()
-    .put("type", "jceks")
-    .put("path", "keystore.jceks")
-    .put("password", "secret"));
-
-JWTAuth authProvider = JWTAuth.create(vertx, authConfig);
-
-router.route("/protected/*").handler(JWTAuthHandler.create(authProvider));
-
-router.route("/protected/somepage").handler(ctx -> {
-  // 一些处理过程
-});
-
                                                                                                              -

                                                                                                              JWT 允许您向令牌中添加任何您需要的信息，只需要在创建令牌时向 JsonObject 参数中添加数据即可。这样做服务器上不存在任何的会话状态，您可以在不依赖集群会话数据的情况下对应用进行扩展。

                                                                                                              -
                                                                                                              JsonObject authConfig = new JsonObject().put("keyStore", new JsonObject()
-    .put("type", "jceks")
-    .put("path", "keystore.jceks")
-    .put("password", "secret"));
-
-JWTAuth authProvider = JWTAuth.create(vertx, authConfig);
-
-authProvider.generateToken(new JsonObject().put("sub", "paulo").put("someKey", "some value"), new JWTOptions());
-
                                                                                                              -

                                                                                                              在消费时用同样的方式：

                                                                                                              -
                                                                                                              Handler<RoutingContext> handler = rc -> {
-  String theSubject = rc.user().principal().getString("sub");
-  String someKey = rc.user().principal().getString("someKey");
-};
-
                                                                                                              -

                                                                                                              配置所需的权限

                                                                                                              -

                                                                                                              您可以对认证处理器配置访问资源所需的权限。

                                                                                                              -

                                                                                                              默认的，如果不配置权限，那么只要登录了就可以访问资源。否则，用户不仅需要登录，而且需要具有所需的权限。

                                                                                                              -

                                                                                                              以下的例子定义了一个应用，该应用的不同部分需要不同的权限。注意，权限的含义取决于您使用的的 Auth Provider。例如一些支持角色/权限的模型，另一些可能是其他的模型。

                                                                                                              -
                                                                                                              AuthHandler listProductsAuthHandler = RedirectAuthHandler.create(authProvider);
-listProductsAuthHandler.addAuthority("list_products");
-
-// 需要 `list_products` 权限来列举产品
-router.route("/listproducts/*").handler(listProductsAuthHandler);
-
-AuthHandler settingsAuthHandler = RedirectAuthHandler.create(authProvider);
-settingsAuthHandler.addAuthority("role:admin");
-
-// 只有 `admin` 可以访问 `/private/settings`
-router.route("/private/settings/*").handler(settingsAuthHandler);
-
                                                                                                              -

                                                                                                              静态资源服务

                                                                                                              -

                                                                                                              Vert.x Web 提供了一个开箱即用的处理器来提供静态的 Web 资源。您可以非常容易地编写静态的 Web 服务器。

                                                                                                              -

                                                                                                              您可以使用静态资源处理器 StaticHandler 来提供诸如 .html、.css、.js 或其他类型的静态资源。

                                                                                                              -

                                                                                                              每一个被静态资源处理器处理的请求都会返回文件系统的某个目录或 classpath 里的文件。文件的根目录是可以配置的，默认为 webroot。

                                                                                                              -

                                                                                                              在以下的例子中，所有路径以 /static 开头的请求都会对应到 webroot 目录：

                                                                                                              -
                                                                                                              router.route("/static/*").handler(StaticHandler.create());
-
                                                                                                              -

                                                                                                              例如，对于一个路径为 /static/css/mystyles.css 的请求，静态处理器会在该路径中查找文件 webroot/css/mystyle.css。

                                                                                                              -

                                                                                                              它也会在 classpath 中查找文件 webroot/css/mystyle.css。这意味着您可以将所有的静态资源打包到一个 jar 文件（或 fat-jar）里进行分发。

                                                                                                              -

                                                                                                              当 Vert.x 在 classpath 中第一次找到一个资源时，会将它提取到一个磁盘的缓存目录中以避免每一次都重新提取。

                                                                                                              -

                                                                                                              这个处理器能够处理范围请求。当客户端请求静态资源时，该处理器会添加一个范围单位的说明到响应的消息头 Accept-Ranges 里来通知客户端它支持范围请求。如果后续请求的消息头 Range 里包含了正确的单位以及起始、终止位置，则客户端将收到包含了的 Content-Range 消息头的部分响应。

                                                                                                              -

                                                                                                              配置缓存

                                                                                                              -

                                                                                                              默认的，为了让浏览器有效地缓存文件，静态处理器会设置缓存消息头。

                                                                                                              -

                                                                                                              Vert.x Web 会在响应里设置这些消息头：cache-control、last-modified、date。

                                                                                                              -

                                                                                                              cache-control 的默认值为 max-age=86400，也就是一天。可以通过 setMaxAgeSeconds 方法来配置。

                                                                                                              -

                                                                                                              当浏览器发送了携带消息头 if-modified-since 的 GET 或 HEAD 请求时，如果对应的资源在该日期之后没有修改过，则会返回一个 304 状态码通知浏览器使用本地的缓存资源。

                                                                                                              -

                                                                                                              如果不需要缓存的消息头，可以通过 setCachingEnabled 方法将其禁用。

                                                                                                              -

                                                                                                              如果启用了缓存处理，则 Vert.x Web 会将资源的最后修改日期缓存在内存里，以此来避免频繁地访问取磁盘来检查修改时间。

                                                                                                              -

                                                                                                              缓存有过期时间，在这个时间之后，会重新访问磁盘检查文件并更新缓存。

                                                                                                              -

                                                                                                              默认的，如果您的文件永远不会发生变化，则缓存内容会永远有效。

                                                                                                              -

                                                                                                              如果您的文件在服务器运行过程中可能发生变化，您可以通过 setFilesReadOnly 方法设置文件的只读属性为 false。

                                                                                                              -

                                                                                                              您可以通过 setMaxCacheSize 方法来设置内存缓存的最大数量。通过 setCacheEntryTimeout 方法来设置缓存的过期时间。

                                                                                                              -

                                                                                                              配置索引页

                                                                                                              -

                                                                                                              所有访问根路径 / 的请求会被定位到索引页。默认的该文件为 index.html。可以通过 setIndexPage 方法来设置。

                                                                                                              -

                                                                                                              配置跟目录

                                                                                                              -

                                                                                                              默认的，所有资源都以 webroot 作为根目录。可以通过 setWebRoot 方法来配置。

                                                                                                              -

                                                                                                              隐藏文件

                                                                                                              -

                                                                                                              默认的，处理器会为隐藏文件提供服务（文件名以 . 开头的文件）。

                                                                                                              -

                                                                                                              如果您不需要为隐藏文件提供服务，可以通过 setIncludeHidden 方法来配置。

                                                                                                              -

                                                                                                              列举目录

                                                                                                              -

                                                                                                              静态资源处理器可以用于列举目录的文件。默认情况下该功能是关闭的。可以通过 setDirectoryListing 方法来启用。

                                                                                                              -

                                                                                                              当该功能启用时，会根据客户端请求的消息头 accept 所表示的类型来返回相应的结果。

                                                                                                              -

                                                                                                              例如对于 text/html 标示的请求，会使用通过 setDirectoryTemplate 方法设置的模板来渲染文件列表。

                                                                                                              -

                                                                                                              禁用磁盘文件缓存

                                                                                                              -

                                                                                                              默认情况下，Vert.x 会使用当前工作目录的子目录 .vertx 来在磁盘上缓存通过 classpath 服务的静态资源。这对于在生产环境中通过 fat-jar 来部署的服务是很重要的。因为每一次都通过 classpath 来提取文件是低效的。

                                                                                                              -

                                                                                                              这在开发时会导致一个问题，例如当您通过 IDE 的运行配置来启动您的应用时，如果您修改了文件，缓存的文件时不会被更新的。

                                                                                                              -

                                                                                                              您可以通过设置系统属性 vertx.disableFileCaching 为 false 来禁用文件缓存。

                                                                                                              -

                                                                                                              处理跨域资源共享

                                                                                                              -

                                                                                                              跨域资源共享（CORS，Cross Origin Resource Sharing）是一个安全机制。该机制允许了浏览器在一个域名下访问另一个域名的资源。

                                                                                                              -

                                                                                                              Vert.x Web 提供了一个处理器 CorsHandler 来为您处理 CORS 协议。

                                                                                                              -

                                                                                                              这是一个例子：

                                                                                                              -
                                                                                                              router.route().handler(CorsHandler.create("vertx\\.io").allowedMethod(HttpMethod.GET));
-
-router.route().handler(routingContext -> {
-
-  // 您的应用处理
-
-});
-
                                                                                                              -

                                                                                                              模板引擎

                                                                                                              -

                                                                                                              Vert.x Web 为若干流行的模板引擎提供了开箱即用的支持，通过这种方式来提供生成动态页面的能力。您也可以很容易地添加您自己的实现。

                                                                                                              -

                                                                                                              模板引擎 TemplateEngine 定义了使用模板引擎的接口，当渲染模板时会调用 render 方法。

                                                                                                              -

                                                                                                              最简单的使用模板的方式不是直接调用模板引擎，而是使用模板处理器 TemplateHandler。这个处理器会根据 HTTP 请求的路径来调用模板引擎。

                                                                                                              -

                                                                                                              默认的，模板处理器会在 templates 目录中查找模板文件。这是可以配置的。

                                                                                                              -

                                                                                                              该处理器会返回渲染的结果，并默认设置 Content-Type 消息头为 text/html。这也是可以配置的。

                                                                                                              -

                                                                                                              您需要在创建模板处理器时提供您需要使用的模板引擎的实例。

                                                                                                              -

                                                                                                              模板引擎的实现没有内嵌在 Vert.x Web 里，您需要配置您的项目来访问它们。Vert.x Web 提供了每一种模板引擎的配置。

                                                                                                              -

                                                                                                              以下是一个例子：

                                                                                                              -
                                                                                                              TemplateEngine engine = HandlebarsTemplateEngine.create();
-TemplateHandler handler = TemplateHandler.create(engine);
-
-// 这会将所有以 `/dynamic` 开头的请求路由到模板处理器上
-// 例如 /dynamic/graph.hbs 会查找模板 /templates/graph.hbs
-router.get("/dynamic/*").handler(handler);
-
-// 将所有以 `.hbs` 结尾的请求路由到模板处理器上
-router.getWithRegex(".+\\.hbs").handler(handler);
-
                                                                                                              -

                                                                                                              MVEL 模板引擎

                                                                                                              -

                                                                                                              您需要在您的项目中添加这些依赖来使用 MVEL 模板引擎：io.vertx:vertx-web-templ-mvel:3.4.1。通过这个方法来创建 MVEL 模板引擎的实例：io.vertx.ext.web.templ.MVELTemplateEngine#create()。

                                                                                                              -

                                                                                                              在使用 MVEL 模板引擎时，如果不指定模板文件的扩展名，则默认会查找扩展名为 .templ 的文件。

                                                                                                              -

                                                                                                              在 MVEL 模板中可以通过 context 变量来访问路由上下文 RoutingContext 对象。这也意味着您可以基于上下文里的任何信息来渲染模板，包括请求、响应、会话或者上下文数据。

                                                                                                              -

                                                                                                              这是一个例子：

                                                                                                              -
                                                                                                              The request path is @{context.request().path()}
-
-The variable 'foo' from the session is @{context.session().get('foo')}
-
-The value 'bar' from the context data is @{context.get('bar')}
-
                                                                                                              -

                                                                                                              关于如何编写 MVEL 模板，请参考 MVEL 模板文档。

                                                                                                              -

                                                                                                              Jade 模板引擎

                                                                                                              -
                                                                                                              -

                                                                                                              译者注：Jade 已更名为 Pug。

                                                                                                              -
                                                                                                              -

                                                                                                              您需要在您的项目中添加这些依赖来使用 Jade 模板引擎：io.vertx:vertx-web-templ-jade:3.4.1。通过这个方法来创建 Jade 模板引擎的实例：io.vertx.ext.web.templ.JadeTemplateEngine#create()。

                                                                                                              -

                                                                                                              在使用 Jade 模板引擎时，如果不指定模板文件的扩展名，则默认会查找扩展名为 .jade 的文件。

                                                                                                              -

                                                                                                              在 Jade 模板中可以通过 context 变量来访问路由上下文 RoutingContext 对象。这也意味着您可以基于上下文里的任何信息来渲染模板，包括请求、响应、会话或者上下文数据。

                                                                                                              -

                                                                                                              这是一个例子：

                                                                                                              -
                                                                                                              !!! 5
-html
-  head
-    title= context.get('foo') + context.request().path()
-  body
-
                                                                                                              -

                                                                                                              关于如何编写 Jade 模板，请参考 Jade4j 文档。

                                                                                                              -

                                                                                                              Handlebars 模板引擎

                                                                                                              -

                                                                                                              您需要在您的项目中添加这些依赖来使用 Handlebars：io.vertx:vertx-web-templ-handlebars:3.4.1。通过这个方法来创建 Handlebars 模板引擎的实例：io.vertx.ext.web.templ.HandlebarsTemplateEngine#create()。

                                                                                                              -

                                                                                                              在使用 Handlebars 模板引擎时，如果不指定模板文件的扩展名，则默认会查找扩展名为 .hbs 的文件。

                                                                                                              -

                                                                                                              Handlebars 不允许在模板中随意地调用对象的方法，因此我们不能像对待其他模板引擎一样将路由上下文传递到引擎里并让模板来识别它。

                                                                                                              -

                                                                                                              替代方案是，可以使用 data 来访问上下文数据。

                                                                                                              -

                                                                                                              如果您要访问某些上下文数据里不存在的信息，比如请求的路径、请求参数或者会话等，您需要在模板处理器执行之前将他们添加到上下文数据里，例如：

                                                                                                              -
                                                                                                              TemplateHandler handler = TemplateHandler.create(engine);
-
-router.get("/dynamic").handler(routingContext -> {
-
-  routingContext.put("request_path", routingContext.request().path());
-  routingContext.put("session_data", routingContext.session().data());
-
-  routingContext.next();
-});
-
-router.get("/dynamic/").handler(handler);
-
                                                                                                              -

                                                                                                              关于如何编写 Handlebars 模板，请参考 Handlebars Java 文档。

                                                                                                              -

                                                                                                              Thymeleaf 模板引擎

                                                                                                              -

                                                                                                              您需要在您的项目中添加这些依赖来使用 Thymeleaf：io.vertx:vertx-web-templ-thymeleaf:3.4.1。通过这个方法来创建 Thymeleaf 模板引擎的实例：io.vertx.ext.web.templ.ThymeleafTemplateEngine#create()。

                                                                                                              -

                                                                                                              在使用 Thymeleaf 模板引擎时，如果不指定模板文件的扩展名，则默认会查找扩展名为 .html 的文件。

                                                                                                              -

                                                                                                              在 Thymeleaf 模板中可以通过 context 变量来访问路由上下文 RoutingContext 对象。这也意味着您可以基于上下文里的任何信息来渲染模板，包括请求、响应、会话或者上下文数据。

                                                                                                              -

                                                                                                              这是一个例子：

                                                                                                              -
                                                                                                              [snip]
-<p th:text="${context.get('foo')}"></p>
-<p th:text="${context.get('bar')}"></p>
-<p th:text="${context.normalisedPath()}"></p>
-<p th:text="${context.request().params().get('param1')}"></p>
-<p th:text="${context.request().params().get('param2')}"></p>
-[snip]
-
                                                                                                              -

                                                                                                              关于如何编写 Thymeleaf 模板，请参考 Thymeleaf 文档。

                                                                                                              -

                                                                                                              Apache FreeMarker 模板引擎

                                                                                                              -

                                                                                                              您需要在您的项目中添加这些依赖来使用 Apache FreeMarker：io.vertx:vertx-web-templ-freemarker:3.4.1。通过这个方法来创建 Apache FreeMarker 模板引擎的实例：io.vertx.ext.web.templ.FreeMarkerTemplateEngine#create()。

                                                                                                              -

                                                                                                              在使用 Apache FreeMarker 模板引擎时，如果不指定模板文件的扩展名，则默认会查找扩展名为 .ftl 的文件。

                                                                                                              -

                                                                                                              在 Apache FreeMarker 模板中可以通过 context 变量来访问路由上下文 RoutingContext 对象。这也意味着您可以基于上下文里的任何信息来渲染模板，包括请求、响应、会话或者上下文数据。

                                                                                                              -

                                                                                                              这是一个例子：

                                                                                                              -
                                                                                                              [snip]
-<p th:text="${context.foo}"></p>
-<p th:text="${context.bar}"></p>
-<p th:text="${context.normalisedPath()}"></p>
-<p th:text="${context.request().params().param1}"></p>
-<p th:text="${context.request().params().param2}"></p>
-[snip]
-
                                                                                                              -

                                                                                                              关于如何编写 Apache FreeMarker 模板，请参考 Apache FreeMarker 文档。

                                                                                                              -

                                                                                                              Pebble 模板引擎

                                                                                                              -

                                                                                                              您需要在您的项目中添加这些依赖来使用 Pebble：io.vertx:vertx-web-templ-pebble:3.4.0-SNAPSHOT。通过这个方法来创建 Pebble 模板引擎的实例：io.vertx.ext.web.templ.PebbleTemplateEngine#create()。

                                                                                                              -

                                                                                                              在使用 Pebble 模板引擎时，如果不指定模板文件的扩展名，则默认会查找扩展名为 .peb 的文件。

                                                                                                              -

                                                                                                              在 Pebble 模板中可以通过 context 变量来访问路由上下文 RoutingContext 对象。这也意味着您可以基于上下文里的任何信息来渲染模板，包括请求、响应、会话或者上下文数据。

                                                                                                              -

                                                                                                              这是一个例子：

                                                                                                              -
                                                                                                              [snip]
-<p th:text="{{context.foo}}"></p>
-<p th:text="{{context.bar}}"></p>
-<p th:text="{{context.normalisedPath()}}"></p>
-<p th:text="{{context.request().params().param1}}"></p>
-<p th:text="{{context.request().params().param2}}"></p>
-[snip]
-
                                                                                                              -

                                                                                                              关于如何编写 Pebble 模板，请参考 Pebble 文档。

                                                                                                              -

                                                                                                              错误处理

                                                                                                              -

                                                                                                              您可以用模板处理器来渲染错误信息，或者使用 Vert.x Web 内置的一个 ”漂亮“ 的、开箱即用的错误处理器来渲染错误页面。

                                                                                                              -

                                                                                                              这个处理器是 ErrorHandler。您只需要在需要覆盖到的路径上将它设置为失败处理器(9)来使用它。

                                                                                                              -

                                                                                                              请求日志

                                                                                                              -

                                                                                                              Vert.x Web 提供了一个用于记录 HTTP 请求的处理器 LoggerHandler。

                                                                                                              -

                                                                                                              默认的，请求会通过 Vert.x 日志来记录，或者也可以配置为 jul 日志、log4j 或 slf4j。详见 LoggerFormat。

                                                                                                              -

                                                                                                              提供网页图标

                                                                                                              -

                                                                                                              Vert.x Web 通过内置的处理器 FaviconHandler 来提供网页图标。

                                                                                                              -

                                                                                                              图标可以指定为文件系统上的某个路径，否则 Vert.x Web 默认会在 classpath 上寻找 favicon.ico 文件。这意味着您可以将图标打包到您的应用的 jar 包里。

                                                                                                              -

                                                                                                              超时处理器

                                                                                                              -

                                                                                                              Vert.x Web 提供了一个超时处理器，可以在处理时间过长时将请求超时。

                                                                                                              -

                                                                                                              通过 TimeoutHandler 对象来进行配置。

                                                                                                              -

                                                                                                              如果一个请求在响应之前超时，则会给客户端返回一个 503 的响应。

                                                                                                              -

                                                                                                              下面的例子设置了一个超时处理器。对于所有以 /foo 路径开头的请求，都会在执行 5 秒后自动超时。

                                                                                                              -
                                                                                                              router.route("/foo/").handler(TimeoutHandler.create(5000));
-
                                                                                                              -

                                                                                                              响应时间处理器

                                                                                                              -

                                                                                                              该处理器会将从接收到请求到写入响应的消息头之间的毫秒数写入到响应的 x-response-time 里，例如：

                                                                                                              -
                                                                                                              x-response-time: 1456ms
-

                                                                                                              Content Type 处理器

                                                                                                              -

                                                                                                              该处理器 ResponseContentTypeHandler 会自动设置响应的 Content-Type 消息头。假设我们要构建一个 RESTful 的 Web 应用，我们需要在所有处理器里设置 Content-Type：

                                                                                                              -
                                                                                                              router.get("/api/books").produces("application/json").handler(rc -> {
-  findBooks(ar -> {
-    if (ar.succeeded()) {
-      rc.response().putHeader("Content-Type", "application/json").end(toJson(ar.result()));
-    } else {
-      rc.fail(ar.cause());
-    }
-  });
-});
-
                                                                                                              -

                                                                                                              随着 API 接口数量的增长，设置 Content-Type 会变得很麻烦。可以通过在 Route 上添加 ResponseContentTypeHandler 来避免这个问题：

                                                                                                              -
                                                                                                              router.route("/api/*").handler(ResponseContentTypeHandler.create());
-router.get("/api/books").produces("application/json").handler(rc -> {
-  findBooks(ar -> {
-    if (ar.succeeded()) {
-      rc.response().end(toJson(ar.result()));
-    } else {
-      rc.fail(ar.cause());
-    }
-  });
-});
-
                                                                                                              -

                                                                                                              这个处理器会通过 getAcceptableContentType 方法来选择适当的 Content-Type。因此，您可以很容易地使用同一个处理器来提供不同类型的数据：

                                                                                                              -
                                                                                                              router.route("/api/*").handler(ResponseContentTypeHandler.create());
-router.get("/api/books").produces("text/xml").produces("application/json").handler(rc -> {
-  findBooks(ar -> {
-    if (ar.succeeded()) {
-      if (rc.getAcceptableContentType().equals("text/xml")) {
-        rc.response().end(toXML(ar.result()));
-      } else {
-        rc.response().end(toJson(ar.result()));
-      }
-    } else {
-      rc.fail(ar.cause());
-    }
-  });
-});
-
                                                                                                              -

                                                                                                              SockJS

                                                                                                              -

                                                                                                              SockJS 是一个客户端的 JavaScript 库。它提供了类似 WebSocket 的接口为您和 SockJS 服务端建立连接。您不必关注浏览器或网络是否真的是 WebSocket。

                                                                                                              -

                                                                                                              它提供了若干不同的传输方式，并在运行时根据浏览器和网络的兼容性来选择使用哪种传输方式处理。

                                                                                                              -

                                                                                                              所有这些对您是透明的，您只需要简单地使用类似 WebSocket 的接口。

                                                                                                              -

                                                                                                              请访问 SockJS 官方网站 来获取 SockJS 的详细信息。

                                                                                                              -

                                                                                                              SockJS 处理器

                                                                                                              -

                                                                                                              Vert.x Web 提供了一个开箱即用的处理器 SockJSHandler 来让您在 Vert.x Web 应用中使用 SockJS。

                                                                                                              -

                                                                                                              您需要通过 SockJSHandler.create 方法为每一个 SockJS 的应用创建这个处理器。您也可以在创建处理器时通过 SockJSHandlerOptions 对象来指定配置选项。

                                                                                                              -
                                                                                                              Router router = Router.router(vertx);
-
-SockJSHandlerOptions options = new SockJSHandlerOptions().setHeartbeatInterval(2000);
-
-SockJSHandler sockJSHandler = SockJSHandler.create(vertx, options);
-
-router.route("/myapp/*").handler(sockJSHandler);
-
                                                                                                              -

                                                                                                              处理 SockJS 套接字

                                                                                                              -

                                                                                                              您可以在服务器端设置一个处理器，这个处理器会在每次客户端创建连接时被调用：

                                                                                                              -

                                                                                                              调用这个处理器的参数是一个 SockJSSocket 对象。这是一个类似套接字的接口，您可以向使用 NetSocket 和 WebSocket 那样通过它来读写数据。它实现了 ReadStream 和 WriteStream 接口，因此您可以将它套用（pump）到其他的读写流上。

                                                                                                              -

                                                                                                              下面的例子中的 SockJS 处理器直接使用了它读取到的数据进行回写：

                                                                                                              -
                                                                                                              Router router = Router.router(vertx);
-
-SockJSHandlerOptions options = new SockJSHandlerOptions().setHeartbeatInterval(2000);
-
-SockJSHandler sockJSHandler = SockJSHandler.create(vertx, options);
-
-sockJSHandler.socketHandler(sockJSSocket -> {
-
-  // 将数据回写
-  sockJSSocket.handler(sockJSSocket::write);
-});
-
-router.route("/myapp/*").handler(sockJSHandler);
-
                                                                                                              -

                                                                                                              SockJS 客户端

                                                                                                              -

                                                                                                              在客户端 JavaScript 环境里您需要通过 SockJS 的客户端库来建立连接。

                                                                                                              -

                                                                                                              SockJS 客户端的地址

                                                                                                              -

                                                                                                              完整的细节可以在 SockJS 的网站 中找到，简单来说您会像这样使用：

                                                                                                              -
                                                                                                              var sock = new SockJS('http://mydomain.com/myapp');
-
-sock.onopen = function() {
-  console.log('open');
-};
-
-sock.onmessage = function(e) {
-  console.log('message', e.data);
-};
-
-sock.onclose = function() {
-  console.log('close');
-};
-
-sock.send('test');
-
-sock.close();
-
                                                                                                              -

                                                                                                              配置 SockJS 处理器

                                                                                                              -

                                                                                                              可以通过 SockJSHandlerOptions 对象来配置这个处理器的若干选项。

                                                                                                              -
                                                                                                                -
                                                                                                              • insertJSESSIONID
                                                                                                                • -
                                                                                                              -

                                                                                                              在 cookie 中插入一个 JSESSIONID，这样负载均衡器可以保证 SockJS 会话永远转发到正确的服务器上。默认值为 true。

                                                                                                              -
                                                                                                                -
                                                                                                              • sessionTimeout
                                                                                                                • -
                                                                                                              -

                                                                                                              对于一个正在接收响应的客户端连接，如果一段时间内没有动作，则服务端会发出一个 close 事件。延时时间由这个配置决定。默认的服务端会在 5 秒之后发出这个 close 事件。(10)

                                                                                                              -
                                                                                                                -
                                                                                                              • heartbeatInterval
                                                                                                                • -
                                                                                                              -

                                                                                                              我们会每隔一段时间发送一个心跳包，用来避免由于请求时间过长导致连接被代理和负载均衡器关闭。默认的每隔 25 秒发送一个心跳包，可以通过这个设置来控制频率。

                                                                                                              -
                                                                                                                -
                                                                                                              • maxBytesStreaming
                                                                                                                • -
                                                                                                              -

                                                                                                              大多数流式传输方式会在客户端保存响应的内容并且不会释放派发消息所使用的内存。这些传输方式需要定期执行垃圾回收。max_bytes_streaming 设置了每一个 http 流式请求所需要发送的最小字节数。超过这个值则客户端需要打开一个新的请求。将这个值设置得过小会失去流式的处理能力，使这个流式的传输方式表现得像一个轮训的传输方式一样。默认值是 128K。

                                                                                                              -
                                                                                                                -
                                                                                                              • libraryURL
                                                                                                                • -
                                                                                                              -

                                                                                                              对于没有提供原生的跨域通信支持的浏览器，会使用 iframe 来进行通信。SockJS 服务器会提供一个简单的页面（在目标域名上）并放置在一个不可见的 iframe 里。在 iframe 里运行的代码和 SockJS 服务器运行在同一个域名下，因此不用担心跨域的问题。这个 iframe 也需要加载 SockJS 的客户端 JavaScript 库，这个配置就是用于指定这个 URL 的。默认情况下会使用最新发布的压缩版本 http://cdn.jsdelivr.net/sockjs/0.3.4/sockjs.min.js。

                                                                                                              -
                                                                                                                -
                                                                                                              • disabledTransports
                                                                                                                • -
                                                                                                              -

                                                                                                              这个参数用于禁用某些传输方式。可能的值包括 WEBSOCKET、EVENT_SOURCE、HTML_FILE、JSON_P、XHR。

                                                                                                              -

                                                                                                              SockJS 桥接 Event Bus

                                                                                                              -

                                                                                                              Vert.x Web 提供了一个内置的叫做 Event Bus Bridge 的 SockJS 套接字处理器。该处理器用于将服务器端的 Vert.x 的 Event Bus 扩展到客户端的 JavaScript 运行环境里。

                                                                                                              -

                                                                                                              这将创建一个分布式的 Event Bus。这个 Event Bus 不仅可以在多个 Vert.x 实例中使用，还可以通过运行在浏览器里的 JavaScript 访问。

                                                                                                              -

                                                                                                              由此，我们可以围绕浏览器和服务器构建一个庞大的分布式 Event Bus。只要服务器之间的链接存在，浏览器不需要每一次都与同一个服务器建立链接。

                                                                                                              -

                                                                                                              这些是通过 Vert.x 提供的一个简单的客户端 JavaScript 库 vertx-eventbus.js 来实现的。它提供了一系列和服务器端的 Vert.x Event Bus 类似的 API。通过这些 API 可以发送或发布消息，或注册处理器来接收消息。

                                                                                                              -

                                                                                                              一个 SockJS 套接字处理器会被安装到 SockJSHandler 上。这个处理器用于处理 SockJS 的数据并把它桥接到服务器端的 event bus 上。

                                                                                                              -
                                                                                                              Router router = Router.router(vertx);
-
-SockJSHandler sockJSHandler = SockJSHandler.create(vertx);
-BridgeOptions options = new BridgeOptions();
-sockJSHandler.bridge(options);
-
-router.route("/eventbus/*").handler(sockJSHandler);
-
                                                                                                              -

                                                                                                              在客户端通过使用 vertx-eventbus.js 库来和 Event Bus 建立连接，并发送/接收消息：

                                                                                                              -
                                                                                                              <script src="http://cdn.jsdelivr.net/sockjs/0.3.4/sockjs.min.js"></script>
-<script src='vertx-eventbus.js'></script>
-
-<script>
-
-var eb = new EventBus('http://localhost:8080/eventbus');
-
-eb.onopen = function() {
-
-  // 设置了一个接收数据的处理器
-  eb.registerHandler('some-address', function(error, message) {
-    console.log('received a message: ' + JSON.stringify(message));
-  });
-
-  // 发送消息
-  eb.send('some-address', {name: 'tim', age: 587});
-
-}
-
-</script>
-
                                                                                                              -

                                                                                                              这个例子做的第一件事是创建了一个 Event Bus 实例：

                                                                                                              -
                                                                                                              var eb = new EventBus('http://localhost:8080/eventbus');
-
                                                                                                              -

                                                                                                              构造函数中的参数是连接到 Event Bus 使用的 URI。由于我们创建的桥接器是以 eventbus 作为前缀的，因此我们需要将 URI 指向这里。

                                                                                                              -

                                                                                                              在连接打开之前，我们什么也做不了。当它打开后，会回调 onopen 函数处理。

                                                                                                              -

                                                                                                              您可以通过依赖管理器来获取客户端库：

                                                                                                              -
                                                                                                                -
                                                                                                              • Maven （在您的 pom.xml 文件里）
                                                                                                                • -
                                                                                                              -
                                                                                                              <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-web</artifactId>
-  <version>3.4.1</version>
-  <classifier>client</classifier>
-  <type>js</type>
-</dependency>
-
                                                                                                              -
                                                                                                                -
                                                                                                              • Gradle（在您的 build.gradle 文件里）
                                                                                                                • -
                                                                                                              -
                                                                                                              compile 'io.vertx:vertx-web:3.4.1:client'
-
                                                                                                              -

                                                                                                              这个库也可以通过 NPM 和 Bower 来获取。

                                                                                                              -

                                                                                                              注意， 这个 API 在 3.0.0 和 3.1.0 版本之间发生了变化，请检查变更日志。老版本的客户端仍然兼容，但新版本提供了更多的特性，并且更接近服务端的 Vert.x Event Bus API。

                                                                                                              -

                                                                                                              安全的桥接

                                                                                                              -

                                                                                                              如果您像上面的例子一样启动一个桥接器，并试图发送消息，您会发现您的消息神秘地失踪了。发生了什么？

                                                                                                              -

                                                                                                              对于大多数的应用，您应该不希望客户端的 JavaScript 代码可以发送任何消息到任何的服务端处理器或其他所有浏览器上。

                                                                                                              -

                                                                                                              例如，您可能在Event Bus 上注册了一个服务，用于访问和删除数据。但我们并不希望恶意的客户端能够通过这个服务来操作数据库中的数据。并且，我们也不希望客户端能够监听所有 event bus 上的地址。

                                                                                                              -

                                                                                                              为了解决这个问题，SockJS 默认的会拒绝所有的消息。您需要告诉桥接器哪些消息是可以通过的。（例外情况是，所有的回复消息都是可以通过的）。

                                                                                                              -

                                                                                                              换句话说，桥接器的行为像是配置了 deny-all 策略的防火墙。

                                                                                                              -

                                                                                                              为桥接器配置哪些消息允许通过是很容易的。

                                                                                                              -

                                                                                                              您可以通过调用桥接器时传入的 BridgeOptions 来配置匹配规则，指定哪些输入和输出的流量是允许通过的。

                                                                                                              -

                                                                                                              每一个匹配规则对应一个 PermittedOptions 对象：

                                                                                                              -

                                                                                                              setAddress

                                                                                                              -

                                                                                                              这个配置精确地定义了消息可以被发送到哪些地址。如果您需要通过精确的地址来控制消息的话，使用这个选项。

                                                                                                              -

                                                                                                              setAddressRegex

                                                                                                              -

                                                                                                              这个配置通过正则表达式来定义消息可以被发送到哪些地址。如果您需要通过正则表达式来控制消息的话，使用这个选项。如果指定了 address，这个选项会被忽略。

                                                                                                              -

                                                                                                              setMatch

                                                                                                              -

                                                                                                              这个配置通过消息的接口来控制消息是否可以发送。这个配置中定义的每一个字段必须在消息中存在，并且值一致。这个配置只能用于 JSON 格式的消息。

                                                                                                              -

                                                                                                              对于一个输入的消息（例如通过客户端 JavaScript 发送到服务器），当消息到达时，Vert.x Web 会检查每一条输入许可。如果存在匹配，则消息可以通过。

                                                                                                              -

                                                                                                              对于一个输出的消息（例如通过服务器端发送给客户端 JavaScript），当消息发送时，Vert.x Web 会检查每一条输出许可。如果存在匹配，则消息可以通过。

                                                                                                              -

                                                                                                              实际的匹配过程如下：

                                                                                                              -

                                                                                                              如果指定了 address 字段，并且消息的目标地址与 address 精确匹配，则匹配成功。

                                                                                                              -

                                                                                                              如果没有指定 address 而是指定了 addressRegex 字段，并且消息的目标地址匹配了这个正则表达式，则匹配成功。

                                                                                                              -

                                                                                                              如果指定了 match 字段，并且消息中包含了 match 对象中的所有键值对，则匹配成功。

                                                                                                              -

                                                                                                              以下是例子：

                                                                                                              -
                                                                                                              Router router = Router.router(vertx);
-
-SockJSHandler sockJSHandler = SockJSHandler.create(vertx);
-
-
-// 允许客户端向地址 `demo.orderMgr` 发送消息
-PermittedOptions inboundPermitted1 = new PermittedOptions().setAddress("demo.orderMgr");
-
-// 允许客户端向地址 `demo.orderMgr` 发送消息
-// 并且 `action` 的值为 `find`、`collecton` 的值为 `albums` 消息。
-PermittedOptions inboundPermitted2 = new PermittedOptions().setAddress("demo.persistor")
-    .setMatch(new JsonObject().put("action", "find")
-        .put("collection", "albums"));
-
-// 允许 `wibble` 值为 `foo` 的消息.
-PermittedOptions inboundPermitted3 = new PermittedOptions().setMatch(new JsonObject().put("wibble", "foo"));
-
-// 下面定义了如何允许服务端向客户端发送消息
-
-// 允许向客户端发送地址为 `ticker.mystock` 的消息
-PermittedOptions outboundPermitted1 = new PermittedOptions().setAddress("ticker.mystock");
-
-// 允许向客户端发送地址以 `news.` 开头的消息（例如 news.europe, news.usa, 等）
-PermittedOptions outboundPermitted2 = new PermittedOptions().setAddressRegex("news\\..+");
-
-// 将规则添加到 BridgeOptions 里
-BridgeOptions options = new BridgeOptions().
-    addInboundPermitted(inboundPermitted1).
-    addInboundPermitted(inboundPermitted1).
-    addInboundPermitted(inboundPermitted3).
-    addOutboundPermitted(outboundPermitted1).
-    addOutboundPermitted(outboundPermitted2);
-
-sockJSHandler.bridge(options);
-
-router.route("/eventbus/*").handler(sockJSHandler);
-
                                                                                                              -

                                                                                                              消息授权

                                                                                                              -

                                                                                                              Event Bus 桥接器可以使用 Vert.x Web 的授权功能来配置消息的访问授权。同时支持输入和输出。

                                                                                                              -

                                                                                                              这可以通过向上文所述的匹配规则中加入额外的字段来指定该匹配需要哪些权限。

                                                                                                              -

                                                                                                              通过 setRequiredAuthority 方法来指定对于一个登录用户，需要具有哪些权限才允许访问这个消息。

                                                                                                              -

                                                                                                              这是一个例子：

                                                                                                              -
                                                                                                              PermittedOptions inboundPermitted = new PermittedOptions().setAddress("demo.orderService");
-
-// 仅当用户已登录并且拥有权限 `place_orders`
-inboundPermitted.setRequiredAuthority("place_orders");
-
-BridgeOptions options = new BridgeOptions().addInboundPermitted(inboundPermitted);
-
                                                                                                              -

                                                                                                              用户需要登录，并被授权才能够访问消息。因此，您需要配置一个 Vert.x 认证处理器来处理登录和授权。例如：

                                                                                                              -
                                                                                                              Router router = Router.router(vertx);
-
-// 允许客户端向地址 `demo.orderService` 发送消息
-PermittedOptions inboundPermitted = new PermittedOptions().setAddress("demo.orderService");
-
-// 仅当用户已经登录并且包含 `place_orders` 权限
-inboundPermitted.setRequiredAuthority("place_orders");
-
-SockJSHandler sockJSHandler = SockJSHandler.create(vertx);
-sockJSHandler.bridge(new BridgeOptions().
-        addInboundPermitted(inboundPermitted));
-
-// 设置基础认证处理器
-
-router.route().handler(CookieHandler.create());
-router.route().handler(SessionHandler.create(LocalSessionStore.create(vertx)));
-
-AuthHandler basicAuthHandler = BasicAuthHandler.create(authProvider);
-
-router.route("/eventbus/*").handler(basicAuthHandler);
-
-
-router.route("/eventbus/*").handler(sockJSHandler);
-
                                                                                                              -

                                                                                                              处理 Event Bus 桥接器事件

                                                                                                              -

                                                                                                              如果您需要在在桥接器发生事件的时候得到通知，您需要在调用 bridge 方法时提供一个处理器。

                                                                                                              -

                                                                                                              任何发生的事件都会被传递到这个处理器。事件由对象 BridgeEvent 来描述。

                                                                                                              -

                                                                                                              事件可能是以下的某一种类型：

                                                                                                              -
                                                                                                                -

                                                                                                              • SOCKET_CREATED

                                                                                                                -

                                                                                                                当新的 SockJS 套接字创建时会发生该事件。

                                                                                                                -
                                                                                                                • -

                                                                                                              • SOCKET_IDLE

                                                                                                                -

                                                                                                                当 SockJS 的套接字的空闲事件超过出事设置会发生该事件。

                                                                                                                -
                                                                                                                • -

                                                                                                              • SOCKET_PING

                                                                                                                -

                                                                                                                当 SockJS 的套接字的 ping 时间戳被更新时会发生该事件。

                                                                                                                -
                                                                                                                • -

                                                                                                              • SOCKET_CLOSED

                                                                                                                -

                                                                                                                当 SockJS 的套接字关闭时会发生该事件。

                                                                                                                -
                                                                                                                • -

                                                                                                              • SEND

                                                                                                                -

                                                                                                                当试图将一个客户端消息发送到服务端时会发生该事件。

                                                                                                                -
                                                                                                                • -

                                                                                                              • PUBLISH

                                                                                                                -

                                                                                                                当试图将一个客户端消息发布到服务端时会发生该事件。

                                                                                                                -
                                                                                                                • -

                                                                                                              • RECEIVE

                                                                                                                -

                                                                                                                当试图将一个服务器端消息发布到客户端时会发生该事件。

                                                                                                                -
                                                                                                                • -

                                                                                                              • REGISTER

                                                                                                                -

                                                                                                                当客户端试图注册一个处理器时会发生该事件。

                                                                                                                -
                                                                                                                • -

                                                                                                              • UNREGISTER

                                                                                                                -

                                                                                                                当客户端试图注销一个处理器时会发生该事件。

                                                                                                                -
                                                                                                                • -
                                                                                                              -

                                                                                                              您可以通过 type 方法来获得事件的类型，通过 getRawMessage 方法来获得消息原始内容。

                                                                                                              -

                                                                                                              消息的原始内容是一个如下结构的 JSON 对象：

                                                                                                              -
                                                                                                              {
-  "type": "send"|"publish"|"receive"|"register"|"unregister",
-  "address": the event bus address being sent/published/registered/unregistered
-  "body": the body of the message
-}
-
                                                                                                              -

                                                                                                              事件对象同时是一个 Future 实例。当您完成了对消息的处理，您可以用参数 true 来完成这个 Future 以执行后续的处理。

                                                                                                              -

                                                                                                              如果您不希望事件继续处理，您可以用参数 false 来结束这个 Future。这个特性可以用于定制您自己的消息过滤器、细粒度的授权或指标收集。

                                                                                                              -

                                                                                                              在下面的例子里，我们拒绝掉了所有经过桥接器并且包含 “Armadillos” 一词的消息：

                                                                                                              -
                                                                                                              Router router = Router.router(vertx);
-
-// 允许客户端向地址 `demo.orderMgr` 发送消息
-PermittedOptions inboundPermitted = new PermittedOptions().setAddress("demo.someService");
-
-SockJSHandler sockJSHandler = SockJSHandler.create(vertx);
-BridgeOptions options = new BridgeOptions().addInboundPermitted(inboundPermitted);
-
-sockJSHandler.bridge(options, be -> {
-  if (be.type() == BridgeEventType.PUBLISH || be.type() == BridgeEventType.RECEIVE) {
-    if (be.getRawMessage().getString("body").equals("armadillos")) {
-      // 拒绝该消息
-      be.complete(false);
-      return;
-    }
-  }
-  be.complete(true);
-});
-
-router.route("/eventbus").handler(sockJSHandler);
-
                                                                                                              -

                                                                                                              下面的例子展示了如何配置并处理 SOCKET_IDDLE 事件。注意，setPingTimeout(5000) 的作用是当 ping 消息在 5 秒内没有从客户端返回时触发 SOCKET_IDLE 事件。

                                                                                                              -
                                                                                                              // 初始化 SockJS 处理器
-Router router = Router.router(vertx);
-
-SockJSHandler sockJSHandler = SockJSHandler.create(vertx);
-BridgeOptions options = new BridgeOptions().addInboundPermitted(inboundPermitted).setPingTimeout(5000);
-
-sockJSHandler.bridge(options, be -> {
-    if (be.type() == BridgeEventType.SOCKET_IDLE) {
-        // 执行某些处理
-    }
-
- be.complete(true);
-});
-
-router.route("/eventbus").handler(sockJSHandler);
-
                                                                                                              -

                                                                                                              在客户端 JavaScript 环境里您使用 vertx-eventbus.js 来创建到 Event Bus 的连接并发送和接收消息：

                                                                                                              -
                                                                                                              <script src="http://cdn.jsdelivr.net/sockjs/0.3.4/sockjs.min.js"></script>
-<script src='vertx-eventbus.js'></script>
-
-<script>
-
-var eb = new EventBus('http://localhost:8080/eventbus', {"vertxbus_ping_interval": 300000}); // sends ping every 5 minutes.
-
-eb.onopen = function() {
-
- // 设置一个接收消息的回调函数
- eb.registerHandler('some-address', function(error, message) {
-   console.log('received a message: ' + JSON.stringify(message));
- });
-
- // 发送消息
- eb.send('some-address', {name: 'tim', age: 587});
-}
-
-</script>
-
                                                                                                              -

                                                                                                              在这个例子中，第一件事是创建了一个 Event Bus 实例：

                                                                                                              -
                                                                                                              var eb = new EventBus('http://localhost:8080/eventbus', {"vertxbus_ping_interval": 300000});
-
                                                                                                              -

                                                                                                              构造函数的第二个参数是告诉 SockJS 的库每隔 5 分钟发送一个 ping 消息。由于服务器端配置了期望每隔 5 秒收到一条 ping 消息，因此会在服务器端触发 SOCKET_IDLE 事件。

                                                                                                              -

                                                                                                              您也可以在处理事件时修改原始的消息内容，例如修改消息体。对于从客户端发送来的消息，您也可以修改消息的消息头，下面是一个例子：

                                                                                                              -
                                                                                                              Router router = Router.router(vertx);
-
-// 允许客户端向地址 `demo.orderService` 发送消息
-PermittedOptions inboundPermitted = new PermittedOptions().setAddress("demo.orderService");
-
-SockJSHandler sockJSHandler = SockJSHandler.create(vertx);
-BridgeOptions options = new BridgeOptions().addInboundPermitted(inboundPermitted);
-
-sockJSHandler.bridge(options, be -> {
-  if (be.type() == BridgeEventType.PUBLISH || be.type() == BridgeEventType.SEND) {
-    // 添加消息头
-    JsonObject headers = new JsonObject().put("header1", "val").put("header2", "val2");
-    JsonObject rawMessage = be.getRawMessage();
-    rawMessage.put("headers", headers);
-    be.setRawMessage(rawMessage);
-  }
-  be.complete(true);
-});
-
-router.route("/eventbus").handler(sockJSHandler);
-
                                                                                                              -

                                                                                                              CSRF 跨站点请求伪造

                                                                                                              -

                                                                                                              CSRF 某些时候也被称为 XSRF。它是一种可以再未授权的网站获取用户隐私数据的技术。Vet.x-Web 提供了一个处理器 CSRFHandler 是您可以避免跨站点的伪造请求。

                                                                                                              -

                                                                                                              这个处理器会向所有的 GET 请求的响应里加一个独一无二的令牌作为 Cookie。客户端会在消息头里包含这个令牌。由于令牌基于 Cookie，因此需要在 Router 上启用 Cookie 处理器。

                                                                                                              -

                                                                                                              当开发非单页面应用，并依赖客户端来发送 POST 请求时，这个消息头没办法在 HTML 表单里指定。为了解决这个问题，这个令牌的值也会通过表单属性来检查。这只会发生在请求中不存在这个消息头，并且表单中包含同名属性时。例如：

                                                                                                              -
                                                                                                              <form action="/submit" method="POST">
-<input type="hidden" name="X-XSRF-TOKEN" value="abracadabra">
-</form>
-
                                                                                                              -

                                                                                                              您需要将表单的属性设置为正确的值。填充这个值唯一的办法是通过上下文来获取键 X-XSRF-TOKEN 的值。这个键的名称也可以在初始化 CSRFHandler 时指定。

                                                                                                              -
                                                                                                              router.route().handler(CookieHandler.create());
-router.route().handler(CSRFHandler.create("abracadabra"));
-router.route().handler(rc -> {
-
-});
-
                                                                                                              -

                                                                                                              虚机主机处理器

                                                                                                              -

                                                                                                              虚机主机处理器会验证请求的主机名。如果匹配成功，则转发这个请求到注册的处理器上。否则，继续在原先的处理器链中执行。

                                                                                                              -

                                                                                                              处理器通过请求的消息头 Host 来进行匹配，并支持基于通配符的模式匹配。例如 *.vertx.io 或完整的域名 www.vertx.io。

                                                                                                              -
                                                                                                              router.route().handler(VirtualHostHandler.create("*.vertx.io", routingContext -> {
-  // 如果请求访问虚机主机 `*.vertx.io` ，执行某些处理
-}));
-
                                                                                                              -

                                                                                                              OAuth2 认证处理器

                                                                                                              -

                                                                                                              OAuth2AuthHandler 帮助您快速地配置基于 OAuth2 协议的安全路由。这个处理器简化了获取 authCode 的流程。下面的例子用这个处理器实现了保护资源并通过 GitHub 来授权：

                                                                                                              -
                                                                                                              OAuth2Auth authProvider = GithubAuth.create(vertx, "CLIENT_ID", "CLIENT_SECRET");
-
-// 在服务器上创建 oauth2 处理器
-// 第二个参数是您提供给您的提供商的回调 URL
-OAuth2AuthHandler oauth2 = OAuth2AuthHandler.create(authProvider, "https://myserver.com/callback");
-
-// 配置回调处理器来接收 GitHub 的回调
-oauth2.setupCallback(router.route());
-
-// 保护 `/protected` 路径下的资源
-router.route("/protected/*").handler(oauth2);
-// 在 `/protected` 路径下挂载某些处理器
-router.route("/protected/somepage").handler(rc -> {
-  rc.response().end("Welcome to the protected resource!");
-});
-
-// 欢迎页
-router.get("/").handler(ctx -> {
-  ctx.response().putHeader("content-type", "text/html").end("Hello<br><a href=\"/protected/somepage\">Protected by Github</a>");
-});
-
                                                                                                              -

                                                                                                              OAuth2AuthHandler 会配置一个正确的 OAuth2 回调，因此您不需要处理授权服务器的响应。一个很重要的事情是，来自授权服务器的响应只有一次有效。也就是说如果客户端对回调 URL 发起了重载操作，则会因为验证错误而请求失败。

                                                                                                              -

                                                                                                              经验法则是：当有效的回调执行时，通知客户端跳转到受保护的资源上。

                                                                                                              -

                                                                                                              就 OAuth2 规范的生态来看，使用其他的 OAuth2 提供商需要作出少许的修改。为此，Vertx Auth 提供了若干开箱即用的实现：

                                                                                                              - -

                                                                                                              如果您需要使用一个上述未列出的提供商，您也可以使用基本的 API 来实现，例如：

                                                                                                              -
                                                                                                              OAuth2Auth authProvider = OAuth2Auth.create(vertx, OAuth2FlowType.AUTH_CODE, new OAuth2ClientOptions()
-    .setClientID("CLIENT_ID")
-    .setClientSecret("CLIENT_SECRET")
-    .setSite("https://accounts.google.com")
-    .setTokenPath("https://www.googleapis.com/oauth2/v3/token")
-    .setAuthorizationPath("/o/oauth2/auth"));
-
-// 在域名 `http://localhost:8080` 上创建 oauth2 处理器
-OAuth2AuthHandler oauth2 = OAuth2AuthHandler.create(authProvider, "http://localhost:8080");
-
-// 配置需要的权限
-oauth2.addAuthority("profile");
-
-// 配置回调处理器来接收 Google 的回调
-oauth2.setupCallback(router.get("/callback"));
-
-// 保护 `/protected` 路径下的资源
-router.route("/protected/*").handler(oauth2);
-// 在 `/protected` 路径下挂载某些处理器
-router.route("/protected/somepage").handler(rc -> {
-  rc.response().end("Welcome to the protected resource!");
-});
-
-// 欢迎页
-router.get("/").handler(ctx -> {
-  ctx.response().putHeader("content-type", "text/html").end("Hello<br><a href=\"/protected/somepage\">Protected by Google</a>");
-});
-
                                                                                                              -

                                                                                                              您需要手工提供所有关于您所使用的提供商的细节，但结果是一样的。

                                                                                                              -

                                                                                                              这个处理器会在您的应用上绑定回调的 URL。用法很简单，只需要为这个处理器提供一个路由(Route)，其他的配置都会自动完成。一个典型的情况是您的 OAuth2 提供商会需要您来提供您的应用的 callback url，则您的输入类似于 https://myserver.com/callback。这是您的处理器的第二个参数。至此，您完成所有必须的配置，只需要通过 setupCallback 方法来启动它即可。

                                                                                                              -

                                                                                                              以上就是如何在您的服务器上绑定处理器 https://myserver.com:8447/callback。注意，端口号可以不使用默认值。

                                                                                                              -
                                                                                                              OAuth2AuthHandler oauth2 = OAuth2AuthHandler.create(provider, "https://myserver.com:8447/callback");
-// 允许该处理器为您处理回调地址
-oauth2.setupCallback(router.route());
-
                                                                                                              -

                                                                                                              在这个例子中，Route 对象通过 Router.route() 创建。如果您需要完整的控制处理器的执行顺序（例如您期望它在处理链中首先被执行），您也可以先创建这个 Route 对象，然后将引用传进这个方法里。

                                                                                                              -

                                                                                                              混合 OAuth2 和 JWT

                                                                                                              -

                                                                                                              一些 OAuth2 的提供商参考了 RFC6750 规范，使用 JWT 令牌来作为访问令牌。这对于需要混合基于客户端的授权和基于 API 的授权很有用。例如您的应用提供了一些受保护的 HTML 文档，同时您又希望他可以作为 API 被消费。在这种情况下，一个 API 不能够很容易的处理 OAuth2 需要的重定向握手，但可以提供令牌(11)。

                                                                                                              -

                                                                                                              只要提供商被配置为支持 JWT，OAuth 处理器会自动处理这个问题。

                                                                                                              -

                                                                                                              这意味着您的 API 可以通过提供值为 Bearer BASE64_ACCESS_TOKEN 的消息头 Authorization 来访问受保护的资源。

                                                                                                              -

                                                                                                              注释

                                                                                                              -
                                                                                                                -
                                                                                                              1. 指 HTTP 协议的 Method
                                                                                                                2. -
                                                                                                              2. 内容协商 指允许同一个 URI 可以根据请求中的 Accept 字段来提供资源的不同版本。
                                                                                                                3. -
                                                                                                              3. accept 指 Router 的 accept 方法。示例代码使用了 Java 8 Lambda 的 方法引用 语法。
                                                                                                                4. -
                                                                                                              4. Reroute 一词没有找到合适的方式来描述，译为了 转发。此处有别于 HTTP 的 Redirect 或 Proxy 等概念，只是进程内的逻辑跳转。
                                                                                                                5. -
                                                                                                              5. 会话 Cookie 也即 Session Cookie，特指有效期为 session 的 Cookie。可参考 MSDN。
                                                                                                                6. -
                                                                                                              6. 或可称之为不可枚举的。可防止碰撞攻击。
                                                                                                                7. -
                                                                                                              7. 指通过 vertx.executeBlocking 方法来定期刷新生成器的种子，在 Event Loop 线程中同步执行生成随机数的过程。
                                                                                                                8. -
                                                                                                              8. 即 Route.failureHandler。
                                                                                                                9. -
                                                                                                              9. 实际上不同的 transport 具有不同的会话处理机制。sessionTimeout 主要针对轮询方式的 transport，例如 xhr。服务器端返回一个响应之后，客户端一旦接受了响应，会立刻再发一个 request 出来继续等下一个消息。如果超过了默认的 5 秒该会话没有收到新的请求，则会认为客户端断开了连接，会话过期。
                                                                                                                10. -
                                                                                                              10. 关于 OAuth2 如何通过 JWT 来进行授权，可以 参考这里。
                                                                                                                11. -
                                                                                                              -

                                                                                                              结语

                                                                                                              -

                                                                                                              route 一词同时具有名词和动词的含义。为了避免混淆，原文中所有使用名词的地方都统一按照专有名词 Route / route 处理。原文中的动词统一译为 路由。原文的最后几部分关于 SockJS 和 OAuth2 的内容写作风格明显和前文不同，而且有些地方描述的很简略（例如 OAuth 流程的细节、SockJS 的不同 Transport 之间的差异等）。本着翻译准确的原则，本译文没有进一步展开描述。

                                                                                                              - - -
                                                                                                              - -
                                                                                                              -
                                                                                                              -
                                                                                                              - -

                                                                                                              results matching ""

                                                                                                              -
                                                                                                                - -
                                                                                                                -
                                                                                                                - -

                                                                                                                No results matching ""

                                                                                                                - -
                                                                                                                -
                                                                                                                -
                                                                                                                - -
                                                                                                                -
                                                                                                                - -
                                                                                                                - - - - - - - - - - - - - - -
                                                                                                                - - -
                                                                                                                - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/docs/webclient/WebClient.html b/docs/webclient/WebClient.html deleted file mode 100644 index ab244ed..0000000 --- a/docs/webclient/WebClient.html +++ /dev/null @@ -1,1544 +0,0 @@ - - - - - - - Web Client · Vert.x 官方文档中文翻译 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                                                                                                -
                                                                                                                - - - - - - - - -
                                                                                                                - -
                                                                                                                - -
                                                                                                                - - - - - - - - -
                                                                                                                -
                                                                                                                - -
                                                                                                                -
                                                                                                                - -
                                                                                                                - -

                                                                                                                Vert.x Web Client

                                                                                                                - -

                                                                                                                中英对照表

                                                                                                                -
                                                                                                                  -
                                                                                                                • Pump：泵（平滑流式数据读入内存的机制，防止一次性将大量数据读入内存导致内存溢出）
                                                                                                                  • -
                                                                                                                • Response Codec：响应编解码器（编码及解码工具）
                                                                                                                  • -
                                                                                                                • Body Codec：响应体编解码器
                                                                                                                  • -
                                                                                                                -

                                                                                                                组件介绍

                                                                                                                -

                                                                                                                Vert.x Web Client（Web客户端）是一个异步的 HTTP 和 HTTP/2 客户端。

                                                                                                                -

                                                                                                                Web Client使得发送 HTTP 请求以及从 Web 服务器接收 HTTP 响应变得更加便捷，同时提供了额外的高级功能，例如：

                                                                                                                -
                                                                                                                  -

                                                                                                                • JSON体的编码和解码

                                                                                                                  -
                                                                                                                  • -

                                                                                                                • 请求和响应泵

                                                                                                                  -
                                                                                                                  • -

                                                                                                                • 请求参数的处理

                                                                                                                  -
                                                                                                                  • -

                                                                                                                • 统一的错误处理

                                                                                                                  -
                                                                                                                  • -

                                                                                                                • 提交表单

                                                                                                                  -
                                                                                                                  • -
                                                                                                                -

                                                                                                                制作Web Client的目的并非为了替换Vert.x Core中的 HttpClient，而是基于该客户端，扩展并保留其便利的设置和特性，例如请求连接池（Pooling），HTTP/2的支持，流水线／管线的支持等。当您需要对 HTTP 请求和响应做细微粒度控制时，您应当使用 HttpClient。

                                                                                                                -

                                                                                                                另外Web Client并未提供 WebSocket API，此时您应当使用 HttpClient。

                                                                                                                -

                                                                                                                使用Web Client

                                                                                                                -

                                                                                                                如需使用Vert.x Web Client，请先加入以下依赖：

                                                                                                                -
                                                                                                                  -

                                                                                                                • Maven（在 pom.xml文件中）：

                                                                                                                  -
                                                                                                                  <dependency>
-  <groupId>io.vertx</groupId>
-  <artifactId>vertx-web-client</artifactId>
-  <version>3.4.1</version>
-</dependency>
-
                                                                                                                  -
                                                                                                                  • -

                                                                                                                • Gradle（在build.gradle文件中）：

                                                                                                                  -
                                                                                                                  dependencies {
-  compile 'io.vertx:vertx-web-client:3.4.1'
-}
-
                                                                                                                  -
                                                                                                                  • -
                                                                                                                -

                                                                                                                对Vert.x Core HTTP Client的回顾

                                                                                                                -

                                                                                                                Vert.x Web Client使用Vert.x Core的API，如您对此还不熟悉，请先熟悉 HttpClient 的一些基本概念。

                                                                                                                -

                                                                                                                创建Web Client

                                                                                                                -

                                                                                                                您可使用缺省设置创建一个 WebClient：

                                                                                                                -
                                                                                                                WebClient client = WebClient.create(vertx);
-
                                                                                                                -

                                                                                                                您亦可使用配置选项来创建客户端：

                                                                                                                -
                                                                                                                WebClientOptions options = new WebClientOptions()
-  .setUserAgent("My-App/1.2.3");
-options.setKeepAlive(false);
-WebClient client = WebClient.create(vertx, options);
-
                                                                                                                -

                                                                                                                Web Client配置选项继承自 HttpClient 配置选项，使用时可根据实际情况选择。

                                                                                                                -

                                                                                                                如已在程序中创建 HttpClient，可用以下方式复用：

                                                                                                                -
                                                                                                                WebClient client = WebClient.wrap(httpClient);
-
                                                                                                                -

                                                                                                                发送请求

                                                                                                                -

                                                                                                                无请求体的简单请求

                                                                                                                -

                                                                                                                一般情况下，HTTP GET，OPTIONS以及HEAD请求没有请求体，可用以下方式发送无请求体的HTTP Requests（HTTP请求）：

                                                                                                                -
                                                                                                                WebClient client = WebClient.create(vertx);
-
-// 发送GET请求
-client
-  .get(8080, "myserver.mycompany.com", "/some-uri")
-  .send(ar -> {
-    if (ar.succeeded()) {
-      // 获取响应
-      HttpResponse<Buffer> response = ar.result();
-
-      System.out.println("Received response with status code" + response.statusCode());
-    } else {
-      System.out.println("Something went wrong " + ar.cause().getMessage());
-    }
-  });
-
-//发送HEAD请求
-client
-  .head(8080, "myserver.mycompany.com", "/some-uri")
-  .send(ar -> {
-    if (ar.succeeded()) {
-      // 获取响应
-      HttpResponse<Buffer> response = ar.result();
-
-      System.out.println("Received response with status code" + response.statusCode());
-    } else {
-      System.out.println("Something went wrong " + ar.cause().getMessage());
-    }
-  });
-
                                                                                                                -

                                                                                                                您可用以下链式方式向请求URI添加查询参数

                                                                                                                -
                                                                                                                client
-  .get(8080, "myserver.mycompany.com", "/some-uri")
-  .addQueryParam("param", "param_value")
-  .send(ar -> {});
-
                                                                                                                -

                                                                                                                在请求URI中的参数将会被预填充

                                                                                                                -
                                                                                                                HttpRequest<Buffer> request = client.get(8080, "myserver.mycompany.com", "/some-uri?param1=param1_value&param2=param2_value");
-
-// 添加param3（参数3）
-request.addQueryParam("param3", "param3_value");
-
-// 覆盖param2（参数2）
-request.setQueryParam("param2", "another_param2_value");
-
                                                                                                                -

                                                                                                                设置请求URI将会自动清除已有的查询参数

                                                                                                                -
                                                                                                                HttpRequest<Buffer> request = client.get(8080, "myserver.mycompany.com", "/some-uri");
-
-// 添加param1（参数1）
-request.addQueryParam("param1", "param1_value");
-
-// 覆盖param1（参数1）同时新增param2（参数2）
-request.uri("/some-uri?param1=param1_value&param2=param2_value");
-
                                                                                                                -

                                                                                                                填充请求体

                                                                                                                -

                                                                                                                如需要发送请求体，可使用相同的API并在最后加上 sendXXX 方法发送相应的请求体。

                                                                                                                -

                                                                                                                例如用 sendBuffer 方法发送一个缓冲体：

                                                                                                                -
                                                                                                                client
-  .post(8080, "myserver.mycompany.com", "/some-uri")
-  .sendBuffer(buffer, ar -> {
-    if (ar.succeeded()) {
-      // Ok
-    }
-  });
-
                                                                                                                -

                                                                                                                有时候我们并不希望将所有数据一次性全部读入内存，因为文件太大或希望同时处理多个请求，希望每个请求仅使用最小的内存。出于此目的，Web Client可用 sendStream 方法发送流式数据 ReadStream<Buffer>（例如 AsyncFile 便是一个 ReadStream<Buffer>）：

                                                                                                                -
                                                                                                                client
-  .post(8080, "myserver.mycompany.com", "/some-uri")
-  .sendStream(stream, resp -> {});
-
                                                                                                                -

                                                                                                                Web Client会为您设置好传输泵以平滑传输流。如果流长度未知则使用分块传输（chunked transfer）。

                                                                                                                -

                                                                                                                如已知流的大小，可在HTTP协议头中设置 content-length 属性

                                                                                                                -
                                                                                                                fs.open("content.txt", new OpenOptions(), fileRes -> {
-  if (fileRes.succeeded()) {
-    ReadStream<Buffer> fileStream = fileRes.result();
-
-    String fileLen = "1024";
-
-    // 用POST方法发送文件
-    client
-      .post(8080, "myserver.mycompany.com", "/some-uri")
-      .putHeader("content-length", fileLen)
-      .sendStream(fileStream, ar -> {
-        if (ar.succeeded()) {
-          // Ok
-        }
-      });
-  }
-});
-
                                                                                                                -

                                                                                                                此时POST方法不会使用分块传输。

                                                                                                                -

                                                                                                                JSON体

                                                                                                                -

                                                                                                                有时您需要在请求体中使用JSON格式，可使用 sendJsonObject 方法发送 JsonObject：

                                                                                                                -
                                                                                                                client
-  .post(8080, "myserver.mycompany.com", "/some-uri")
-  .sendJsonObject(new JsonObject()
-    .put("firstName", "Dale")
-    .put("lastName", "Cooper"), ar -> {
-    if (ar.succeeded()) {
-      // Ok
-    }
-  });
-
                                                                                                                -

                                                                                                                在Java，Groovy以及Kotlin语言中，您亦可使用 sendJson 方法发送POJO（Plain Old Java Object），该方法会自动调用 Json.encode 方法将 POJO 映射为 JSON：

                                                                                                                -
                                                                                                                client
-  .post(8080, "myserver.mycompany.com", "/some-uri")
-  .sendJson(new User("Dale", "Cooper"), ar -> {
-    if (ar.succeeded()) {
-      // Ok
-    }
-  });
-
                                                                                                                -
                                                                                                                -

                                                                                                                请注意： Json.encode 方法使用Jackson的 mapper将 POJO 映射成 JSON。

                                                                                                                -
                                                                                                                -

                                                                                                                表单提交

                                                                                                                -

                                                                                                                您可使用 sendForm 方法发送HTTP表单。

                                                                                                                -
                                                                                                                MultiMap form = MultiMap.caseInsensitiveMultiMap();
-form.set("firstName", "Dale");
-form.set("lastName", "Cooper");
-
-// 用URL编码方式提交表单
-client
-  .post(8080, "myserver.mycompany.com", "/some-uri")
-  .sendForm(form, ar -> {
-    if (ar.succeeded()) {
-      // Ok
-    }
-  });
-
                                                                                                                -

                                                                                                                缺省情况下，提交表单的请求头中的 content-type 属性值为 application/x-www-form-urlencoded，您亦可将其设置为 multipart/form-data：

                                                                                                                -
                                                                                                                MultiMap form = MultiMap.caseInsensitiveMultiMap();
-form.set("firstName", "Dale");
-form.set("lastName", "Cooper");
-
-// 用分块方式编码提交表单
-client
-  .post(8080, "myserver.mycompany.com", "/some-uri")
-  .putHeader("content-type", "multipart/form-data")
-  .sendForm(form, ar -> {
-    if (ar.succeeded()) {
-      // Ok
-    }
-  });
-
                                                                                                                -
                                                                                                                -

                                                                                                                请注意：当前版本并不支持分块文件编码（multipart files，即文件上传），该功能可能在将来版本中予以支持。

                                                                                                                -
                                                                                                                -

                                                                                                                填充请求头

                                                                                                                -

                                                                                                                您可使用以下方式填充请求头：

                                                                                                                -
                                                                                                                HttpRequest<Buffer> request = client.get(8080, "myserver.mycompany.com", "/some-uri");
-MultiMap headers = request.headers();
-headers.set("content-type", "application/json");
-headers.set("other-header", "foo");
-
                                                                                                                -

                                                                                                                此处 Headers 是一个 MultiMap 对象，提供了增加、设置以及删除头属性操作的入口。HTTP头的某些特定属性允许设置多个值。

                                                                                                                -

                                                                                                                您亦可通过 putHeader 方法写入头属性：

                                                                                                                -
                                                                                                                HttpRequest<Buffer> request = client.get(8080, "myserver.mycompany.com", "/some-uri");
-request.putHeader("content-type", "application/json");
-request.putHeader("other-header", "foo");
-
                                                                                                                -

                                                                                                                重用请求

                                                                                                                -

                                                                                                                send 方法可被重复多次调用，这使得配置以及重用 HttpRequest 对象变得更加便捷：

                                                                                                                -
                                                                                                                HttpRequest<Buffer> get = client.get(8080, "myserver.mycompany.com", "/some-uri");
-get.send(ar -> {
-  if (ar.succeeded()) {
-    // Ok
-  }
-});
-
-// 再次发送同样的请求
-get.send(ar -> {
-  if (ar.succeeded()) {
-    // Ok
-  }
-});
-
                                                                                                                -

                                                                                                                当您需要更改请求时，可用 copy 方法复制一份请求的拷贝：

                                                                                                                -
                                                                                                                HttpRequest<Buffer> get = client.get(8080, "myserver.mycompany.com", "/some-uri");
-get.send(ar -> {
-  if (ar.succeeded()) {
-    // Ok
-  }
-});
-
-// 获取同样的请求
-get.copy()
-  .putHeader("an-header", "with-some-value")
-  .send(ar -> {
-  if (ar.succeeded()) {
-    // Ok
-  }
-
                                                                                                                -

                                                                                                                超时

                                                                                                                -

                                                                                                                您可通过 timeout 方法设置超时时间。

                                                                                                                -
                                                                                                                client
-  .get(8080, "myserver.mycompany.com", "/some-uri")
-  .timeout(5000)
-  .send(ar -> {
-    if (ar.succeeded()) {
-      // Ok
-    } else {
-      // 此处可填入超时处理部分代码
-    }
-  });
-
                                                                                                                -

                                                                                                                若请求在设定时间内没返回任何数据，则一个超时异常将会传递给响应处理代码。

                                                                                                                -

                                                                                                                处理HTTP响应

                                                                                                                -

                                                                                                                Web Client请求发送之后，返回的结果将会被包装在异步结果 HttpResponse 中。

                                                                                                                -

                                                                                                                当响应被成功接收到之后，相应的回调函数将会被触发。

                                                                                                                -
                                                                                                                client
-  .get(8080, "myserver.mycompany.com", "/some-uri")
-  .send(ar -> {
-    if (ar.succeeded()) {
-
-      HttpResponse<Buffer> response = ar.result();
-
-      System.out.println("Received response with status code" + response.statusCode());
-    } else {
-      System.out.println("Something went wrong " + ar.cause().getMessage());
-    }
-  });
-
                                                                                                                -
                                                                                                                -

                                                                                                                警告：缺省状况下，响应会被完全缓冲读入内存，请用 BodyCodec.pipe 方法将响应写入流。

                                                                                                                -
                                                                                                                -

                                                                                                                响应编解码器

                                                                                                                -

                                                                                                                缺省状况下，响应以缓冲形式提供，并不提供任何形式的解码。

                                                                                                                -

                                                                                                                可用 BodyCodec 将响应定制成以下类型：

                                                                                                                -
                                                                                                                  -
                                                                                                                • 普通字符串
                                                                                                                  • -
                                                                                                                • JSON对象
                                                                                                                  • -
                                                                                                                • 将JSON映射成POJO
                                                                                                                  • -
                                                                                                                • WriteStream
                                                                                                                  • -
                                                                                                                -

                                                                                                                响应体编解码器对二进制数据流解码，以节省您在响应处理中的代码。

                                                                                                                -

                                                                                                                使用 BodyCodec.jsonObject 将结果解码为JSON对象：

                                                                                                                -
                                                                                                                client
-  .get(8080, "myserver.mycompany.com", "/some-uri")
-  .as(BodyCodec.jsonObject())
-  .send(ar -> {
-    if (ar.succeeded()) {
-      HttpResponse<JsonObject> response = ar.result();
-
-      JsonObject body = response.body();
-
-      System.out.println("Received response with status code" + response.statusCode() + " with body " + body);
-    } else {
-      System.out.println("Something went wrong " + ar.cause().getMessage());
-    }
-  });
-
                                                                                                                -

                                                                                                                在Java，Groovy以及Kotlin语言中，JSON对象可被解码映射成POJO：

                                                                                                                -
                                                                                                                client
-  .get(8080, "myserver.mycompany.com", "/some-uri")
-  .as(BodyCodec.json(User.class))
-  .send(ar -> {
-    if (ar.succeeded()) {
-      HttpResponse<User> response = ar.result();
-
-      User user = response.body();
-
-      System.out.println("Received response with status code" + response.statusCode() + " with body " +
-        user.getFirstName() + " " + user.getLastName());
-    } else {
-      System.out.println("Something went wrong " + ar.cause().getMessage());
-    }
-  });
-
                                                                                                                -

                                                                                                                当响应结果较大时，请使用 BodyCodec.pipe 方法。响应体编解码器将响应结果压入 WriteStream 并在最后发出成功或失败的信号。

                                                                                                                -
                                                                                                                client
-  .get(8080, "myserver.mycompany.com", "/some-uri")
-  .as(BodyCodec.pipe(writeStream))
-  .send(ar -> {
-    if (ar.succeeded()) {
-
-      HttpResponse<Void> response = ar.result();
-
-      System.out.println("Received response with status code" + response.statusCode());
-    } else {
-      System.out.println("Something went wrong " + ar.cause().getMessage());
-    }
-  });
-
                                                                                                                -

                                                                                                                最后，如您对响应结果不感兴趣，可用 BodyCodec.none 废弃响应体。

                                                                                                                -
                                                                                                                client
-  .get(8080, "myserver.mycompany.com", "/some-uri")
-  .as(BodyCodec.none())
-  .send(ar -> {
-    if (ar.succeeded()) {
-
-      HttpResponse<Void> response = ar.result();
-
-      System.out.println("Received response with status code" + response.statusCode());
-    } else {
-      System.out.println("Something went wrong " + ar.cause().getMessage());
-    }
-  });
-
                                                                                                                -

                                                                                                                若无法预知响应内容类型，您依旧可以在获取结果之后，用 bodyAsXXX() 方法将其转换成特定的类型

                                                                                                                -
                                                                                                                client
-  .get(8080, "myserver.mycompany.com", "/some-uri")
-  .send(ar -> {
-    if (ar.succeeded()) {
-
-      HttpResponse<Buffer> response = ar.result();
-
-      // 将结果解码为Json对象
-      JsonObject body = response.bodyAsJsonObject();
-
-      System.out.println("Received response with status code" + response.statusCode() + " with body " + body);
-    } else {
-      System.out.println("Something went wrong " + ar.cause().getMessage());
-    }
-  });
-
                                                                                                                -
                                                                                                                -

                                                                                                                警告：这种方式仅对响应结果为缓冲体有效。

                                                                                                                -
                                                                                                                -

                                                                                                                处理30x重定向

                                                                                                                -

                                                                                                                缺省状况下，客户端将会依照30x状态码自动重定向，您可使用 WebClientOptions 予以配置：

                                                                                                                -
                                                                                                                WebClient client = WebClient.create(vertx, new WebClientOptions().setFollowRedirects(false));
-
                                                                                                                -

                                                                                                                客户端将会执行最多达16次重定向，该参数亦可在 WebClientOptions 配置：

                                                                                                                -
                                                                                                                WebClient client = WebClient.create(vertx, new WebClientOptions().setMaxRedirects(5));
-
                                                                                                                -

                                                                                                                使用HTTPS

                                                                                                                -

                                                                                                                Vert.x Web Client可用与 HttpClient 相同方式配置HTTPS协议。

                                                                                                                -

                                                                                                                您可对每个请求单独设置：

                                                                                                                -
                                                                                                                client
-  .get(443, "myserver.mycompany.com", "/some-uri")
-  .ssl(true)
-  .send(ar -> {
-    if (ar.succeeded()) {
-      // 获取响应
-      HttpResponse<Buffer> response = ar.result();
-
-      System.out.println("Received response with status code" + response.statusCode());
-    } else {
-      System.out.println("Something went wrong " + ar.cause().getMessage());
-    }
-  });
-
                                                                                                                -

                                                                                                                或使用绝对路径：

                                                                                                                -
                                                                                                                client
-  .getAbs("https://myserver.mycompany.com:4043/some-uri")
-  .send(ar -> {
-    if (ar.succeeded()) {
-      // 获取响应
-      HttpResponse<Buffer> response = ar.result();
-
-      System.out.println("Received response with status code" + response.statusCode());
-    } else {
-      System.out.println("Something went wrong " + ar.cause().getMessage());
-    }
-  });
-
                                                                                                                -

                                                                                                                RxJava API

                                                                                                                -

                                                                                                                RxJava的 HttpRequest 提供了原版API的响应式版本，rxSend 方法返回一个可被订阅的 Single<HttpResponse<Buffer>>，故单个 Single 可被多次订阅。

                                                                                                                -
                                                                                                                Single<HttpResponse<Buffer>> single = client
-  .get(8080, "myserver.mycompany.com", "/some-uri")
-  .rxSend();
-
-// 发送一次请求，并处理其响应，rx通常通过订阅触发各种响应
-single.subscribe(response -> {
-  System.out.println("Received 1st response with status code" + response.statusCode());
-}, error -> {
-  System.out.println("Something went wrong " + error.getMessage());
-});
-
-// 再次发送请求
-single.subscribe(response -> {
-  System.out.println("Received 2nd response with status code" + response.statusCode());
-}, error -> {
-  System.out.println("Something went wrong " + error.getMessage());
-});
-
                                                                                                                -

                                                                                                                获取到的 Single 可与其它RxJava API自然组合成链式处理

                                                                                                                -
                                                                                                                Single<String> url = client
-  .get(8080, "myserver.mycompany.com", "/some-uri")
-  .rxSend()
-  .map(HttpResponse::bodyAsString);
-
-// 用flatMap将返回值内的链接作为参数传入lambda，在lambda中将其设置成发送请求，并返回Single，在下一步订阅中予以触发
-url
-  .flatMap(u -> client.getAbs(u).rxSend())
-  .subscribe(response -> {
-    System.out.println("Received response with status code" + response.statusCode());
-  }, error -> {
-    System.out.println("Something went wrong " + error.getMessage());
-  });
-
                                                                                                                -

                                                                                                                之前的例子可写成

                                                                                                                -
                                                                                                                Single<HttpResponse<JsonObject>> single = client
-  .get(8080, "myserver.mycompany.com", "/some-uri")
-  .putHeader("some-header", "header-value")
-  .addQueryParam("some-param", "param value")
-  .as(BodyCodec.jsonObject())
-  .rxSend();
-single.subscribe(resp -> {
-  System.out.println(resp.statusCode());
-  System.out.println(resp.body());
-});
-
                                                                                                                -

                                                                                                                当发送请求体为 Observable<Buffer> 时，应使用 sendStream：

                                                                                                                -
                                                                                                                Observable<Buffer> body = getPayload();
-
-Single<HttpResponse<Buffer>> single = client
-  .post(8080, "myserver.mycompany.com", "/some-uri")
-  .rxSendStream(body);
-single.subscribe(resp -> {
-  System.out.println(resp.statusCode());
-  System.out.println(resp.body());
-});
-
                                                                                                                -

                                                                                                                当订阅时，body 将会被订阅，其内容将会被用于请求中。

                                                                                                                -
                                                                                                                -
                                                                                                                -

                                                                                                                原文上次编辑于2017-03-15 15:54:14 欧洲中部时间

                                                                                                                -
                                                                                                                - - -
                                                                                                                - -
                                                                                                                -
                                                                                                                -
                                                                                                                - -

                                                                                                                results matching ""

                                                                                                                -
                                                                                                                  - -
                                                                                                                  -
                                                                                                                  - -

                                                                                                                  No results matching ""

                                                                                                                  - -
                                                                                                                  -
                                                                                                                  -
                                                                                                                  - -
                                                                                                                  -
                                                                                                                  - -
                                                                                                                  - - - - - - - - - - - - - - -
                                                                                                                  - - -
                                                                                                                  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - From 169efea26bd52976be69729b010e611274546f08 Mon Sep 17 00:00:00 2001 From: downgoon Date: Fri, 9 Jun 2017 15:56:33 +0800 Subject: [PATCH 4/4] markdown toc plugin changed to gitbook-markdown-etoc from gitbook-markdown-toc due to the previous one's auto-gen feature --- book.json | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/book.json b/book.json index b834a52..fc0517a 100644 --- a/book.json +++ b/book.json @@ -30,12 +30,13 @@ "pageNumbers": false, "paperSize": "a4" }, - "plugins": ["atoc"], + "plugins": ["etoc"], "pluginsConfig": { - "atoc": { - "addClass": true, - "className": "atoc" - } + "etoc": { + "mindepth": 2, + "maxdepth": 4, + "notoc": false + } }, "title": "Vert.x 官方文档中文翻译", "variables": {}