<!doctype html><html lang=zh-cn class=no-js><head><meta name=ROBOTS content="INDEX, FOLLOW"><link rel=canonical href=https://dubbo.apache.org/zh-cn/overview/mannual/java-sdk/faq/7/><meta charset=utf-8><meta name=viewport content="width=device-width,initial-scale=1,shrink-to-fit=no"><meta name=generator content="Hugo 0.120.4"><link rel=alternate type=application/rss+xml href=https://dubbo.apache.org/zh-cn/overview/mannual/java-sdk/faq/7/index.xml><link rel="shortcut icon" type=image/png href=/imgs/favicon.png><link rel=apple-touch-icon href=/favicons/apple-touch-icon-180x180.png sizes=180x180><link rel=manifest href=/manifest.webmanifest><title>7 - QoS 插件模块 | Apache Dubbo</title><meta property="og:title" content="7 - QoS 插件模块">
<meta property="og:description" content="7 - QoS 插件模块"><meta property="og:type" content="website"><meta property="og:url" content="https://dubbo.apache.org/zh-cn/overview/mannual/java-sdk/faq/7/"><meta itemprop=name content="7 - QoS 插件模块"><meta itemprop=description content="7 - QoS 插件模块"><meta name=twitter:card content="summary"><meta name=twitter:title content="7 - QoS 插件模块"><meta name=twitter:description content="7 - QoS 插件模块"><script async src="https://www.googletagmanager.com/gtag/js?id=G-1TFHM5YBH0"></script><script>var doNotTrack=!1;if(!doNotTrack){window.dataLayer=window.dataLayer||[];function gtag(){dataLayer.push(arguments)}gtag("js",new Date),gtag("config","G-1TFHM5YBH0",{anonymize_ip:!1})}</script><link rel=preload href=/scss/main.min.fe7176cbe3102a33d3e8c0c9cec61eb52508abd24a2cc1ae23ccf535a481ffde.css as=style><link href=/scss/main.min.fe7176cbe3102a33d3e8c0c9cec61eb52508abd24a2cc1ae23ccf535a481ffde.css rel=stylesheet integrity><script src=/js/jquery-3.5.1.min.js integrity="sha256-9/aliU8dGd2tb6OSsuzixeV4y/faTqgFtohetphbbj0=" crossorigin=anonymous></script><link rel=stylesheet href=https://cdn.jsdelivr.net/npm/@docsearch/css@3><meta name=theme-color content="#326ce5"><link rel=stylesheet href=/css/feature-states.css><meta name=description content="7 - QoS 插件模块"><meta property="og:description" content="7 - QoS 插件模块"><meta name=twitter:description content="7 - QoS 插件模块"><meta property="og:url" content="https://dubbo.apache.org/zh-cn/overview/mannual/java-sdk/faq/7/"><meta property="og:title" content="7 - QoS 插件模块"><meta name=twitter:title content="7 - QoS 插件模块"><meta name=twitter:image:alt content="Apache Dubbo"><meta property="og:type" content="article"><meta name=viewport content="width=device-width"><script async defer src=/js/github-buttons.js></script><link href=/css/community.css rel=stylesheet><link href=/css/contactus.css rel=stylesheet><link href=/css/language.css rel=stylesheet><script src=/js/script.js></script></head><body class="td-section td-documentation"><header><nav class="js-navbar-scroll navbar navbar-expand navbar-dark flex-column flex-md-row td-navbar" data-auto-burger=primary><a class=navbar-brand href=/zh-cn/><span class=navbar-logo></span><span class="text-uppercase font-weight-bold">Apache Dubbo</span></a><div class="td-navbar-nav-scroll ml-md-auto" id=main_navbar><ul class="navbar-nav mt-2 mt-lg-0"><li class="nav-item mr-4 mb-2 mb-lg-0"><a class=nav-link href=/zh-cn/overview/home/><span>文档</span></a></li><li class="nav-item mr-4 mb-2 mb-lg-0"><a class=nav-link href=/zh-cn/blog/><span>博客</span></a></li><li class="nav-item mr-4 mb-2 mb-lg-0"><a class=nav-link href=/zh-cn/download/><span>版本发布</span></a></li><li class="nav-item mr-4 mb-2 mb-lg-0"><a class=nav-link href=/zh-cn/contact/><span>联系社区</span></a></li><li class="nav-item mr-4 mb-2 mb-lg-0"><a class=nav-link href=https://start.dubbo.apache.org/bootstrap.html target=_blank><span>Initializer</span><i class='fas fa-external-link-alt'></i></a></li><li class="nav-item mr-4 mb-2 mb-lg-0"><a class=nav-link href=/zh-cn/github/><span>Github</span><i class='fa-brands fa-github'></i></a></li><li class="nav-item dropdown d-lg-block"><a class="nav-link dropdown-toggle" href=# id=navbarDropdownMenuLink role=button data-toggle=dropdown aria-haspopup=true aria-expanded=false>中文</a><div class="dropdown-menu dropdown-menu-right" aria-labelledby=navbarDropdownMenuLink><a class=dropdown-item href=/en/>English</a></div></li><li class="nav-item dropdown d-lg-block"><div class="nav-item d-none d-lg-block"><div id=docsearch></div></div></li></ul></div></nav><section class="header-hero text-white pb-0 light-text"></section></header><div class="container-fluid td-outer"><div class=td-main><div class="row flex-md-nowrap"><div class="col-12 col-md-3 col-xl-2 td-sidebar d-print-none"><script>$(function(){$("#td-section-nav a").removeClass("active"),$("#td-section-nav #m-zh-cnoverviewmannualjava-sdkfaq7").addClass("active"),$("#td-section-nav #m-zh-cnoverviewmannualjava-sdkfaq7-li span").addClass("td-sidebar-nav-active-item"),$("#td-section-nav #m-zh-cnoverviewmannualjava-sdkfaq7").parents("li").addClass("active-path"),$("#td-section-nav li.active-path").addClass("show"),$("#td-section-nav li.active-path").children("input").prop("checked",!0),$("#td-section-nav #m-zh-cnoverviewmannualjava-sdkfaq7-li").siblings("li").addClass("show"),$("#td-section-nav #m-zh-cnoverviewmannualjava-sdkfaq7-li").children("ul").children("li").addClass("show"),$("#td-sidebar-menu").toggleClass("d-none")})</script><div id=td-sidebar-menu class="td-sidebar__inner d-none"><div id=content-mobile><form class="td-sidebar__search d-flex align-items-center"><div id=docsearch></div><button class="btn btn-link td-sidebar__toggle d-md-none p-0 ml-3 fas fa-bars" type=button data-toggle=collapse data-target=#td-section-nav aria-controls=td-docs-nav aria-expanded=false aria-label="Toggle section navigation"></button></form></div><div id=content-desktop></div><nav class="collapse td-sidebar-nav foldable-nav" id=td-section-nav><ul class="td-sidebar-nav__section pr-md-3 ul-0"><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverview-li><ul class=ul-1><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewhome-li><input type=checkbox id=m-zh-cnoverviewhome-check>
<label for=m-zh-cnoverviewhome-check><a href=/zh-cn/overview/home/ title="Dubbo 文档" class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewhome><span>主页</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewquickstart-li><input type=checkbox id=m-zh-cnoverviewquickstart-check>
<label for=m-zh-cnoverviewquickstart-check><a href=/zh-cn/overview/quickstart/ title="Dubbo 入门" class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewquickstart><span>入门</span></a></label><ul class="ul-2 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewquickstartjava-li><input type=checkbox id=m-zh-cnoverviewquickstartjava-check>
<label for=m-zh-cnoverviewquickstartjava-check><a href=/zh-cn/overview/quickstart/java/ title="Java 微服务开发入门" class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewquickstartjava><span>Java</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewquickstartjavabrief-li><input type=checkbox id=m-zh-cnoverviewquickstartjavabrief-check>
<label for=m-zh-cnoverviewquickstartjavabrief-check><a href=/zh-cn/overview/quickstart/java/brief/ title="1 - 零基础快速部署一个微服务应用" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewquickstartjavabrief><span>快速部署一个微服务应用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewquickstartjavaspring-boot-li><input type=checkbox id=m-zh-cnoverviewquickstartjavaspring-boot-check>
<label for=m-zh-cnoverviewquickstartjavaspring-boot-check><a href=/zh-cn/overview/quickstart/java/spring-boot/ title="2 - Dubbo Spring Boot Starter 开发微服务应用" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewquickstartjavaspring-boot><span>Dubbo Spring Boot Starter 开发微服务应用</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewquickstartgo-li><input type=checkbox id=m-zh-cnoverviewquickstartgo-check>
<label for=m-zh-cnoverviewquickstartgo-check><a href=/zh-cn/overview/quickstart/go/ title="Go 微服务开发入门" class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewquickstartgo><span>Go</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewquickstartgoinstall-li><input type=checkbox id=m-zh-cnoverviewquickstartgoinstall-check>
<label for=m-zh-cnoverviewquickstartgoinstall-check><a href=/zh-cn/overview/quickstart/go/install/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewquickstartgoinstall><span>安装 Dubbo-go 开发环境</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewquickstartgoquickstart_triple-li><input type=checkbox id=m-zh-cnoverviewquickstartgoquickstart_triple-check>
<label for=m-zh-cnoverviewquickstartgoquickstart_triple-check><a href=/zh-cn/overview/quickstart/go/quickstart_triple/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewquickstartgoquickstart_triple><span>完成一次 RPC 调用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewquickstartgoquickstart_triple_with_customize-li><input type=checkbox id=m-zh-cnoverviewquickstartgoquickstart_triple_with_customize-check>
<label for=m-zh-cnoverviewquickstartgoquickstart_triple_with_customize-check><a href=/zh-cn/overview/quickstart/go/quickstart_triple_with_customize/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewquickstartgoquickstart_triple_with_customize><span>完成一次自己定义接口的 RPC 调用</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewquickstartrust-li><input type=checkbox id=m-zh-cnoverviewquickstartrust-check>
<label for=m-zh-cnoverviewquickstartrust-check><a href=/zh-cn/overview/quickstart/rust/ title="Rust 微服务开发入门" class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewquickstartrust><span>Rust</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewquickstartnodejs-li><input type=checkbox id=m-zh-cnoverviewquickstartnodejs-check>
<label for=m-zh-cnoverviewquickstartnodejs-check><a href=https://github.com/apache/dubbo-js title="Node.js 微服务开发入门" target=_blank rel=noopener class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewquickstartnodejs><i class="fas fa-external-link-alt"></i><span>Node.js</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewwhat-li><input type=checkbox id=m-zh-cnoverviewwhat-check>
<label for=m-zh-cnoverviewwhat-check><a href=/zh-cn/overview/what/ title="Dubbo 介绍" class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewwhat><span>介绍</span></a></label><ul class="ul-2 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewwhatoverview-li><input type=checkbox id=m-zh-cnoverviewwhatoverview-check>
<label for=m-zh-cnoverviewwhatoverview-check><a href=/zh-cn/overview/what/overview/ title="了解 Dubbo 核心概念和架构" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewwhatoverview><span>概念与架构</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewwhatxyz-difference-li><input type=checkbox id=m-zh-cnoverviewwhatxyz-difference-check>
<label for=m-zh-cnoverviewwhatxyz-difference-check><a href=/zh-cn/overview/what/xyz-difference/ title="与 gRPC、Spring Cloud、Istio 的关系" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewwhatxyz-difference><span>与 gRPC、Spring Cloud、Istio 关系</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewwhatadvantages-li><input type=checkbox id=m-zh-cnoverviewwhatadvantages-check>
<label for=m-zh-cnoverviewwhatadvantages-check><a href=/zh-cn/overview/what/advantages/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewwhatadvantages><span>核心优势</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewwhatadvantagesusability-li><input type=checkbox id=m-zh-cnoverviewwhatadvantagesusability-check>
<label for=m-zh-cnoverviewwhatadvantagesusability-check><a href=/zh-cn/overview/what/advantages/usability/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewwhatadvantagesusability><span>快速易用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewwhatadvantagesperformance-li><input type=checkbox id=m-zh-cnoverviewwhatadvantagesperformance-check>
<label for=m-zh-cnoverviewwhatadvantagesperformance-check><a href=/zh-cn/overview/what/advantages/performance/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewwhatadvantagesperformance><span>超高性能</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewwhatadvantagesgovernance-li><input type=checkbox id=m-zh-cnoverviewwhatadvantagesgovernance-check>
<label for=m-zh-cnoverviewwhatadvantagesgovernance-check><a href=/zh-cn/overview/what/advantages/governance/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewwhatadvantagesgovernance><span>服务治理</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewwhatadvantagesproduction-ready-li><input type=checkbox id=m-zh-cnoverviewwhatadvantagesproduction-ready-check>
<label for=m-zh-cnoverviewwhatadvantagesproduction-ready-check><a href=/zh-cn/overview/what/advantages/production-ready/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewwhatadvantagesproduction-ready><span>生产环境验证</span></a></label></li></ul></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewcore-features-li><input type=checkbox id=m-zh-cnoverviewcore-features-check>
<label for=m-zh-cnoverviewcore-features-check><a href=/zh-cn/overview/core-features/ title="Dubbo 核心特性" class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewcore-features><span>功能</span></a></label><ul class="ul-2 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewcore-featuresservice-definition-li><input type=checkbox id=m-zh-cnoverviewcore-featuresservice-definition-check>
<label for=m-zh-cnoverviewcore-featuresservice-definition-check><a href=/zh-cn/overview/core-features/service-definition/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewcore-featuresservice-definition><span>微服务开发</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewcore-featuresservice-discovery-li><input type=checkbox id=m-zh-cnoverviewcore-featuresservice-discovery-check>
<label for=m-zh-cnoverviewcore-featuresservice-discovery-check><a href=/zh-cn/overview/core-features/service-discovery/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewcore-featuresservice-discovery><span>服务发现</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewcore-featuresload-balance-li><input type=checkbox id=m-zh-cnoverviewcore-featuresload-balance-check>
<label for=m-zh-cnoverviewcore-featuresload-balance-check><a href=/zh-cn/overview/core-features/load-balance/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewcore-featuresload-balance><span>负载均衡</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewcore-featurestraffic-li><input type=checkbox id=m-zh-cnoverviewcore-featurestraffic-check>
<label for=m-zh-cnoverviewcore-featurestraffic-check><a href=/zh-cn/overview/core-features/traffic/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewcore-featurestraffic><span>流量管控</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewcore-featurestrafficcondition-rule-li><input type=checkbox id=m-zh-cnoverviewcore-featurestrafficcondition-rule-check>
<label for=m-zh-cnoverviewcore-featurestrafficcondition-rule-check><a href=/zh-cn/overview/core-features/traffic/condition-rule/ title=条件路由规则 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewcore-featurestrafficcondition-rule><span>条件路由</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewcore-featurestraffictag-rule-li><input type=checkbox id=m-zh-cnoverviewcore-featurestraffictag-rule-check>
<label for=m-zh-cnoverviewcore-featurestraffictag-rule-check><a href=/zh-cn/overview/core-features/traffic/tag-rule/ title=标签路由规则 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewcore-featurestraffictag-rule><span>标签路由</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewcore-featurestrafficscript-rule-li><input type=checkbox id=m-zh-cnoverviewcore-featurestrafficscript-rule-check>
<label for=m-zh-cnoverviewcore-featurestrafficscript-rule-check><a href=/zh-cn/overview/core-features/traffic/script-rule/ title=脚本路由规则 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewcore-featurestrafficscript-rule><span>脚本路由</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewcore-featurestrafficconfiguration-rule-li><input type=checkbox id=m-zh-cnoverviewcore-featurestrafficconfiguration-rule-check>
<label for=m-zh-cnoverviewcore-featurestrafficconfiguration-rule-check><a href=/zh-cn/overview/core-features/traffic/configuration-rule/ title=动态配置规则 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewcore-featurestrafficconfiguration-rule><span>动态配置</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewcore-featurestrafficcircuit-breaking-li><input type=checkbox id=m-zh-cnoverviewcore-featurestrafficcircuit-breaking-check>
<label for=m-zh-cnoverviewcore-featurestrafficcircuit-breaking-check><a href=/zh-cn/overview/core-features/traffic/circuit-breaking/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewcore-featurestrafficcircuit-breaking><span>限流 & 熔断</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewcore-featuresprotocols-li><input type=checkbox id=m-zh-cnoverviewcore-featuresprotocols-check>
<label for=m-zh-cnoverviewcore-featuresprotocols-check><a href=/zh-cn/overview/core-features/protocols/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewcore-featuresprotocols><span>通信协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewcore-featuresextensibility-li><input type=checkbox id=m-zh-cnoverviewcore-featuresextensibility-check>
<label for=m-zh-cnoverviewcore-featuresextensibility-check><a href=/zh-cn/overview/core-features/extensibility/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewcore-featuresextensibility><span>扩展适配</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewcore-featuresobservability-li><input type=checkbox id=m-zh-cnoverviewcore-featuresobservability-check>
<label for=m-zh-cnoverviewcore-featuresobservability-check><a href=/zh-cn/overview/core-features/observability/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewcore-featuresobservability><span>观测服务</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewcore-featuressecurity-li><input type=checkbox id=m-zh-cnoverviewcore-featuressecurity-check>
<label for=m-zh-cnoverviewcore-featuressecurity-check><a href=/zh-cn/overview/core-features/security/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewcore-featuressecurity><span>认证鉴权</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewcore-featuresservice-mesh-li><input type=checkbox id=m-zh-cnoverviewcore-featuresservice-mesh-check>
<label for=m-zh-cnoverviewcore-featuresservice-mesh-check><a href=/zh-cn/overview/core-features/service-mesh/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewcore-featuresservice-mesh><span>服务网格</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewcore-featuresecosystem-li><input type=checkbox id=m-zh-cnoverviewcore-featuresecosystem-check>
<label for=m-zh-cnoverviewcore-featuresecosystem-check><a href=/zh-cn/overview/core-features/ecosystem/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewcore-featuresecosystem><span>微服务生态</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewcore-featuresmore-li><input type=checkbox id=m-zh-cnoverviewcore-featuresmore-check>
<label for=m-zh-cnoverviewcore-featuresmore-check><a href=/zh-cn/overview/core-features/more/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewcore-featuresmore><span>更多高级功能</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewtasks-li><input type=checkbox id=m-zh-cnoverviewtasks-check>
<label for=m-zh-cnoverviewtasks-check><a href=/zh-cn/overview/tasks/ title="跟随示例任务学习 Dubbo" class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewtasks><span>任务</span></a></label><ul class="ul-2 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewtasksdevelop-li><input type=checkbox id=m-zh-cnoverviewtasksdevelop-check>
<label for=m-zh-cnoverviewtasksdevelop-check><a href=/zh-cn/overview/tasks/develop/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewtasksdevelop><span>开发服务</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksdeveloptemplate-li><input type=checkbox id=m-zh-cnoverviewtasksdeveloptemplate-check>
<label for=m-zh-cnoverviewtasksdeveloptemplate-check><a href=/zh-cn/overview/tasks/develop/template/ title=通过模板生成项目脚手架 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksdeveloptemplate><span>生成项目</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksdevelopservice_reference-li><input type=checkbox id=m-zh-cnoverviewtasksdevelopservice_reference-check>
<label for=m-zh-cnoverviewtasksdevelopservice_reference-check><a href=/zh-cn/overview/tasks/develop/service_reference/ title=开发服务 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksdevelopservice_reference><span>发布和调用 Dubbo 服务</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksdevelopasync-li><input type=checkbox id=m-zh-cnoverviewtasksdevelopasync-check>
<label for=m-zh-cnoverviewtasksdevelopasync-check><a href=/zh-cn/overview/tasks/develop/async/ title=异步调用 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksdevelopasync><span>Provider端和Consumer端异步调用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksdevelopversion_group-li><input type=checkbox id=m-zh-cnoverviewtasksdevelopversion_group-check>
<label for=m-zh-cnoverviewtasksdevelopversion_group-check><a href=/zh-cn/overview/tasks/develop/version_group/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksdevelopversion_group><span>版本与分组</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksdevelopcontext-li><input type=checkbox id=m-zh-cnoverviewtasksdevelopcontext-check>
<label for=m-zh-cnoverviewtasksdevelopcontext-check><a href=/zh-cn/overview/tasks/develop/context/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksdevelopcontext><span>上下文参数传递</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksdevelopgeneric-li><input type=checkbox id=m-zh-cnoverviewtasksdevelopgeneric-check>
<label for=m-zh-cnoverviewtasksdevelopgeneric-check><a href=/zh-cn/overview/tasks/develop/generic/ title=开发服务 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksdevelopgeneric><span>泛化调用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksdevelopidl-li><input type=checkbox id=m-zh-cnoverviewtasksdevelopidl-check>
<label for=m-zh-cnoverviewtasksdevelopidl-check><a href=/zh-cn/overview/tasks/develop/idl/ title="使用 IDL 定义与开发服务" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksdevelopidl><span>IDL开发服务</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewtasksdeploy-li><input type=checkbox id=m-zh-cnoverviewtasksdeploy-check>
<label for=m-zh-cnoverviewtasksdeploy-check><a href=/zh-cn/overview/tasks/deploy/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewtasksdeploy><span>部署服务</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksdeploydeploy-on-vm-li><input type=checkbox id=m-zh-cnoverviewtasksdeploydeploy-on-vm-check>
<label for=m-zh-cnoverviewtasksdeploydeploy-on-vm-check><a href=/zh-cn/overview/tasks/deploy/deploy-on-vm/ title="部署 Dubbo 应用到虚拟机环境" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksdeploydeploy-on-vm><span>部署到虚拟机</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksdeploydeploy-on-docker-li><input type=checkbox id=m-zh-cnoverviewtasksdeploydeploy-on-docker-check>
<label for=m-zh-cnoverviewtasksdeploydeploy-on-docker-check><a href=/zh-cn/overview/tasks/deploy/deploy-on-docker/ title="部署 Dubbo 应用到 Docker 环境" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksdeploydeploy-on-docker><span>部署到 Docker</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksdeploydeploy-on-k8s-docker-li><input type=checkbox id=m-zh-cnoverviewtasksdeploydeploy-on-k8s-docker-check>
<label for=m-zh-cnoverviewtasksdeploydeploy-on-k8s-docker-check><a href=/zh-cn/overview/tasks/deploy/deploy-on-k8s-docker/ title="部署 Dubbo 应用到 Kubernetes + Docker 环境" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksdeploydeploy-on-k8s-docker><span>部署到 Kubernetes + Docker</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksdeploydeploy-on-k8s-containerd-li><input type=checkbox id=m-zh-cnoverviewtasksdeploydeploy-on-k8s-containerd-check>
<label for=m-zh-cnoverviewtasksdeploydeploy-on-k8s-containerd-check><a href=/zh-cn/overview/tasks/deploy/deploy-on-k8s-containerd/ title="部署 Dubbo 应用到 Kubernetes + Containerd 环境" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksdeploydeploy-on-k8s-containerd><span>部署到 Kubernetes + Containerd</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewtaskstraffic-management-li><input type=checkbox id=m-zh-cnoverviewtaskstraffic-management-check>
<label for=m-zh-cnoverviewtaskstraffic-management-check><a href=/zh-cn/overview/tasks/traffic-management/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewtaskstraffic-management><span>流量管控</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtaskstraffic-managementtimeout-li><input type=checkbox id=m-zh-cnoverviewtaskstraffic-managementtimeout-check>
<label for=m-zh-cnoverviewtaskstraffic-managementtimeout-check><a href=/zh-cn/overview/tasks/traffic-management/timeout/ title=动态调整服务超时时间 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtaskstraffic-managementtimeout><span>调整超时时间</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtaskstraffic-managementretry-li><input type=checkbox id=m-zh-cnoverviewtaskstraffic-managementretry-check>
<label for=m-zh-cnoverviewtaskstraffic-managementretry-check><a href=/zh-cn/overview/tasks/traffic-management/retry/ title=通过重试提高服务调用成功率 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtaskstraffic-managementretry><span>服务重试</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtaskstraffic-managementaccesslog-li><input type=checkbox id=m-zh-cnoverviewtaskstraffic-managementaccesslog-check>
<label for=m-zh-cnoverviewtaskstraffic-managementaccesslog-check><a href=/zh-cn/overview/tasks/traffic-management/accesslog/ title=通过动态开启访问日志跟踪服务调用情况 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtaskstraffic-managementaccesslog><span>访问日志</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtaskstraffic-managementregion-li><input type=checkbox id=m-zh-cnoverviewtaskstraffic-managementregion-check>
<label for=m-zh-cnoverviewtaskstraffic-managementregion-check><a href=/zh-cn/overview/tasks/traffic-management/region/ title=同机房/区域优先 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtaskstraffic-managementregion><span>同区域优先</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtaskstraffic-managementisolation-li><input type=checkbox id=m-zh-cnoverviewtaskstraffic-managementisolation-check>
<label for=m-zh-cnoverviewtaskstraffic-managementisolation-check><a href=/zh-cn/overview/tasks/traffic-management/isolation/ title=通过标签实现流量隔离环境（灰度、多套开发环境等） class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtaskstraffic-managementisolation><span>环境隔离</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtaskstraffic-managementarguments-li><input type=checkbox id=m-zh-cnoverviewtaskstraffic-managementarguments-check>
<label for=m-zh-cnoverviewtaskstraffic-managementarguments-check><a href=/zh-cn/overview/tasks/traffic-management/arguments/ title=根据请求参数引导流量分布 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtaskstraffic-managementarguments><span>参数路由</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtaskstraffic-managementweight-li><input type=checkbox id=m-zh-cnoverviewtaskstraffic-managementweight-check>
<label for=m-zh-cnoverviewtaskstraffic-managementweight-check><a href=/zh-cn/overview/tasks/traffic-management/weight/ title=基于权重值的比例流量转发 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtaskstraffic-managementweight><span>权重比例</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtaskstraffic-managementmock-li><input type=checkbox id=m-zh-cnoverviewtaskstraffic-managementmock-check>
<label for=m-zh-cnoverviewtaskstraffic-managementmock-check><a href=/zh-cn/overview/tasks/traffic-management/mock/ title=在大促之前对弱依赖调用进行服务降级 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtaskstraffic-managementmock><span>服务降级</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtaskstraffic-managementhost-li><input type=checkbox id=m-zh-cnoverviewtaskstraffic-managementhost-check>
<label for=m-zh-cnoverviewtaskstraffic-managementhost-check><a href=/zh-cn/overview/tasks/traffic-management/host/ title="将流量点对点引导到一台机器 (如排查问题)" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtaskstraffic-managementhost><span>固定机器导流</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewtasksecosystem-li><input type=checkbox id=m-zh-cnoverviewtasksecosystem-check>
<label for=m-zh-cnoverviewtasksecosystem-check><a href=/zh-cn/overview/tasks/ecosystem/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewtasksecosystem><span>微服务生态</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksecosystemtransaction-li><input type=checkbox id=m-zh-cnoverviewtasksecosystemtransaction-check>
<label for=m-zh-cnoverviewtasksecosystemtransaction-check><a href=/zh-cn/overview/tasks/ecosystem/transaction/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksecosystemtransaction><span>事务管理</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksecosystemgateway-li><input type=checkbox id=m-zh-cnoverviewtasksecosystemgateway-check>
<label for=m-zh-cnoverviewtasksecosystemgateway-check><a href=/zh-cn/overview/tasks/ecosystem/gateway/ title="通过网关将 http 流量接入 Dubbo 后端服务" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksecosystemgateway><span>HTTP网关</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksecosystemconfiguration-li><input type=checkbox id=m-zh-cnoverviewtasksecosystemconfiguration-check>
<label for=m-zh-cnoverviewtasksecosystemconfiguration-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/config-center/ target=_blank rel=noopener class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksecosystemconfiguration><i class="fas fa-external-link-alt"></i><span>配置中心</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksecosystemmetadata-center-li><input type=checkbox id=m-zh-cnoverviewtasksecosystemmetadata-center-check>
<label for=m-zh-cnoverviewtasksecosystemmetadata-center-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/metadata-center/ target=_blank rel=noopener class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksecosystemmetadata-center><i class="fas fa-external-link-alt"></i><span>元数据中心</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksecosystemregistry-li><input type=checkbox id=m-zh-cnoverviewtasksecosystemregistry-check>
<label for=m-zh-cnoverviewtasksecosystemregistry-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/registry/ target=_blank rel=noopener class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksecosystemregistry><i class="fas fa-external-link-alt"></i><span>注册中心</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewtasksobservability-li><input type=checkbox id=m-zh-cnoverviewtasksobservability-check>
<label for=m-zh-cnoverviewtasksobservability-check><a href=/zh-cn/overview/tasks/observability/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewtasksobservability><span>观测服务</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksobservabilityadmin-li><input type=checkbox id=m-zh-cnoverviewtasksobservabilityadmin-check>
<label for=m-zh-cnoverviewtasksobservabilityadmin-check><a href=/zh-cn/overview/tasks/observability/admin/ title="使用 Admin 可视化查看集群状态" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksobservabilityadmin><span>Admin</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewtasksobservabilitytracing-li><input type=checkbox id=m-zh-cnoverviewtasksobservabilitytracing-check>
<label for=m-zh-cnoverviewtasksobservabilitytracing-check><a href=/zh-cn/overview/tasks/observability/tracing/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewtasksobservabilitytracing><span>全链路追踪</span></a></label><ul class="ul-4 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksobservabilitytracingotlp-li><input type=checkbox id=m-zh-cnoverviewtasksobservabilitytracingotlp-check>
<label for=m-zh-cnoverviewtasksobservabilitytracingotlp-check><a href=/zh-cn/overview/tasks/observability/tracing/otlp/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksobservabilitytracingotlp><span>OTlp</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksobservabilitytracingzipkin-li><input type=checkbox id=m-zh-cnoverviewtasksobservabilitytracingzipkin-check>
<label for=m-zh-cnoverviewtasksobservabilitytracingzipkin-check><a href=/zh-cn/overview/tasks/observability/tracing/zipkin/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksobservabilitytracingzipkin><span>Zipkin</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksobservabilitytracingskywalking-li><input type=checkbox id=m-zh-cnoverviewtasksobservabilitytracingskywalking-check>
<label for=m-zh-cnoverviewtasksobservabilitytracingskywalking-check><a href=/zh-cn/overview/tasks/observability/tracing/skywalking/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksobservabilitytracingskywalking><span>Skywalking</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksobservabilitygrafana-li><input type=checkbox id=m-zh-cnoverviewtasksobservabilitygrafana-check>
<label for=m-zh-cnoverviewtasksobservabilitygrafana-check><a href=/zh-cn/overview/tasks/observability/grafana/ title="使用 Grafana 可视化查看集群 Metrics 指标" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksobservabilitygrafana><span>Grafana</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksobservabilityprometheus-li><input type=checkbox id=m-zh-cnoverviewtasksobservabilityprometheus-check>
<label for=m-zh-cnoverviewtasksobservabilityprometheus-check><a href=/zh-cn/overview/tasks/observability/prometheus/ title="从 Prometheus 查询 Metrics 监控指标" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksobservabilityprometheus><span>Prometheus</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewtasksprotocols-li><input type=checkbox id=m-zh-cnoverviewtasksprotocols-check>
<label for=m-zh-cnoverviewtasksprotocols-check><a href=/zh-cn/overview/tasks/protocols/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewtasksprotocols><span>通信协议</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksprotocolsdubbo-li><input type=checkbox id=m-zh-cnoverviewtasksprotocolsdubbo-check>
<label for=m-zh-cnoverviewtasksprotocolsdubbo-check><a href=/zh-cn/overview/tasks/protocols/dubbo/ title="使用 Dubbo 开发 TCP 通信协议服务" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksprotocolsdubbo><span>开发 Dubbo2 服务</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksprotocolsgrpc-li><input type=checkbox id=m-zh-cnoverviewtasksprotocolsgrpc-check>
<label for=m-zh-cnoverviewtasksprotocolsgrpc-check><a href=/zh-cn/overview/tasks/protocols/grpc/ title="使用 Dubbo 开发 gRPC 服务" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksprotocolsgrpc><span>开发 gRPC 服务</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksprotocolstriple-li><input type=checkbox id=m-zh-cnoverviewtasksprotocolstriple-check>
<label for=m-zh-cnoverviewtasksprotocolstriple-check><a href=/zh-cn/overview/tasks/protocols/triple/ title="使用 Dubbo 开发 Triple 协议通信服务" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksprotocolstriple><span>开发 Triple 服务</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksprotocolsweb-li><input type=checkbox id=m-zh-cnoverviewtasksprotocolsweb-check>
<label for=m-zh-cnoverviewtasksprotocolsweb-check><a href=/zh-cn/overview/tasks/protocols/web/ title="使用 Dubbo 开发 Web 应用" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksprotocolsweb><span>开发 Web 应用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksprotocolsspringcloud-li><input type=checkbox id=m-zh-cnoverviewtasksprotocolsspringcloud-check>
<label for=m-zh-cnoverviewtasksprotocolsspringcloud-check><a href=/zh-cn/overview/tasks/protocols/springcloud/ title="使用 Dubbo 作为消费端调用 Spring Cloud 服务" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksprotocolsspringcloud><span>调用 Spring Cloud</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksprotocolsmulti-protocols-li><input type=checkbox id=m-zh-cnoverviewtasksprotocolsmulti-protocols-check>
<label for=m-zh-cnoverviewtasksprotocolsmulti-protocols-check><a href=/zh-cn/overview/tasks/protocols/multi-protocols/ title=发布使用不同协议的多个服务，通过单端口监听 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksprotocolsmulti-protocols><span>单端口多协议</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewtasksrate-limit-li><input type=checkbox id=m-zh-cnoverviewtasksrate-limit-check>
<label for=m-zh-cnoverviewtasksrate-limit-check><a href=/zh-cn/overview/tasks/rate-limit/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewtasksrate-limit><span>限流降级</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksrate-limitsentinel-li><input type=checkbox id=m-zh-cnoverviewtasksrate-limitsentinel-check>
<label for=m-zh-cnoverviewtasksrate-limitsentinel-check><a href=/zh-cn/overview/tasks/rate-limit/sentinel/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksrate-limitsentinel><span>Sentinel 限流</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksrate-limithystrix-li><input type=checkbox id=m-zh-cnoverviewtasksrate-limithystrix-check>
<label for=m-zh-cnoverviewtasksrate-limithystrix-check><a href=/zh-cn/overview/tasks/rate-limit/hystrix/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksrate-limithystrix><span>Hystrix 熔断降级</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksrate-limitresilience4j-li><input type=checkbox id=m-zh-cnoverviewtasksrate-limitresilience4j-check>
<label for=m-zh-cnoverviewtasksrate-limitresilience4j-check><a href=/zh-cn/overview/tasks/rate-limit/resilience4j/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksrate-limitresilience4j><span>Resilience4j</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewtasksextensibility-li><input type=checkbox id=m-zh-cnoverviewtasksextensibility-check>
<label for=m-zh-cnoverviewtasksextensibility-check><a href=/zh-cn/overview/tasks/extensibility/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewtasksextensibility><span>自定义扩展</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksextensibilityfilter-li><input type=checkbox id=m-zh-cnoverviewtasksextensibilityfilter-check>
<label for=m-zh-cnoverviewtasksextensibilityfilter-check><a href=/zh-cn/overview/tasks/extensibility/filter/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksextensibilityfilter><span>Filter</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksextensibilityprotocol-li><input type=checkbox id=m-zh-cnoverviewtasksextensibilityprotocol-check>
<label for=m-zh-cnoverviewtasksextensibilityprotocol-check><a href=/zh-cn/overview/tasks/extensibility/protocol/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksextensibilityprotocol><span>Protocol</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksextensibilityregistry-li><input type=checkbox id=m-zh-cnoverviewtasksextensibilityregistry-check>
<label for=m-zh-cnoverviewtasksextensibilityregistry-check><a href=/zh-cn/overview/tasks/extensibility/registry/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksextensibilityregistry><span>Registry</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtasksextensibilityrouter-li><input type=checkbox id=m-zh-cnoverviewtasksextensibilityrouter-check>
<label for=m-zh-cnoverviewtasksextensibilityrouter-check><a href=/zh-cn/overview/tasks/extensibility/router/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtasksextensibilityrouter><span>Router</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewtaskstroubleshoot-li><input type=checkbox id=m-zh-cnoverviewtaskstroubleshoot-check>
<label for=m-zh-cnoverviewtaskstroubleshoot-check><a href=/zh-cn/overview/tasks/troubleshoot/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewtaskstroubleshoot><span>故障排查</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtaskstroubleshootstart-failed-li><input type=checkbox id=m-zh-cnoverviewtaskstroubleshootstart-failed-check>
<label for=m-zh-cnoverviewtaskstroubleshootstart-failed-check><a href=/zh-cn/overview/tasks/troubleshoot/start-failed/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtaskstroubleshootstart-failed><span>应用启动失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtaskstroubleshootno-provider-li><input type=checkbox id=m-zh-cnoverviewtaskstroubleshootno-provider-check>
<label for=m-zh-cnoverviewtaskstroubleshootno-provider-check><a href=/zh-cn/overview/tasks/troubleshoot/no-provider/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtaskstroubleshootno-provider><span>地址找不到异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewtaskstroubleshootrequest-failed-li><input type=checkbox id=m-zh-cnoverviewtaskstroubleshootrequest-failed-check>
<label for=m-zh-cnoverviewtaskstroubleshootrequest-failed-check><a href=/zh-cn/overview/tasks/troubleshoot/request-failed/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewtaskstroubleshootrequest-failed><span>请求成功率低</span></a></label></li></ul></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child active-path" id=m-zh-cnoverviewmannual-li><input type=checkbox id=m-zh-cnoverviewmannual-check checked>
<label for=m-zh-cnoverviewmannual-check><a href=/zh-cn/overview/mannual/ title="Dubbo SDK 用户手册" class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannual><span>SDK 用户手册</span></a></label><ul class="ul-2 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdk-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdk-check>
<label for=m-zh-cnoverviewmannualjava-sdk-check><a href=/zh-cn/overview/mannual/java-sdk/ title="Java SDK 手册" class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdk><span>Java SDK</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkquick-start-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkquick-start-check>
<label for=m-zh-cnoverviewmannualjava-sdkquick-start-check><a href=/zh-cn/overview/mannual/java-sdk/quick-start/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkquick-start><span>快速入门</span></a></label><ul class="ul-4 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkquick-startbrief-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkquick-startbrief-check>
<label for=m-zh-cnoverviewmannualjava-sdkquick-startbrief-check><a href=/zh-cn/overview/mannual/java-sdk/quick-start/brief/ title="1 - 零基础快速部署一个微服务应用" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkquick-startbrief><span>快速部署一个微服务应用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkquick-startapi-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkquick-startapi-check>
<label for=m-zh-cnoverviewmannualjava-sdkquick-startapi-check><a href=/zh-cn/overview/mannual/java-sdk/quick-start/api/ title="2 - 基于 Dubbo API 开发微服务应用" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkquick-startapi><span>基于 Dubbo API 开发微服务应用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkquick-startspring-boot-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkquick-startspring-boot-check>
<label for=m-zh-cnoverviewmannualjava-sdkquick-startspring-boot-check><a href=/zh-cn/overview/mannual/java-sdk/quick-start/spring-boot/ title="3 - 基于 Spring Boot Starter 开发微服务应用" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkquick-startspring-boot><span>基于 Spring Boot Starter 开发微服务应用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkquick-startspring-xml-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkquick-startspring-xml-check>
<label for=m-zh-cnoverviewmannualjava-sdkquick-startspring-xml-check><a href=/zh-cn/overview/mannual/java-sdk/quick-start/spring-xml/ title="4 - 基于 Spring XML 开发微服务应用" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkquick-startspring-xml><span>基于 Spring XML 开发微服务应用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkquick-startidl-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkquick-startidl-check>
<label for=m-zh-cnoverviewmannualjava-sdkquick-startidl-check><a href=/zh-cn/overview/mannual/java-sdk/quick-start/idl/ title="5 - IDL 定义跨语言服务" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkquick-startidl><span>IDL 定义跨语言服务</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usage-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usage-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usage-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usage><span>高级特性和用法</span></a></label><ul class="ul-4 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservice-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservice-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservice-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/ title=配置框架与服务行为 class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservice><span>框架与服务</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceport-unification-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceport-unification-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceport-unification-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/port-unification/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceport-unification><span>端口协议复用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicetransaction-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicetransaction-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicetransaction-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/transaction/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicetransaction><span>分布式事务</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicegroup-merger-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicegroup-merger-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicegroup-merger-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/group-merger/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicegroup-merger><span>分组聚合</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicemulti-versions-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicemulti-versions-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicemulti-versions-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/multi-versions/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicemulti-versions><span>服务分版本</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicepreflight-check-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicepreflight-check-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicepreflight-check-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/preflight-check/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicepreflight-check><span>启动时检查</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicereactive-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicereactive-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicereactive-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/reactive/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicereactive><span>响应式编程</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceparameter-validation-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceparameter-validation-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceparameter-validation-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/parameter-validation/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceparameter-validation><span>参数校验</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceservice-group-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceservice-group-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceservice-group-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/service-group/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceservice-group><span>服务分组</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicefault-tolerent-strategy-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicefault-tolerent-strategy-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicefault-tolerent-strategy-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/fault-tolerent-strategy/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicefault-tolerent-strategy><span>集群容错</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceservice-downgrade-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceservice-downgrade-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceservice-downgrade-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/service-downgrade/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceservice-downgrade><span>服务降级</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceasync-call-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceasync-call-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceasync-call-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/async-call/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceasync-call><span>异步调用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicegeneric-reference-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicegeneric-reference-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicegeneric-reference-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/generic-reference/ title=泛化调用（客户端泛化） class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicegeneric-reference><span>泛化调用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicestreaming-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicestreaming-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicestreaming-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/streaming/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicestreaming><span>流式通信</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceisolation-executor-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceisolation-executor-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceisolation-executor-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/isolation-executor/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceisolation-executor><span>线程池隔离</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceattachment-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceattachment-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceattachment-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/attachment/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceattachment><span>调用链路传递隐式参数</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicespecify-ip-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicespecify-ip-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicespecify-ip-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/specify-ip/ title="动态指定 IP 调用" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicespecify-ip><span>运行时动态指定 IP 调用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceexplicit-target-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceexplicit-target-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceexplicit-target-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/explicit-target/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceexplicit-target><span>直连提供者</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicecontext-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicecontext-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicecontext-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/context/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicecontext><span>RPC调用上下文</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicejson-compatibility-check-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicejson-compatibility-check-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicejson-compatibility-check-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/json-compatibility-check/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicejson-compatibility-check><span>服务接口JSON兼容性检测</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceconsistent-hash-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceconsistent-hash-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceconsistent-hash-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/consistent-hash/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceconsistent-hash><span>一致性哈希选址</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicesubscribe-only-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicesubscribe-only-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicesubscribe-only-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/subscribe-only/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicesubscribe-only><span>只订阅</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceevents-notify-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceevents-notify-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceevents-notify-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/events-notify/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceevents-notify><span>调用触发事件通知</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicemulti-protocols-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicemulti-protocols-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicemulti-protocols-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/multi-protocols/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicemulti-protocols><span>多协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicecallback-parameter-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicecallback-parameter-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicecallback-parameter-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/callback-parameter/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicecallback-parameter><span>服务端对客户端进行回调</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicelocal-mock-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicelocal-mock-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicelocal-mock-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/local-mock/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicelocal-mock><span>本地伪装</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicemulti-registry-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicemulti-registry-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicemulti-registry-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/multi-registry/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicemulti-registry><span>多注册中心</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicelocal-stub-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicelocal-stub-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicelocal-stub-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/local-stub/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicelocal-stub><span>本地存根</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceecho-service-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceecho-service-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceecho-service-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/echo-service/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceecho-service><span>回声测试</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceaccesslog-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceaccesslog-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceaccesslog-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/accesslog/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceaccesslog><span>调用信息记录</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicegeneric-service-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicegeneric-service-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicegeneric-service-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/generic-service/ title=实现泛化实现（服务端泛化） class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicegeneric-service><span>泛化调用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceasync-execute-on-provider-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceasync-execute-on-provider-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceasync-execute-on-provider-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/async-execute-on-provider/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceasync-execute-on-provider><span>异步执行</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicelocal-call-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicelocal-call-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicelocal-call-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/local-call/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicelocal-call><span>本地调用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicedelay-publish-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicedelay-publish-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicedelay-publish-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/delay-publish/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicedelay-publish><span>延迟暴露</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceregistry-only-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceregistry-only-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceregistry-only-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/registry-only/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageserviceregistry-only><span>只注册</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicedistributed-transaction-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicedistributed-transaction-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicedistributed-transaction-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/service/distributed-transaction/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageservicedistributed-transaction><span>分布式事务支持</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservability-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservability-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservability-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/observability/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservability><span>可观测性</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservabilitymeter-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservabilitymeter-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservabilitymeter-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/observability/meter/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservabilitymeter><span>Metrics</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservabilitytracing-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservabilitytracing-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservabilitytracing-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/observability/tracing/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservabilitytracing><span>链路追踪</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservabilitylogging-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservabilitylogging-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservabilitylogging-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/observability/logging/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageobservabilitylogging><span>日志管理</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetraffic-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetraffic-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetraffic-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/traffic/ title=流量治理规则 class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetraffic><span>流量治理</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformance-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformance-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformance-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformance><span>诊断与调优</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceprofiler-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceprofiler-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceprofiler-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/profiler/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceprofiler><span>请求耗时采样</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancethreading-model-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancethreading-model-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancethreading-model-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/threading-model/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancethreading-model><span>线程模型</span></a></label><ul class="ul-6 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancethreading-modelprovider-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancethreading-modelprovider-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancethreading-modelprovider-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/threading-model/provider/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancethreading-modelprovider><span>服务端线程模型</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancethreading-modelconsumer-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancethreading-modelconsumer-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancethreading-modelconsumer-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/threading-model/consumer/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancethreading-modelconsumer><span>消费端线程模型</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancereference-config-cache-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancereference-config-cache-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancereference-config-cache-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/reference-config-cache/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancereference-config-cache><span>服务引用配置对象缓存</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancerouter-snapshot-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancerouter-snapshot-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancerouter-snapshot-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/router-snapshot/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancerouter-snapshot><span>路由状态采集</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceloadbalance-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceloadbalance-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceloadbalance-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/loadbalance/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceloadbalance><span>负载均衡</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancesimplify-registry-data-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancesimplify-registry-data-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancesimplify-registry-data-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/simplify-registry-data/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancesimplify-registry-data><span>注册信息简化</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceresult-cache-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceresult-cache-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceresult-cache-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/result-cache/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceresult-cache><span>调用结果缓存</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceconcurrency-control-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceconcurrency-control-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceconcurrency-control-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/concurrency-control/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceconcurrency-control><span>并发控制</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceadaptive-concurrency-control-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceadaptive-concurrency-control-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceadaptive-concurrency-control-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/adaptive-concurrency-control/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceadaptive-concurrency-control><span>自适应限流</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceconfig-connections-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceconfig-connections-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceconfig-connections-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/config-connections/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceconfig-connections><span>连接控制</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancelazy-connect-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancelazy-connect-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancelazy-connect-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/lazy-connect/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancelazy-connect><span>延迟连接</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancestickiness-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancestickiness-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancestickiness-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/stickiness/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancestickiness><span>粘滞连接</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancesupport-graalvm-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancesupport-graalvm-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancesupport-graalvm-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/support-graalvm/ title="支持 Graal VM" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancesupport-graalvm><span>支持 GraalVM Native Image</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancedump-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancedump-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancedump-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/dump/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformancedump><span>导出线程堆栈</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceserialization-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceserialization-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceserialization-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/performance/serialization/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageperformanceserialization><span>Kryo 和 FST 序列化</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecurity-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecurity-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecurity-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/security/ title=提升服务安全性 class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecurity><span>提升安全性</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecuritytls-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecuritytls-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecuritytls-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/security/tls/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecuritytls><span>TLS支持</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecurityclass-check-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecurityclass-check-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecurityclass-check-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/security/class-check/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecurityclass-check><span>类检查机制</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecuritytoken-authorization-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecuritytoken-authorization-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecuritytoken-authorization-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/security/token-authorization/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecuritytoken-authorization><span>权限控制</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecurityauth-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecurityauth-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecurityauth-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/security/auth/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagesecurityauth><span>服务鉴权</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothers-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothers-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothers-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/others/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothers><span>其他</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersservice-container-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersservice-container-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersservice-container-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/others/service-container/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersservice-container><span>自定义服务容器</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersgraceful-shutdown-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersgraceful-shutdown-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersgraceful-shutdown-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/others/graceful-shutdown/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersgraceful-shutdown><span>优雅停机</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersset-host-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersset-host-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersset-host-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/others/set-host/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersset-host><span>主机地址自定义暴露</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageotherslogger-management-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageotherslogger-management-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageotherslogger-management-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/others/logger-management/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageotherslogger-management><span>日志框架适配及运行时管理</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersdubbo-kubernetes-probe-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersdubbo-kubernetes-probe-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersdubbo-kubernetes-probe-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/others/dubbo-kubernetes-probe/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersdubbo-kubernetes-probe><span>Kubernetes 生命周期探针</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersdocker-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersdocker-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersdocker-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/others/docker/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageothersdocker><span>Dubbo 部署 Docker 环境</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetriple-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetriple-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetriple-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/triple/ title="Dubbo3 通信协议 -- Triple" class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetriple><span>Triple 协议</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetripleidl-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetripleidl-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetripleidl-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/triple/idl/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetripleidl><span>使用 IDL + Protobuf 跨语言定义服务</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetriplewrap-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetriplewrap-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetriplewrap-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/triple/wrap/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetriplewrap><span>Pojo 序列化兼容模式</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetriplestreaming-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetriplestreaming-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetriplestreaming-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/triple/streaming/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usagetriplestreaming><span>Streaming 通信模式</span></a></label></li></ul></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkreference-manual-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manual-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manual-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manual><span>参考手册</span></a></label><ul class="ul-4 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/config/ title=配置手册 class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfig><span>配置说明</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigoverview-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigoverview-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualconfigoverview-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/config/overview/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigoverview><span>配置概述</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigapi-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigapi-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualconfigapi-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/config/api/ title="API 配置" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigapi><span>API 配置</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigannotation-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigannotation-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualconfigannotation-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/config/annotation/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigannotation><span>Annotation 配置</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigxml-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigxml-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualconfigxml-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/config/xml/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigxml><span>XML 配置</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigprinciple-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigprinciple-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualconfigprinciple-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/config/principle/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigprinciple><span>配置工作原理</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigproperties-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigproperties-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualconfigproperties-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/config/properties/ title=配置项参考手册 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfigproperties><span>配置项手册</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualarchitecture-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualarchitecture-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualarchitecture-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/architecture/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualarchitecture><span>源码架构</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualarchitecturecode-architecture-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualarchitecturecode-architecture-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualarchitecturecode-architecture-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/architecture/code-architecture/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualarchitecturecode-architecture><span>代码架构</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualarchitectureservice-invocation-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualarchitectureservice-invocation-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualarchitectureservice-invocation-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/architecture/service-invocation/ title=服务调用扩展点 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualarchitectureservice-invocation><span>服务调用</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualqos-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualqos-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualqos-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/qos/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualqos><span>QOS 操作手册</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualqosoverview-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualqosoverview-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualqosoverview-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/qos/overview/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualqosoverview><span>QOS 概述</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualqoscommand-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualqoscommand-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualqoscommand-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/qos/command/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualqoscommand><span>基础命令手册</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualqosservice-management-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualqosservice-management-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualqosservice-management-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/qos/service-management/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualqosservice-management><span>服务管理命令</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualqosprobe-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualqosprobe-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualqosprobe-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/qos/probe/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualqosprobe><span>框架状态命令</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualqoslogger-management-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualqoslogger-management-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualqoslogger-management-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/qos/logger-management/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualqoslogger-management><span>日志框架运行时管理</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualqosprofiler-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualqosprofiler-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualqosprofiler-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/qos/profiler/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualqosprofiler><span>性能采样命令</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualqosrouter-snapshot-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualqosrouter-snapshot-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualqosrouter-snapshot-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/qos/router-snapshot/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualqosrouter-snapshot><span>路由状态命令</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualqossecurity-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualqossecurity-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualqossecurity-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/qos/security/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualqossecurity><span>序列化安全审计</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualqosdefault_metrics-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualqosdefault_metrics-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualqosdefault_metrics-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/qos/default_metrics/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualqosdefault_metrics><span>默认监控指标命令</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocol-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocol-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocol-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocol><span>RPC 协议</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoloverview-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoloverview-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoloverview-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/overview/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoloverview><span>协议概述</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoldubbo-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoldubbo-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoldubbo-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/dubbo/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoldubbo><span>Dubbo协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriple-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriple-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriple-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/triple/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriple><span>Triple协议</span></a></label><ul class="ul-6 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltripleoverview-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltripleoverview-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltripleoverview-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/triple/overview/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltripleoverview><span>协议概述</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltripleidl-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltripleidl-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltripleidl-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/triple/idl/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltripleidl><span>IDL 方式使用 Triple</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriplepojo-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriplepojo-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriplepojo-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/triple/pojo/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriplepojo><span>POJO 方式使用 Triple</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltripleguide-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltripleguide-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltripleguide-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/triple/guide/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltripleguide><span>协议使用方式</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriplemigration-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriplemigration-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriplemigration-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/triple/migration/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriplemigration><span>Dubbo2 协议迁移</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriplestreaming-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriplestreaming-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriplestreaming-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/triple/streaming/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocoltriplestreaming><span>Streaming 通信</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolrest-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolrest-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolrest-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/rest/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolrest><span>Rest协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolgrpc-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolgrpc-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolgrpc-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/grpc/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolgrpc><span>gRPC协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolhttp-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolhttp-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolhttp-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/http/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolhttp><span>HTTP协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolv32_rest_protocol_design-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolv32_rest_protocol_design-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolv32_rest_protocol_design-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/v3.2_rest_protocol_design/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolv32_rest_protocol_design><span>Rest 协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolthrift-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolthrift-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolthrift-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/thrift/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolthrift><span>Thrift协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolrmi-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolrmi-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolrmi-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/rmi/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolrmi><span>Rmi协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolredis-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolredis-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolredis-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/redis/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolredis><span>Redis协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolhessian-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolhessian-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolhessian-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/hessian/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolhessian><span>Hessian协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolwebservice-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolwebservice-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolwebservice-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/webservice/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolwebservice><span>Webservice协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolmemcached-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolmemcached-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolmemcached-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/protocol/memcached/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualprotocolmemcached><span>Memcached协议</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-center-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-center-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-center-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/config-center/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-center><span>配置中心</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-centerzookeeper-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-centerzookeeper-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-centerzookeeper-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/config-center/zookeeper/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-centerzookeeper><span>Zookeeper</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-centernacos-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-centernacos-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-centernacos-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/config-center/nacos/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-centernacos><span>Nacos</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-centerapollo-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-centerapollo-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-centerapollo-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/config-center/apollo/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualconfig-centerapollo><span>Apollo</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-center-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-center-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-center-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/metadata-center/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-center><span>元数据中心</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centeroverview-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centeroverview-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centeroverview-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/metadata-center/overview/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centeroverview><span>元数据中心概述</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centernacos-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centernacos-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centernacos-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/metadata-center/nacos/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centernacos><span>Nacos</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centerzookeeper-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centerzookeeper-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centerzookeeper-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/metadata-center/zookeeper/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centerzookeeper><span>Zookeeper</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centerredis-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centerredis-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centerredis-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/metadata-center/redis/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualmetadata-centerredis><span>Redis</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistry-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualregistry-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualregistry-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/registry/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistry><span>注册中心</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistryoverview-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualregistryoverview-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualregistryoverview-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/registry/overview/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistryoverview><span>注册中心概述</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistryzookeeper-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualregistryzookeeper-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualregistryzookeeper-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/registry/zookeeper/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistryzookeeper><span>Zookeeper</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistrynacos-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualregistrynacos-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualregistrynacos-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/registry/nacos/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistrynacos><span>Nacos</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistrymulticast-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualregistrymulticast-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualregistrymulticast-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/registry/multicast/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistrymulticast><span>Multicast</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistryredis-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualregistryredis-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualregistryredis-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/registry/redis/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistryredis><span>Redis</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistrymultiple-registry-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualregistrymultiple-registry-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualregistrymultiple-registry-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/registry/multiple-registry/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistrymultiple-registry><span>多注册中心</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistrysimple-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualregistrysimple-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualregistrysimple-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/registry/simple/ title="Simple 注册中心" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualregistrysimple><span>Simple</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualmesh-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualmesh-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualmesh-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/mesh/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualmesh><span>Mesh手册</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualmeshmesh-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualmeshmesh-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualmeshmesh-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/mesh/mesh/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualmeshmesh><span>Debug参考文档</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualperformance-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualperformance-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualperformance-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/performance/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualperformance><span>性能参考手册</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualperformancerpc-benchmarking-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualperformancerpc-benchmarking-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualperformancerpc-benchmarking-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/performance/rpc-benchmarking/ title="RPC 协议 Triple&amp;Dubbo 基准测试" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualperformancerpc-benchmarking><span>RPC 基准</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualperformancebenchmarking-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualperformancebenchmarking-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualperformancebenchmarking-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/performance/benchmarking/ title=应用级服务发现基准测试 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualperformancebenchmarking><span>应用级服务发现基准</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspi-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspi-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspi-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualspi><span>SPI 扩展使用手册</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspioverview-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspioverview-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspioverview-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/overview/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspioverview><span>Dubbo SPI 概述</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescription-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescription-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescription-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescription><span>Dubbo SPI 扩展实现说明</span></a></label><ul class="ul-6 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionprotocol-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionprotocol-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionprotocol-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/protocol/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionprotocol><span>协议扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionfilter-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionfilter-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionfilter-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/filter/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionfilter><span>调用拦截扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioninvoker-listener-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioninvoker-listener-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioninvoker-listener-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/invoker-listener/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioninvoker-listener><span>引用监听扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionexporter-listener-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionexporter-listener-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionexporter-listener-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/exporter-listener/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionexporter-listener><span>暴露监听扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncluster-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncluster-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncluster-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/cluster/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncluster><span>集群扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionrouter-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionrouter-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionrouter-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/router/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionrouter><span>路由扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionload-balance-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionload-balance-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionload-balance-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/load-balance/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionload-balance><span>负载均衡扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionmerger-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionmerger-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionmerger-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/merger/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionmerger><span>合并结果扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionregistry-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionregistry-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionregistry-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/registry/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionregistry><span>注册中心扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionmonitor-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionmonitor-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionmonitor-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/monitor/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionmonitor><span>监控中心扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionextension-factory-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionextension-factory-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionextension-factory-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/extension-factory/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionextension-factory><span>扩展点加载扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionliveness-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionliveness-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionliveness-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/liveness/ title="Liveness 存活探针" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionliveness><span>存活探针</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionproxy-factory-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionproxy-factory-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionproxy-factory-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/proxy-factory/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionproxy-factory><span>动态代理扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionreadiness-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionreadiness-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionreadiness-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/readiness/ title="Readiness 就绪探针" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionreadiness><span>就绪探针</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionstartup-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionstartup-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionstartup-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/startup/ title="Startup 启动探针" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionstartup><span>启动探针</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncompiler-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncompiler-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncompiler-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/compiler/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncompiler><span>编译器扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionconfig-center-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionconfig-center-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionconfig-center-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/config-center/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionconfig-center><span>配置中心扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionmetadata-report-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionmetadata-report-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionmetadata-report-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/metadata-report/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionmetadata-report><span>元数据中心扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptiondispatcher-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptiondispatcher-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptiondispatcher-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/dispatcher/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptiondispatcher><span>消息派发扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionthreadpool-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionthreadpool-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionthreadpool-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/threadpool/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionthreadpool><span>线程池扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionserialize-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionserialize-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionserialize-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/serialize/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionserialize><span>序列化扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionremoting-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionremoting-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionremoting-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/remoting/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionremoting><span>网络传输扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionexchanger-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionexchanger-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionexchanger-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/exchanger/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionexchanger><span>信息交换扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionpage-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionpage-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionpage-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/page/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionpage><span>对等网络节点组网器扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionnetworker-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionnetworker-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionnetworker-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/networker/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionnetworker><span>组网扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptiontelnet-handler-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptiontelnet-handler-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptiontelnet-handler-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/telnet-handler/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptiontelnet-handler><span>Telnet 命令扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionstatus-checker-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionstatus-checker-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionstatus-checker-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/status-checker/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionstatus-checker><span>状态检查扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncontainer-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncontainer-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncontainer-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/container/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncontainer><span>容器扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncache-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncache-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncache-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/cache/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptioncache><span>缓存扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionvalidation-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionvalidation-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionvalidation-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/validation/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionvalidation><span>验证扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionlogger-adapter-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionlogger-adapter-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionlogger-adapter-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/logger-adapter/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionlogger-adapter><span>日志适配扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionqos-permission-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionqos-permission-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionqos-permission-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/qos-permission/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptionqos-permission><span>QoS匿名访问权限验证扩展</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptiondubbo-spi-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptiondubbo-spi-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptiondubbo-spi-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/spi/description/dubbo-spi/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualspidescriptiondubbo-spi><span>扩展点开发指南</span></a></label></li></ul></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualserialization-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualserialization-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualserialization-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/serialization/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkreference-manualserialization><span>序列化</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationhessian-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationhessian-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualserializationhessian-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/serialization/hessian/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationhessian><span>Hessian</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationfastjson2-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationfastjson2-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualserializationfastjson2-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/serialization/fastjson2/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationfastjson2><span>Fastjson2</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationprotobuf-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationprotobuf-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualserializationprotobuf-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/serialization/protobuf/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationprotobuf><span>Protobuf</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationfastjson-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationfastjson-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualserializationfastjson-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/serialization/fastjson/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationfastjson><span>Fastjson</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationavro-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationavro-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualserializationavro-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/serialization/avro/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationavro><span>Avro</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationfst-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationfst-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualserializationfst-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/serialization/fst/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationfst><span>FST</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationgson-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationgson-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualserializationgson-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/serialization/gson/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationgson><span>Gson</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationkryo-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationkryo-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualserializationkryo-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/serialization/kryo/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationkryo><span>Kryo</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationmsgpack-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationmsgpack-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualserializationmsgpack-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/serialization/msgpack/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualserializationmsgpack><span>MessagePack</span></a></label></li></ul></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility-check>
<label for=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility-check><a href=/zh-cn/overview/mannual/java-sdk/upgrades-and-compatibility/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility><span>升级和兼容性</span></a></label><ul class="ul-4 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility2x-to-3x-compatibility-guide-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility2x-to-3x-compatibility-guide-check>
<label for=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility2x-to-3x-compatibility-guide-check><a href=/zh-cn/overview/mannual/java-sdk/upgrades-and-compatibility/2.x-to-3.x-compatibility-guide/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility2x-to-3x-compatibility-guide><span>2.x 升级至 3.x</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility30-to-31-compatibility-guide-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility30-to-31-compatibility-guide-check>
<label for=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility30-to-31-compatibility-guide-check><a href=/zh-cn/overview/mannual/java-sdk/upgrades-and-compatibility/3.0-to-3.1-compatibility-guide/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility30-to-31-compatibility-guide><span>3.0 升级至 3.1</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility31-to-32-compatibility-guide-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility31-to-32-compatibility-guide-check>
<label for=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility31-to-32-compatibility-guide-check><a href=/zh-cn/overview/mannual/java-sdk/upgrades-and-compatibility/3.1-to-3.2-compatibility-guide/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility31-to-32-compatibility-guide><span>3.1 升级至 3.2</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility32-to-33-compatibility-guide-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility32-to-33-compatibility-guide-check>
<label for=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility32-to-33-compatibility-guide-check><a href=/zh-cn/overview/mannual/java-sdk/upgrades-and-compatibility/3.2-to-3.3-compatibility-guide/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibility32-to-33-compatibility-guide><span>3.2 升级至 3.3</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discovery-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discovery-check>
<label for=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discovery-check><a href=/zh-cn/overview/mannual/java-sdk/upgrades-and-compatibility/service-discovery/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discovery><span>应用级服务发现</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discoveryservice-discovery-samples-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discoveryservice-discovery-samples-check>
<label for=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discoveryservice-discovery-samples-check><a href=/zh-cn/overview/mannual/java-sdk/upgrades-and-compatibility/service-discovery/service-discovery-samples/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discoveryservice-discovery-samples><span>应用级服务发现迁移示例</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discoverymigration-service-discovery-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discoverymigration-service-discovery-check>
<label for=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discoverymigration-service-discovery-check><a href=/zh-cn/overview/mannual/java-sdk/upgrades-and-compatibility/service-discovery/migration-service-discovery/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discoverymigration-service-discovery><span>接口级服务发现迁移至应用级服务发现指南</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discoveryservice-discovery-rule-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discoveryservice-discovery-rule-check>
<label for=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discoveryservice-discovery-rule-check><a href=/zh-cn/overview/mannual/java-sdk/upgrades-and-compatibility/service-discovery/service-discovery-rule/ title=应用级服务发现地址迁移规则说明 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityservice-discoveryservice-discovery-rule><span>应用级服务发现地址迁移规则</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityserialization-upgrade-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityserialization-upgrade-check>
<label for=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityserialization-upgrade-check><a href=/zh-cn/overview/mannual/java-sdk/upgrades-and-compatibility/serialization-upgrade/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityserialization-upgrade><span>序列化协议升级</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityprotobufinterface-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityprotobufinterface-check>
<label for=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityprotobufinterface-check><a href=/zh-cn/overview/mannual/java-sdk/upgrades-and-compatibility/protobufinterface/ title="Protobuf 与 Interface" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityprotobufinterface><span>Protobuf vs Interface</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilitymigration-triple-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilitymigration-triple-check>
<label for=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilitymigration-triple-check><a href=/zh-cn/overview/mannual/java-sdk/upgrades-and-compatibility/migration-triple/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilitymigration-triple><span>Dubbo 协议迁移至 Triple 协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityversion-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityversion-check>
<label for=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityversion-check><a href=/zh-cn/overview/mannual/java-sdk/upgrades-and-compatibility/version/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkupgrades-and-compatibilityversion><span>查看历史版本文档</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkfaq-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq-check><a href=/zh-cn/overview/mannual/java-sdk/faq/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkfaq><span>错误码 FAQ</span></a></label><ul class="ul-4 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkfaq0-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq0-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq0-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkfaq0><span>0 - Common 层</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq01-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq01-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq01-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/1/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq01><span>0-1 - 线程池资源枯竭</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq02-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq02-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq02-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/2/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq02><span>0-2 - 非法属性值</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq03-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq03-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq03-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/3/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq03><span>0-3 - 无法访问缓存路径</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq04-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq04-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq04-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/4/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq04><span>0-4 - 缓存条目超限</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq05-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq05-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq05-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/5/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq05><span>0-5 - 缓存文件大小超限</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq06-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq06-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq06-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/6/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq06><span>0-6 - 线程中断异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq07-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq07-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq07-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/7/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq07><span>0-7 - 未找到反射类</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq08-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq08-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq08-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/8/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq08><span>0-8 - 反射失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq09-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq09-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq09-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/9/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq09><span>0-9 - 通知事件失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq010-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq010-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq010-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/10/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq010><span>0-10 - 当前调用不在支持</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq011-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq011-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq011-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/11/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq011><span>0-11 - 服务停止失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq012-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq012-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq012-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/12/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq012><span>0-12 - 未知异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq013-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq013-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq013-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/13/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq013><span>0-13 - 指标收集器发生异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq014-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq014-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq014-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/14/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq014><span>0-14 - 监控异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq015-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq015-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq015-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/15/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq015><span>0-15 - 加载扩展类时发生异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq016-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq016-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq016-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/16/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq016><span>0-16 - 没有可用的执行器</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq017-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq017-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq017-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/17/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq017><span>0-17 - 执行器在关闭时发生未知异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq018-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq018-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq018-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/18/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq018><span>0-18 - 线程池执行器被错误使用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq019-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq019-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq019-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/19/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq019><span>0-19 - 处理任务时发生异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq020-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq020-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq020-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/20/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq020><span>0-20 - 存储堆栈信息时发生异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq021-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq021-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq021-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/21/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq021><span>0-21 - 构建的实例过多</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq022-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq022-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq022-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/22/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq022><span>0-22 - 输入输出流异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq023-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq023-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq023-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/23/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq023><span>0-23 - 序列化数据转换异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq024-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq024-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq024-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/24/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq024><span>0-24 - 覆盖字段值异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq025-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq025-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq025-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/25/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq025><span>0-25 - 加载映射错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq026-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq026-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq026-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/26/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq026><span>0-26 - 元数据发布服务时的警告信息</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq027-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq027-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq027-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/27/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq027><span>0-27 - 线程池隔离配置异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq028-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq028-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq028-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/28/ title="0-28 - 操作了可能会引起危险的行为" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq028><span>0-28 - 危险的行为</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq029-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq029-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq029-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/29/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq029><span>0-29 - 未找到Tracer依赖</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq099-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq099-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq099-check><a href=/zh-cn/overview/mannual/java-sdk/faq/0/99/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq099><span>0-99 - 调用了过时 (Deprecated) 的方法</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkfaq1-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq1-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq1-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkfaq1><span>1 - 注册中心层</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq11-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq11-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq11-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/1/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq11><span>1-1 - 地址非法</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq13-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq13-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq13-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/3/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq13><span>1-3 - URL 销毁失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq14-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq14-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq14-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/4/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq14><span>1-4 - 空地址</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq15-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq15-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq15-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/5/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq15><span>1-5 - 接收到没有任何参数的 URL</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq16-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq16-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq16-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/6/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq16><span>1-6 - 清空URL缓存出错</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq17-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq17-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq17-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/7/ title="1-7 - 通知注册事件失败" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq17><span>1-7 - 读写注册中心服务缓存失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq18-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq18-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq18-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/8/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq18><span>1-8 - 销毁时注销（取消订阅）地址失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq19-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq19-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq19-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/9/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq19><span>1-9 - 读写注册中心服务缓存失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq110-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq110-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq110-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/10/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq110><span>1-10 - 读写注册中心服务缓存失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq111-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq111-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq111-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/11/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq111><span>1-11 - 注册服务实例创建失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq112-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq112-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq112-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/12/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq112><span>1-12 - “注册服务” 的实例均已销毁</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq113-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq113-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq113-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/13/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq113><span>1-13 - 执行重试任务失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq114-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq114-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq114-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/14/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq114><span>1-14 - 动态配置识别失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq115-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq115-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq115-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/15/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq115><span>1-15 - 销毁服务失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq116-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq116-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq116-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/16/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq116><span>1-16 - 存在不支持的类别</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq117-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq117-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq117-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/17/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq117><span>1-17 - metadata Server 失效</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq118-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq118-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq118-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/18/ title="1-18 - 未提供 metadata service 端口" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq118><span>1-18 - 未提供 metadata service 端口</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq119-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq119-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq119-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/19/ title="1-19 - K8S监听异常" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq119><span>1-19 - K8S监听异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq120-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq120-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq120-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/20/ title="1-20 - K8S Pod不存在" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq120><span>1-20 - K8S Pod不存在</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq121-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq121-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq121-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/21/ title="1-21 - K8S 无可用服务" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq121><span>1-21 - K8S 无可用服务</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq122-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq122-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq122-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/22/ title="1-22 - K8S 配置地址错误" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq122><span>1-22 - K8S 配置地址错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq126-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq126-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq126-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/26/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq126><span>1-26 - xDS 证书生成失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq127-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq127-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq127-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/27/ title="1-27 - K8S监听异常" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq127><span>1-27 - K8S监听异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq128-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq128-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq128-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/28/ title="1-28 - xDS 存根错误" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq128><span>1-28 - xDS 存根错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq129-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq129-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq129-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/29/ title="1-29 - xDS 读取文件失败" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq129><span>1-29 - xDS 读取文件失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq130-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq130-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq130-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/30/ title="1-30 - xDS 请求失败" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq130><span>1-30 - xDS 请求失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq131-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq131-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq131-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/31/ title="1-31 - xDS 响应失败" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq131><span>1-31 - xDS 响应失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq132-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq132-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq132-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/32/ title="1-32 - xDS Channel 初始化失败" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq132><span>1-32 - xDS Channel 初始化失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq133-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq133-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq133-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/33/ title="1-33 - xDS 服务发现初始化失败" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq133><span>1-33 - xDS 服务发现初始化失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq134-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq134-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq134-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/34/ title="1-34 - xDS 解析发生错误" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq134><span>1-34 - xDS 解析发生错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq135-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq135-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq135-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/35/ title="1-35 - ZK 异常" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq135><span>1-35 - ZK 异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq136-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq136-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq136-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/36/ title="1-36 - 未知异常" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq136><span>1-36 - 未知异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq137-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq137-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq137-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/37/ title="1-37 - Nacos 异常" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq137><span>1-37 - Nacos 异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq138-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq138-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq138-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/38/ title="1-38 - Socket 连接异常" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq138><span>1-38 - Socket 连接异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq139-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq139-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq139-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/39/ title="1-39 - 获取元数据失败" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq139><span>1-39 - 获取元数据失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq140-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq140-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq140-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/40/ title="1-40 - 路由等待时间过长" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq140><span>1-40 - 路由等待时间过长</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq141-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq141-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq141-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/41/ title="1-41 - Istio 异常" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq141><span>1-41 - Istio 异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq142-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq142-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq142-check><a href=/zh-cn/overview/mannual/java-sdk/faq/1/42/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq142><span>1-42 - Nacos 存在低版本服务</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkfaq2-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq2-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq2-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkfaq2><span>2 - 路由层</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq21-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq21-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq21-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/1/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq21><span>2-1 - 路由选址执行失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq22-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq22-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq22-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/2/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq22><span>2-2 - 没有可用的 Provider（地址找不到）</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq23-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq23-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq23-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/3/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq23><span>2-3 - 路由关闭失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq24-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq24-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq24-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/4/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq24><span>2-4 - Merger接口加载失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq25-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq25-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq25-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/5/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq25><span>2-5 - 筛选提供方失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq26-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq26-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq26-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/6/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq26><span>2-6 - 条件路由筛选提供方列表为空</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq27-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq27-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq27-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/7/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq27><span>2-7 - 条件路由执行异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq28-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq28-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq28-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/8/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq28><span>2-8 - 提供方返回异常响应</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq29-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq29-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq29-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/9/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq29><span>2-9 - 增加超时检查任务失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq210-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq210-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq210-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/10/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq210><span>2-10 - 调用服务提供方失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq211-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq211-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq211-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/11/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq211><span>2-11 - 标签路由规则不合法</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq212-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq212-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq212-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/12/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq212><span>2-12 - 标签路由获取提供方应用名为空</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq213-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq213-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq213-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/13/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq213><span>2-13 - 接收加载mesh的路由规则失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq214-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq214-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq214-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/14/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq214><span>2-14 - 脚本路由执行失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq215-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq215-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq215-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/15/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq215><span>2-15 - 路由规则解析失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq216-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq216-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq216-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/16/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq216><span>2-16 - 请求重试多次失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq217-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq217-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq217-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/17/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq217><span>2-17 - mock请求失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq218-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq218-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq218-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/18/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq218><span>2-18 - mesh路由规则未被监听</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq219-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq219-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq219-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/19/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq219><span>2-19 - 异步请求失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq220-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq220-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq220-check><a href=/zh-cn/overview/mannual/java-sdk/faq/2/20/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq220><span>2-20 - 获取分组结果合并时失败</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkfaq3-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq3-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq3-check><a href=/zh-cn/overview/mannual/java-sdk/faq/3/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkfaq3><span>3 - 动态代理层</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq31-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq31-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq31-check><a href=/zh-cn/overview/mannual/java-sdk/faq/3/1/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq31><span>3-1 - 将地址转换成 Invoker 失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq32-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq32-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq32-check><a href=/zh-cn/overview/mannual/java-sdk/faq/3/2/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq32><span>3-2 - 发布或推送服务失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq33-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq33-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq33-check><a href=/zh-cn/overview/mannual/java-sdk/faq/3/3/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq33><span>3-3 - 通过Javassist生成字节码失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq34-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq34-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq34-check><a href=/zh-cn/overview/mannual/java-sdk/faq/3/4/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq34><span>3-4 - 客户端发送请求超时</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq35-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq35-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq35-check><a href=/zh-cn/overview/mannual/java-sdk/faq/3/5/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq35><span>3-5 - 异步响应出现异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq36-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq36-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq36-check><a href=/zh-cn/overview/mannual/java-sdk/faq/3/6/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq36><span>3-6 - 代理执行服务发生异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq37-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq37-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq37-check><a href=/zh-cn/overview/mannual/java-sdk/faq/3/7/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq37><span>3-7 - 服务端响应结果超时</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq38-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq38-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq38-check><a href=/zh-cn/overview/mannual/java-sdk/faq/3/8/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq38><span>3-8 - 代理失败</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkfaq4-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq4-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq4-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkfaq4><span>4 - 协议层</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq41-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq41-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq41-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/1/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq41><span>4-1 - 不支持的协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq42-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq42-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq42-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/2/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq42><span>4-2 - 序列化优化器初始发生错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq43-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq43-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq43-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/3/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq43><span>4-3 - 接口引用调用失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq44-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq44-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq44-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/4/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq44><span>4-4 - 非安全序列化方式</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq45-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq45-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq45-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/5/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq45><span>4-5 - 流关闭异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq46-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq46-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq46-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/6/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq46><span>4-6 - 反序列化失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq47-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq47-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq47-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/7/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq47><span>4-7 - 关闭客户端时发生错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq48-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq48-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq48-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/8/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq48><span>4-8 - 关闭服务端时发生错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq49-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq49-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq49-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/9/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq49><span>4-9 - 解析失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq410-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq410-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq410-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/10/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq410><span>4-10 - Triple 序列化结果失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq411-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq411-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq411-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/11/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq411><span>4-11 - 发起请求失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq412-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq412-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq412-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/12/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq412><span>4-12 - 创建Triple流失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq413-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq413-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq413-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/13/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq413><span>4-13 - 服务端超时</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq414-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq414-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq414-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/14/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq414><span>4-14 - 响应结果失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq415-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq415-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq415-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/15/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq415><span>4-15 - 客户端流监听器</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq416-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq416-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq416-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/16/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq416><span>4-16 - 服务已关闭</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq417-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq417-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq417-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/17/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq417><span>4-17 - 关闭所有调用程序时发生错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq418-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq418-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq418-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/18/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq418><span>4-18 - 无法从调用中获取服务模型</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq419-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq419-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq419-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/19/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq419><span>4-19 - 参数值有出错的可能</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq420-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq420-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq420-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/20/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq420><span>4-20 - 数据解码失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq421-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq421-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq421-check><a href=/zh-cn/overview/mannual/java-sdk/faq/4/21/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq421><span>4-21 - 检测到不安全的序列化数据</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkfaq5-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq5-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq5-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkfaq5><span>5 - 配置（中心）层</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq51-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq51-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq51-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/1/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq51><span>5-1 - 配置中心连接失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq52-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq52-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq52-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/2/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq52><span>5-2 - 注册/注销关闭钩子方法失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq53-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq53-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq53-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/3/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq53><span>5-3 - 销毁方法调用时发生意外错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq54-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq54-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq54-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/4/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq54><span>5-4 - 服务接口中找不到方法</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq55-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq55-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq55-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/5/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq55><span>5-5 - 无法获得env变量</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq56-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq56-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq56-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/6/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq56><span>5-6 - 接口类型的属性冲突</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq57-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq57-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq57-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/7/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq57><span>5-7 - 取消导出时发生意外错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq58-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq58-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq58-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/8/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq58><span>5-8 - 协议将使用随机可用端口</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq59-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq59-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq59-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/9/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq59><span>5-9 - 服务配置导出失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq510-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq510-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq510-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/10/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq510><span>5-10 - 服务的注册接口应用程序映射失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq511-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq511-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq511-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/11/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq511><span>5-11 - 注册实例错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq512-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq512-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq512-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/12/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq512><span>5-12 - 刷新实例和元数据错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq513-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq513-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq513-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/13/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq513><span>5-13 - 无法销毁模型</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq514-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq514-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq514-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/14/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq514><span>5-14 - 模型启动错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq515-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq515-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq515-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/15/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq515><span>5-15 - 模型引用错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq516-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq516-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq516-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/16/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq516><span>5-16 - 无法找到任何有效的协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq517-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq517-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq517-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/17/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq517><span>5-17 - 参数值格式错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq518-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq518-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq518-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/18/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq518><span>5-18 - 通知注册事件失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq520-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq520-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq520-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/20/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq520><span>5-20 - 停止 dubbo 模块时发生错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq521-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq521-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq521-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/21/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq521><span>5-21 - 服务销毁时发生异常错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq522-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq522-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq522-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/22/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq522><span>5-22 - 注册中心在初始化时发生错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq523-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq523-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq523-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/23/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq523><span>5-23 - 等待导出/引用服务发生异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq524-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq524-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq524-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/24/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq524><span>5-24 - 异步等待引用服务发生异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq525-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq525-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq525-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/25/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq525><span>5-25 - 自定义实现发生未定义异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq526-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq526-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq526-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/26/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq526><span>5-26 - 元数据已导出</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq527-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq527-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq527-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/27/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq527><span>5-27 - 内部类API被错误使用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq528-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq528-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq528-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/28/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq528><span>5-28 - 未发现可用注解</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq529-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq529-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq529-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/29/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq529><span>5-29 - 扫描包未配置</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq530-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq530-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq530-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/30/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq530><span>5-30 - 声明bean定义重复</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq531-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq531-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq531-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/31/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq531><span>5-31 - 状态检查错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq532-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq532-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq532-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/32/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq532><span>5-32 - Apollo 断开连接时发生错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq533-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq533-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq533-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/33/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq533><span>5-33 - Apollo 配置更新事件发生异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq534-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq534-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq534-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/34/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq534><span>5-34 - NACOS 发生错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq535-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq535-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq535-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/35/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq535><span>5-35 - 容器初始化失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq536-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq536-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq536-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/36/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq536><span>5-36 - 过滤器校验时发生错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq537-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq537-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq537-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/37/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq537><span>5-37 - 动态配置监听处理发生错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq538-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq538-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq538-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/38/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq538><span>5-38 - 配置参数未定义</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq539-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq539-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq539-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/39/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq539><span>5-39 - Dubbo配置bean初始化器发生错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq540-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq540-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq540-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/40/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq540><span>5-40 - Dubbo配置bean未找到</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq541-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq541-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq541-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/41/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq541><span>5-41 - SSL证书读取失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq542-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq542-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq542-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/42/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq542><span>5-42 - Dubbo 证书签发失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq543-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq543-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq543-check><a href=/zh-cn/overview/mannual/java-sdk/faq/5/43/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq543><span>5-43 - Dubbo 证书签发连接不安全</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkfaq6-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq6-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq6-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkfaq6><span>6 - 网络传输层</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq61-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq61-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq61-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/1/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq61><span>6-1 - 服务端连接失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq62-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq62-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq62-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/2/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq62><span>6-2 - 客户端超时</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq63-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq63-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq63-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/3/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq63><span>6-3 - 网络连接关闭失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq64-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq64-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq64-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/4/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq64><span>6-4 - 网络通讯层未知异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq65-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq65-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq65-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/5/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq65><span>6-5 - 网络连接断开失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq66-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq66-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq66-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/6/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq66><span>6-6 - 不支持的消息</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq67-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq67-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq67-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/7/ title="6-7 - 线程连接数超限警告" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq67><span>6-7 - 服务端连接失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq68-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq68-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq68-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/8/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq68><span>6-8 - 返回数据解码失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq69-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq69-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq69-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/9/ title="6-9 - 序列号ID存在重复" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq69><span>6-9 - 服务端连接失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq610-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq610-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq610-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/10/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq610><span>6-10 - 超过有效载荷限制异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq611-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq611-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq611-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/11/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq611><span>6-11 - 字符集不被支持</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq612-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq612-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq612-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/12/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq612><span>6-12 - ZK客户端销毁时发生错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq613-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq613-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq613-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/13/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq613><span>6-13 - 流关闭异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq614-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq614-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq614-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/14/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq614><span>6-14 - 服务端响应失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq615-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq615-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq615-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/15/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq615><span>6-15 - 跳过未读完的流数据</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq616-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq616-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq616-check><a href=/zh-cn/overview/mannual/java-sdk/faq/6/16/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq616><span>6-16 - 重连时发生异常</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkfaq7-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq7-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq7-check><a href=/zh-cn/overview/mannual/java-sdk/faq/7/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkfaq7><span>7 - QoS 插件模块</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq71-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq71-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq71-check><a href=/zh-cn/overview/mannual/java-sdk/faq/7/1/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq71><span>7-1 - QOS 已关闭</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq72-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq72-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq72-check><a href=/zh-cn/overview/mannual/java-sdk/faq/7/2/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq72><span>7-2 - QOS 已开启</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq73-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq73-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq73-check><a href=/zh-cn/overview/mannual/java-sdk/faq/7/3/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq73><span>7-3 - 设置超时时间的警告百分比值</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq74-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq74-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq74-check><a href=/zh-cn/overview/mannual/java-sdk/faq/7/4/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq74><span>7-4 - QOS 服务启动失败</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq75-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq75-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq75-check><a href=/zh-cn/overview/mannual/java-sdk/faq/7/5/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq75><span>7-5 - QOS 命令未找到</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq76-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq76-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq76-check><a href=/zh-cn/overview/mannual/java-sdk/faq/7/6/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq76><span>7-6 - QOS 发生未知异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq77-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq77-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq77-check><a href=/zh-cn/overview/mannual/java-sdk/faq/7/7/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq77><span>7-7 - QOS 无权限访问</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkfaq81-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq81-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq81-check><a href=/zh-cn/overview/mannual/java-sdk/faq/81/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkfaq81><span>81 - 单元测试辅助模块（注册中心）</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq811-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq811-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq811-check><a href=/zh-cn/overview/mannual/java-sdk/faq/81/1/ title="81-1 - ZK  启动异常" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq811><span>81-1 - ZK 启动异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq812-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq812-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq812-check><a href=/zh-cn/overview/mannual/java-sdk/faq/81/2/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq812><span>81-2 - ZK 销毁异常</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq813-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq813-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq813-check><a href=/zh-cn/overview/mannual/java-sdk/faq/81/3/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq813><span>81-3 - 通过url无法下载文件</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq814-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq814-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq814-check><a href=/zh-cn/overview/mannual/java-sdk/faq/81/4/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq814><span>81-4 - 嵌入式ZooKeeper运行异常</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualjava-sdkfaq99-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq99-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq99-check><a href=/zh-cn/overview/mannual/java-sdk/faq/99/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualjava-sdkfaq99><span>99 - 其它未知错误</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq990-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq990-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq990-check><a href=/zh-cn/overview/mannual/java-sdk/faq/99/0/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq990><span>99-0 - 内部未知错误</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaq991-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaq991-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaq991-check><a href=/zh-cn/overview/mannual/java-sdk/faq/99/1/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaq991><span>99-1 - 程序被打断</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkfaqintro-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkfaqintro-check>
<label for=m-zh-cnoverviewmannualjava-sdkfaqintro-check><a href=/zh-cn/overview/mannual/java-sdk/faq/intro/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkfaqintro><span>错误码机制的介绍</span></a></label></li></ul></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdk-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdk-check>
<label for=m-zh-cnoverviewmannualgolang-sdk-check><a href=/zh-cn/overview/mannual/golang-sdk/ title="Golang SDK 手册" class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdk><span>Golang SDK</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdkpreface-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkpreface-check>
<label for=m-zh-cnoverviewmannualgolang-sdkpreface-check><a href=/zh-cn/overview/mannual/golang-sdk/preface/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdkpreface><span>框架介绍</span></a></label><ul class="ul-4 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdkprefaceconcept-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkprefaceconcept-check>
<label for=m-zh-cnoverviewmannualgolang-sdkprefaceconcept-check><a href=/zh-cn/overview/mannual/golang-sdk/preface/concept/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdkprefaceconcept><span>概念体系</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkprefaceconceptmulti_language-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkprefaceconceptmulti_language-check>
<label for=m-zh-cnoverviewmannualgolang-sdkprefaceconceptmulti_language-check><a href=/zh-cn/overview/mannual/golang-sdk/preface/concept/multi_language/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkprefaceconceptmulti_language><span>多语言 RPC</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkprefaceconceptgeneric-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkprefaceconceptgeneric-check>
<label for=m-zh-cnoverviewmannualgolang-sdkprefaceconceptgeneric-check><a href=/zh-cn/overview/mannual/golang-sdk/preface/concept/generic/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkprefaceconceptgeneric><span>泛化调用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkprefaceconceptregistry-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkprefaceconceptregistry-check>
<label for=m-zh-cnoverviewmannualgolang-sdkprefaceconceptregistry-check><a href=/zh-cn/overview/mannual/golang-sdk/preface/concept/registry/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkprefaceconceptregistry><span>服务注册发现</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkprefaceconceptprotocol-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkprefaceconceptprotocol-check>
<label for=m-zh-cnoverviewmannualgolang-sdkprefaceconceptprotocol-check><a href=/zh-cn/overview/mannual/golang-sdk/preface/concept/protocol/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkprefaceconceptprotocol><span>网络协议</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkpreface30_feature-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkpreface30_feature-check>
<label for=m-zh-cnoverviewmannualgolang-sdkpreface30_feature-check><a href=/zh-cn/overview/mannual/golang-sdk/preface/3.0_feature/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkpreface30_feature><span>新特性</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdkprefacedesign-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkprefacedesign-check>
<label for=m-zh-cnoverviewmannualgolang-sdkprefacedesign-check><a href=/zh-cn/overview/mannual/golang-sdk/preface/design/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdkprefacedesign><span>代码架构</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkprefacedesignaop_and_extension-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkprefacedesignaop_and_extension-check>
<label for=m-zh-cnoverviewmannualgolang-sdkprefacedesignaop_and_extension-check><a href=/zh-cn/overview/mannual/golang-sdk/preface/design/aop_and_extension/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkprefacedesignaop_and_extension><span>AOP 与可扩展机制</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkprefacedesignapp_and_interface-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkprefacedesignapp_and_interface-check>
<label for=m-zh-cnoverviewmannualgolang-sdkprefacedesignapp_and_interface-check><a href=/zh-cn/overview/mannual/golang-sdk/preface/design/app_and_interface/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkprefacedesignapp_and_interface><span>Dubbo的应用和接口</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkprefacedesignarchitecture-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkprefacedesignarchitecture-check>
<label for=m-zh-cnoverviewmannualgolang-sdkprefacedesignarchitecture-check><a href=/zh-cn/overview/mannual/golang-sdk/preface/design/architecture/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkprefacedesignarchitecture><span>架构</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkprefacesamples-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkprefacesamples-check>
<label for=m-zh-cnoverviewmannualgolang-sdkprefacesamples-check><a href=/zh-cn/overview/mannual/golang-sdk/preface/samples/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkprefacesamples><span>快速入门</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdkquickstart-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkquickstart-check>
<label for=m-zh-cnoverviewmannualgolang-sdkquickstart-check><a href=/zh-cn/overview/mannual/golang-sdk/quickstart/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdkquickstart><span>快速开始</span></a></label><ul class="ul-4 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkquickstartinstall-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkquickstartinstall-check>
<label for=m-zh-cnoverviewmannualgolang-sdkquickstartinstall-check><a href=/zh-cn/overview/mannual/golang-sdk/quickstart/install/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkquickstartinstall><span>安装 Dubbo-go 开发环境</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkquickstartquickstart_triple-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkquickstartquickstart_triple-check>
<label for=m-zh-cnoverviewmannualgolang-sdkquickstartquickstart_triple-check><a href=/zh-cn/overview/mannual/golang-sdk/quickstart/quickstart_triple/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkquickstartquickstart_triple><span>完成一次 RPC 调用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkquickstartquickstart_triple_with_customize-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkquickstartquickstart_triple_with_customize-check>
<label for=m-zh-cnoverviewmannualgolang-sdkquickstartquickstart_triple_with_customize-check><a href=/zh-cn/overview/mannual/golang-sdk/quickstart/quickstart_triple_with_customize/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkquickstartquickstart_triple_with_customize><span>完成一次自己定义接口的版本 RPC 调用</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorial-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorial-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorial-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorial><span>使用教程</span></a></label><ul class="ul-4 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelop-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelop-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelop-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelop><span>开发服务</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdeveloptemplate-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdeveloptemplate-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdeveloptemplate-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/template/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdeveloptemplate><span>应用模板</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistry-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistry-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistry-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/registry/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistry><span>注册中心</span></a></label><ul class="ul-6 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrydesc-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrydesc-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrydesc-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/registry/desc/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrydesc><span>了解注册中心</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistryservice-discovery-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistryservice-discovery-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistryservice-discovery-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/registry/service-discovery/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistryservice-discovery><span>应用级服务发现</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistryregistry-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistryregistry-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistryregistry-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/registry/registry/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistryregistry><span>注册中心配置</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrynacos-2-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrynacos-2-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrynacos-2-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/registry/nacos-2/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrynacos-2><span>使用 Nacos 作为注册中心</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrynacos-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrynacos-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrynacos-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/registry/nacos/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrynacos><span>使用 Nacos 作为注册中心</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistryzookeeper-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistryzookeeper-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistryzookeeper-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/registry/zookeeper/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistryzookeeper><span>使用 Zookeeper 作为注册中心</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrypolaris-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrypolaris-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrypolaris-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/registry/polaris/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrypolaris><span>使用 Polaris 作为注册中心</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrymulti_registry-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrymulti_registry-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrymulti_registry-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/registry/multi_registry/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopregistrymulti_registry><span>多注册中心</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocol-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocol-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocol-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/protocol/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocol><span>协议配置</span></a></label><ul class="ul-6 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocolexception_response-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocolexception_response-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocolexception_response-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/protocol/exception_response/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocolexception_response><span>Triple 异常回传</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocolerror-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocolerror-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocolerror-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/protocol/error/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocolerror><span>异常信息回传</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocolchoose_protocol-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocolchoose_protocol-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocolchoose_protocol-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/protocol/choose_protocol/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopprotocolchoose_protocol><span>选择使用的网络协议</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopinterflow-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopinterflow-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopinterflow-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/interflow/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopinterflow><span>异构体系互通</span></a></label><ul class="ul-6 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopinterflowcall_java-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopinterflowcall_java-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopinterflowcall_java-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/interflow/call_java/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopinterflowcall_java><span>与 Java 应用跨语言互通</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopinterflowcall_grpc-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopinterflowcall_grpc-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopinterflowcall_grpc-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/interflow/call_grpc/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopinterflowcall_grpc><span>与 gRPC 应用互通</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-center-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-center-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-center-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/config-center/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-center><span>配置中心</span></a></label><ul class="ul-6 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-centerdesc-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-centerdesc-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-centerdesc-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/config-center/desc/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-centerdesc><span>配置中心介绍</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-centerconfig-center-dynamic-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-centerconfig-center-dynamic-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-centerconfig-center-dynamic-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/config-center/config-center-dynamic/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-centerconfig-center-dynamic><span>Dubbogo 3.0 配置中心和配置监听</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-centerremote_config-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-centerremote_config-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-centerremote_config-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/config-center/remote_config/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopconfig-centerremote_config><span>远程加载配置启动</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeatures-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeatures-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeatures-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/features/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeatures><span>高级特性</span></a></label><ul class="ul-6 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturesconfig_api-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturesconfig_api-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturesconfig_api-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/features/config_api/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturesconfig_api><span>使用配置 API 启动应用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturescustom-logger-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturescustom-logger-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturescustom-logger-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/features/custom-logger/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturescustom-logger><span>日志</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturescontext-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturescontext-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturescontext-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/features/context/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturescontext><span>使用 ctx 传递上下文信息</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturesgeneric-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturesgeneric-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturesgeneric-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/features/generic/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturesgeneric><span>泛化调用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturesgeneric-2-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturesgeneric-2-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturesgeneric-2-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/develop/features/generic-2/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdevelopfeaturesgeneric-2><span>泛化调用</span></a></label></li></ul></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdebugging-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdebugging-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdebugging-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/debugging/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialdebugging><span>服务调试</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdebugginggrpc_cli-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdebugginggrpc_cli-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdebugginggrpc_cli-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/debugging/grpc_cli/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialdebugginggrpc_cli><span>使用 grpc_cli 调试 Dubbo-go 服务</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdeployment-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdeployment-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdeployment-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/deployment/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialdeployment><span>部署服务</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdeploymentpractice-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdeploymentpractice-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdeploymentpractice-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/deployment/practice/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialdeploymentpractice><span>生产部署的最佳实践介绍</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdeploymentdocker-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdeploymentdocker-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdeploymentdocker-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/deployment/docker/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialdeploymentdocker><span>Docker 镜像打包教程</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialdeploymentkubernetes-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialdeploymentkubernetes-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialdeploymentkubernetes-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/deployment/kubernetes/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialdeploymentkubernetes><span>Kubernetes 部署教程</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernance-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernance-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernance-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernance><span>服务治理</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitor-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitor-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitor-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/monitor/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitor><span>服务状态监控</span></a></label><ul class="ul-6 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorrpc_metrics-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorrpc_metrics-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorrpc_metrics-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/monitor/rpc_metrics/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorrpc_metrics><span>查看 RPC 调用的监控信息</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorhttp-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorhttp-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorhttp-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/monitor/http/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorhttp><span>基于 http metrics 的指标观测</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorpromethus-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorpromethus-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorpromethus-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/monitor/promethus/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorpromethus><span>数据上报 Promethus 教程</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorgrafana-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorgrafana-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorgrafana-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/monitor/grafana/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorgrafana><span>基于 Grafana 的可视化监控教程</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorlogger-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorlogger-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorlogger-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/monitor/logger/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitorlogger><span>Dubbo Go 日志管理</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitormetrics-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitormetrics-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitormetrics-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/monitor/metrics/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancemonitormetrics><span>Metrics 数据上报</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracing-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracing-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracing-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/tracing/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracing><span>全链路追踪</span></a></label><ul class="ul-6 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracingjaeger-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracingjaeger-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracingjaeger-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/tracing/jaeger/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracingjaeger><span>基于 Jaeger 的链路追踪</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracingopentelmentry-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracingopentelmentry-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracingopentelmentry-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/tracing/opentelmentry/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracingopentelmentry><span>使用 OpenTelmentry 协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracingskywalking-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracingskywalking-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracingskywalking-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/tracing/skywalking/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetracingskywalking><span>基于 Skywalking 的追踪</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealth-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealth-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealth-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/health/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealth><span>健康检查</span></a></label><ul class="ul-6 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealthtriple-health-check-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealthtriple-health-check-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealthtriple-health-check-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/health/triple-health-check/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealthtriple-health-check><span>基于Grpc的健康检查</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealthstart-check-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealthstart-check-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealthstart-check-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/health/start-check/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealthstart-check><span>dubbogo 3.0 启动时检查</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealthkubernetes-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealthkubernetes-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealthkubernetes-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/health/kubernetes/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancehealthkubernetes><span>Kubernetes 探针</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetraffic-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetraffic-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetraffic-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/traffic/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetraffic><span>流量管理</span></a></label><ul class="ul-6 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetrafficmesh_router-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetrafficmesh_router-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetrafficmesh_router-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/traffic/mesh_router/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetrafficmesh_router><span>路由规则</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetrafficgraceful_shutdown-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetrafficgraceful_shutdown-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetrafficgraceful_shutdown-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/traffic/graceful_shutdown/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancetrafficgraceful_shutdown><span>优雅下线</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimit-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimit-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimit-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/limit/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimit><span>限流</span></a></label><ul class="ul-6 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitinternally-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitinternally-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitinternally-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/limit/internally/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitinternally><span>Dubbo Go 内置的限流使用教程</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitsentinel-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitsentinel-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitsentinel-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/limit/sentinel/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitsentinel><span>基于 Sentinel 的限流教程</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitpolaris-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitpolaris-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitpolaris-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/limit/polaris/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitpolaris><span>基于 Polaris 的限流教程</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimittps_limiter-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimittps_limiter-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimittps_limiter-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/limit/tps_limiter/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimittps_limiter><span>为服务端设置限流</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitadaptive-service-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitadaptive-service-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitadaptive-service-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/limit/adaptive-service/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancelimitadaptive-service><span>dubbogo 3.0 柔性服务</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-mesh-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-mesh-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-mesh-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/service-mesh/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-mesh><span>服务网格</span></a></label><ul class="ul-6 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshistio-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshistio-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshistio-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/service-mesh/istio/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshistio><span>部署 Istio 环境</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshdeploy-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshdeploy-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshdeploy-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/service-mesh/deploy/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshdeploy><span>Istio 环境部署 Dubbo-go 应用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshtraffic_management-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshtraffic_management-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshtraffic_management-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/service-mesh/traffic_management/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshtraffic_management><span>流量管理</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshpixiu-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshpixiu-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshpixiu-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/service-mesh/pixiu/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshpixiu><span>使用 Pixiu 网关接入 Ingress 流量</span></a></label><ul class="ul-7 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshpixiuhttp_triple-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshpixiuhttp_triple-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshpixiuhttp_triple-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/service-mesh/pixiu/http_triple/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshpixiuhttp_triple><span>接入 Ingress 流量</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshpixiupixiu-nacos-triple-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshpixiupixiu-nacos-triple-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshpixiupixiu-nacos-triple-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/service-mesh/pixiu/pixiu-nacos-triple/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshpixiupixiu-nacos-triple><span>使用 Pixiu 暴露 Dubbo-go 服务</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshproxyless_service_mesh-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshproxyless_service_mesh-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshproxyless_service_mesh-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/service-mesh/proxyless_service_mesh/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernanceservice-meshproxyless_service_mesh><span>无代理服务网格</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeatures-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeatures-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeatures-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/features/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeatures><span>高级特性</span></a></label><ul class="ul-6 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeaturestimeout-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeaturestimeout-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeaturestimeout-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/features/timeout/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeaturestimeout><span>配置调用的超时</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeaturesaop-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeaturesaop-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeaturesaop-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/features/aop/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeaturesaop><span>自定义服务调用中间件</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeaturescustom-filter-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeaturescustom-filter-check>
<label for=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeaturescustom-filter-check><a href=/zh-cn/overview/mannual/golang-sdk/tutorial/governance/features/custom-filter/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdktutorialgovernancefeaturescustom-filter><span>自定义Filter组件</span></a></label></li></ul></li></ul></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdksourcecode-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdksourcecode-check>
<label for=m-zh-cnoverviewmannualgolang-sdksourcecode-check><a href=/zh-cn/overview/mannual/golang-sdk/sourcecode/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdksourcecode><span>源码解读</span></a></label><ul class="ul-4 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdksourcecodeprotocol-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdksourcecodeprotocol-check>
<label for=m-zh-cnoverviewmannualgolang-sdksourcecodeprotocol-check><a href=/zh-cn/overview/mannual/golang-sdk/sourcecode/protocol/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdksourcecodeprotocol><span>网络协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdksourcecoderegistry-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdksourcecoderegistry-check>
<label for=m-zh-cnoverviewmannualgolang-sdksourcecoderegistry-check><a href=/zh-cn/overview/mannual/golang-sdk/sourcecode/registry/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdksourcecoderegistry><span>注册中心</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualgolang-sdkrefer-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkrefer-check>
<label for=m-zh-cnoverviewmannualgolang-sdkrefer-check><a href=/zh-cn/overview/mannual/golang-sdk/refer/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualgolang-sdkrefer><span>参考手册</span></a></label><ul class="ul-4 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkreferconfig-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkreferconfig-check>
<label for=m-zh-cnoverviewmannualgolang-sdkreferconfig-check><a href=/zh-cn/overview/mannual/golang-sdk/refer/config/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkreferconfig><span>配置项参考指南</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkreferuse_dubbogo_cli-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkreferuse_dubbogo_cli-check>
<label for=m-zh-cnoverviewmannualgolang-sdkreferuse_dubbogo_cli-check><a href=/zh-cn/overview/mannual/golang-sdk/refer/use_dubbogo_cli/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkreferuse_dubbogo_cli><span>使用 dubbogo-cli 工具</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkreferecology-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkreferecology-check>
<label for=m-zh-cnoverviewmannualgolang-sdkreferecology-check><a href=/zh-cn/overview/mannual/golang-sdk/refer/ecology/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkreferecology><span>生态组件</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkrefercompatible_version-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkrefercompatible_version-check>
<label for=m-zh-cnoverviewmannualgolang-sdkrefercompatible_version-check><a href=/zh-cn/overview/mannual/golang-sdk/refer/compatible_version/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkrefercompatible_version><span>版本号</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualgolang-sdkreferbasic_concept-li><input type=checkbox id=m-zh-cnoverviewmannualgolang-sdkreferbasic_concept-check>
<label for=m-zh-cnoverviewmannualgolang-sdkreferbasic_concept-check><a href=/zh-cn/overview/mannual/golang-sdk/refer/basic_concept/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualgolang-sdkreferbasic_concept><span>配置基本概念</span></a></label></li></ul></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualdubbo-go-pixiu-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiu-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiu-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualdubbo-go-pixiu><span>Dubbo Go Pixiu</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuoverview-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuoverview-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuoverview-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/overview/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualdubbo-go-pixiuoverview><span>入门概述</span></a></label><ul class="ul-4 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuoverviewwhat-is-pixiu-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuoverviewwhat-is-pixiu-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuoverviewwhat-is-pixiu-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/overview/what-is-pixiu/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuoverviewwhat-is-pixiu><span>Pixiu 是什么</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuoverviewterminology-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuoverviewterminology-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuoverviewterminology-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/overview/terminology/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuoverviewterminology><span>Pixiu 术语</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuoverviewfaq-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuoverviewfaq-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuoverviewfaq-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/overview/faq/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuoverviewfaq><span>Pixiu 常见问题</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuser-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuser-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuser-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualdubbo-go-pixiuuser><span>用户文档</span></a></label><ul class="ul-4 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserquickstart-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserquickstart-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserquickstart-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/quickstart/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserquickstart><span>快速开始</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserconfigurations-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserconfigurations-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserconfigurations-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/configurations/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserconfigurations><span>启动和配置</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserdeployment-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserdeployment-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserdeployment-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/deployment/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserdeployment><span>部署操作</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistener-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistener-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistener-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/listener/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistener><span>Listener 介绍</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenerhttp-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenerhttp-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenerhttp-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/listener/http/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenerhttp><span>Http Listener 介绍</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenerhttp2-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenerhttp2-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenerhttp2-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/listener/http2/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenerhttp2><span>Http2 Listener 介绍</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenertcp-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenertcp-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenertcp-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/listener/tcp/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenertcp><span>TCP Listener 介绍</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenertriple-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenertriple-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenertriple-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/listener/triple/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserlistenertriple><span>Triple Listener 介绍</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfilter-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfilter-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfilter-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/networkfilter/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfilter><span>Network Filter 介绍</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfilterhttp-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfilterhttp-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfilterhttp-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/networkfilter/http/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfilterhttp><span>Http NetWorkFilter 介绍</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfiltergrpc-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfiltergrpc-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfiltergrpc-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/networkfilter/grpc/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfiltergrpc><span>Grpc NetWorkFilter 介绍</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfilterdubbo-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfilterdubbo-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfilterdubbo-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/networkfilter/dubbo/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuusernetworkfilterdubbo><span>Dubbo NetWorkFilter 介绍</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuseradapter-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuseradapter-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuseradapter-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/adapter/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualdubbo-go-pixiuuseradapter><span>Adapter 介绍</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuseradapterdubbo-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuseradapterdubbo-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuseradapterdubbo-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/adapter/dubbo/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuuseradapterdubbo><span>Dubbo 集群中心 Adapter</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuseradapterspringcloud-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuseradapterspringcloud-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuseradapterspringcloud-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/adapter/springcloud/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuuseradapterspringcloud><span>Spring Cloud 集群中心 Adapter</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilter-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilter-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilter-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/httpfilter/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilter><span>Http Filter 介绍</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilterdubbo-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilterdubbo-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilterdubbo-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/httpfilter/dubbo/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilterdubbo><span>Dubbo HttpFilter 介绍</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilterratelimit-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilterratelimit-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilterratelimit-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/httpfilter/ratelimit/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilterratelimit><span>RateLimiter 介绍</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilterhystrix-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilterhystrix-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilterhystrix-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/httpfilter/hystrix/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserhttpfilterhystrix><span>断路器介绍</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuusersamples-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuusersamples-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuusersamples-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/samples/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualdubbo-go-pixiuusersamples><span>案例介绍</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuusersampleshttp_proxy-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuusersampleshttp_proxy-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuusersampleshttp_proxy-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/samples/http_proxy/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuusersampleshttp_proxy><span>Http Proxy 案例介绍</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuusersampleshttp_to_dubbo-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuusersampleshttp_to_dubbo-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuusersampleshttp_to_dubbo-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/samples/http_to_dubbo/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuusersampleshttp_to_dubbo><span>Http to Dubbo 案例介绍</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuusersampleshttps-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuusersampleshttps-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuusersampleshttps-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/samples/https/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuusersampleshttps><span>Https 案例介绍</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserquality-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserquality-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserquality-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/quality/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserquality><span>质量指标</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserqualitystability-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserqualitystability-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserqualitystability-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/quality/stability/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserqualitystability><span>稳定性</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserqualityperformance-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserqualityperformance-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserqualityperformance-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/quality/performance/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserqualityperformance><span>性能</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserappendix-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserappendix-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserappendix-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/appendix/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserappendix><span>附录</span></a></label><ul class="ul-5 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserappendixhttp-to-dubbo-default-stragety-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiuuserappendixhttp-to-dubbo-default-stragety-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiuuserappendixhttp-to-dubbo-default-stragety-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/user/appendix/http-to-dubbo-default-stragety/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiuuserappendixhttp-to-dubbo-default-stragety><span>HTTP to Dubbo 默认转换协议</span></a></label></li></ul></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualdubbo-go-pixiudev-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiudev-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiudev-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/dev/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualdubbo-go-pixiudev><span>开发者指南</span></a></label><ul class="ul-4 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiudevfilter-extension-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiudevfilter-extension-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiudevfilter-extension-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/dev/filter-extension/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiudevfilter-extension><span>Pixiu Filter体系介绍</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiudevdubbo-pilot-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiudevdubbo-pilot-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiudevdubbo-pilot-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/dev/dubbo-pilot/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiudevdubbo-pilot><span>dubbo-pilot Control Plane 部署</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualdubbo-go-pixiudevtrie-li><input type=checkbox id=m-zh-cnoverviewmannualdubbo-go-pixiudevtrie-check>
<label for=m-zh-cnoverviewmannualdubbo-go-pixiudevtrie-check><a href=/zh-cn/overview/mannual/dubbo-go-pixiu/dev/trie/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualdubbo-go-pixiudevtrie><span>Trie 前缀树介绍</span></a></label></li></ul></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualrust-sdk-li><input type=checkbox id=m-zh-cnoverviewmannualrust-sdk-check>
<label for=m-zh-cnoverviewmannualrust-sdk-check><a href=/zh-cn/overview/mannual/rust-sdk/ title="Rust SDK 手册" class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualrust-sdk><span>Rust SDK</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualrust-sdkquick-start-li><input type=checkbox id=m-zh-cnoverviewmannualrust-sdkquick-start-check>
<label for=m-zh-cnoverviewmannualrust-sdkquick-start-check><a href=/zh-cn/overview/mannual/rust-sdk/quick-start/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualrust-sdkquick-start><span>快速开始</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualrust-sdkjava-interoperability-li><input type=checkbox id=m-zh-cnoverviewmannualrust-sdkjava-interoperability-check>
<label for=m-zh-cnoverviewmannualrust-sdkjava-interoperability-check><a href=/zh-cn/overview/mannual/rust-sdk/java-interoperability/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualrust-sdkjava-interoperability><span>Rust和Java互相调用</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualrust-sdkservice-discovery-li><input type=checkbox id=m-zh-cnoverviewmannualrust-sdkservice-discovery-check>
<label for=m-zh-cnoverviewmannualrust-sdkservice-discovery-check><a href=/zh-cn/overview/mannual/rust-sdk/service-discovery/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualrust-sdkservice-discovery><span>服务发现</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualrust-sdkrouter-module-li><input type=checkbox id=m-zh-cnoverviewmannualrust-sdkrouter-module-check>
<label for=m-zh-cnoverviewmannualrust-sdkrouter-module-check><a href=/zh-cn/overview/mannual/rust-sdk/router-module/ title=服务路由规则 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualrust-sdkrouter-module><span>服务路由</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualrust-sdkstreaming-li><input type=checkbox id=m-zh-cnoverviewmannualrust-sdkstreaming-check>
<label for=m-zh-cnoverviewmannualrust-sdkstreaming-check><a href=/zh-cn/overview/mannual/rust-sdk/streaming/ title="Streaming 通信模型" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualrust-sdkstreaming><span>Streaming通信模型</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualrust-sdkunix-transport-li><input type=checkbox id=m-zh-cnoverviewmannualrust-sdkunix-transport-check>
<label for=m-zh-cnoverviewmannualrust-sdkunix-transport-check><a href=/zh-cn/overview/mannual/rust-sdk/unix-transport/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualrust-sdkunix-transport><span>使用Unix套接字连接器通信</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewmannualerlang-sdk-li><input type=checkbox id=m-zh-cnoverviewmannualerlang-sdk-check>
<label for=m-zh-cnoverviewmannualerlang-sdk-check><a href=/zh-cn/overview/mannual/erlang-sdk/ title="Erlang SDK 手册" class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewmannualerlang-sdk><span>Erlang SDK</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualerlang-sdkquick-start-li><input type=checkbox id=m-zh-cnoverviewmannualerlang-sdkquick-start-check>
<label for=m-zh-cnoverviewmannualerlang-sdkquick-start-check><a href=/zh-cn/overview/mannual/erlang-sdk/quick-start/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualerlang-sdkquick-start><span>快速开始</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualerlang-sdkreference-li><input type=checkbox id=m-zh-cnoverviewmannualerlang-sdkreference-check>
<label for=m-zh-cnoverviewmannualerlang-sdkreference-check><a href=/zh-cn/overview/mannual/erlang-sdk/reference/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualerlang-sdkreference><span>消费者配置</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualerlang-sdkservice-li><input type=checkbox id=m-zh-cnoverviewmannualerlang-sdkservice-check>
<label for=m-zh-cnoverviewmannualerlang-sdkservice-check><a href=/zh-cn/overview/mannual/erlang-sdk/service/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualerlang-sdkservice><span>提供者配置</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualerlang-sdkserialization-li><input type=checkbox id=m-zh-cnoverviewmannualerlang-sdkserialization-check>
<label for=m-zh-cnoverviewmannualerlang-sdkserialization-check><a href=/zh-cn/overview/mannual/erlang-sdk/serialization/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualerlang-sdkserialization><span>序列化配置项</span></a></label></li></ul></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewreference-li><input type=checkbox id=m-zh-cnoverviewreference-check>
<label for=m-zh-cnoverviewreference-check><a href=/zh-cn/overview/reference/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewreference><span>其他</span></a></label><ul class="ul-2 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewreferenceadmin-li><input type=checkbox id=m-zh-cnoverviewreferenceadmin-check>
<label for=m-zh-cnoverviewreferenceadmin-check><a href=/zh-cn/overview/reference/admin/ title="Admin 控制台操作手册" class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewreferenceadmin><span>Admin</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceadminarchitecture-li><input type=checkbox id=m-zh-cnoverviewreferenceadminarchitecture-check>
<label for=m-zh-cnoverviewreferenceadminarchitecture-check><a href=/zh-cn/overview/reference/admin/architecture/ title="Admin 整体架构与安装步骤" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceadminarchitecture><span>架构与安装</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceadminsearch-li><input type=checkbox id=m-zh-cnoverviewreferenceadminsearch-check>
<label for=m-zh-cnoverviewreferenceadminsearch-check><a href=/zh-cn/overview/reference/admin/search/ title="Admin 服务查询" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceadminsearch><span>文档查询</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceadmintest-li><input type=checkbox id=m-zh-cnoverviewreferenceadmintest-check>
<label for=m-zh-cnoverviewreferenceadmintest-check><a href=/zh-cn/overview/reference/admin/test/ title="Admin 服务测试功能简介" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceadmintest><span>服务测试</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceadminmock-li><input type=checkbox id=m-zh-cnoverviewreferenceadminmock-check>
<label for=m-zh-cnoverviewreferenceadminmock-check><a href=/zh-cn/overview/reference/admin/mock/ title="Admin 服务 Mock 功能简介" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceadminmock><span>服务Mock</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewreferencemetrics-li><input type=checkbox id=m-zh-cnoverviewreferencemetrics-check>
<label for=m-zh-cnoverviewreferencemetrics-check><a href=/zh-cn/overview/reference/metrics/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewreferencemetrics><span>Metrics</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferencemetricsstandard_metrics-li><input type=checkbox id=m-zh-cnoverviewreferencemetricsstandard_metrics-check>
<label for=m-zh-cnoverviewreferencemetricsstandard_metrics-check><a href=/zh-cn/overview/reference/metrics/standard_metrics/ title="Dubbo 框架标准监控指标" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferencemetricsstandard_metrics><span>标准监控指标</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewreferenceintegrations-li><input type=checkbox id=m-zh-cnoverviewreferenceintegrations-check>
<label for=m-zh-cnoverviewreferenceintegrations-check><a href=/zh-cn/overview/reference/integrations/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewreferenceintegrations><span>集成适配</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceintegrationsprometheus-li><input type=checkbox id=m-zh-cnoverviewreferenceintegrationsprometheus-check>
<label for=m-zh-cnoverviewreferenceintegrationsprometheus-check><a href=/zh-cn/overview/reference/integrations/prometheus/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceintegrationsprometheus><span>Prometheus</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceintegrationsgrafana-li><input type=checkbox id=m-zh-cnoverviewreferenceintegrationsgrafana-check>
<label for=m-zh-cnoverviewreferenceintegrationsgrafana-check><a href=/zh-cn/overview/reference/integrations/grafana/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceintegrationsgrafana><span>Grafana</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceintegrationsskywalking-li><input type=checkbox id=m-zh-cnoverviewreferenceintegrationsskywalking-check>
<label for=m-zh-cnoverviewreferenceintegrationsskywalking-check><a href=/zh-cn/overview/reference/integrations/skywalking/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceintegrationsskywalking><span>Skywalking</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceintegrationszipkin-li><input type=checkbox id=m-zh-cnoverviewreferenceintegrationszipkin-check>
<label for=m-zh-cnoverviewreferenceintegrationszipkin-check><a href=/zh-cn/overview/reference/integrations/zipkin/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceintegrationszipkin><span>Zipkin</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewreferenceproposals-li><input type=checkbox id=m-zh-cnoverviewreferenceproposals-check>
<label for=m-zh-cnoverviewreferenceproposals-check><a href=/zh-cn/overview/reference/proposals/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewreferenceproposals><span>提案</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceproposalsprotocol-http-li><input type=checkbox id=m-zh-cnoverviewreferenceproposalsprotocol-http-check>
<label for=m-zh-cnoverviewreferenceproposalsprotocol-http-check><a href=/zh-cn/overview/reference/proposals/protocol-http/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceproposalsprotocol-http><span>Rest 协议</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceproposalsregistry-config-meta-li><input type=checkbox id=m-zh-cnoverviewreferenceproposalsregistry-config-meta-check>
<label for=m-zh-cnoverviewreferenceproposalsregistry-config-meta-check><a href=/zh-cn/overview/reference/proposals/registry-config-meta/ title=注册中心、配置中心和元数据中心 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceproposalsregistry-config-meta><span>注册&配置&元数据中心</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceproposalsadmin-li><input type=checkbox id=m-zh-cnoverviewreferenceproposalsadmin-check>
<label for=m-zh-cnoverviewreferenceproposalsadmin-check><a href=/zh-cn/overview/reference/proposals/admin/ title="Dubbo Admin 控制面总体架构设计" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceproposalsadmin><span>Admin 架构设计</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceproposalsmetrics-li><input type=checkbox id=m-zh-cnoverviewreferenceproposalsmetrics-check>
<label for=m-zh-cnoverviewreferenceproposalsmetrics-check><a href=/zh-cn/overview/reference/proposals/metrics/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceproposalsmetrics><span>指标埋点</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceproposalsheuristic-flow-control-li><input type=checkbox id=m-zh-cnoverviewreferenceproposalsheuristic-flow-control-check>
<label for=m-zh-cnoverviewreferenceproposalsheuristic-flow-control-check><a href=/zh-cn/overview/reference/proposals/heuristic-flow-control/ title=自适应负载均衡与限流 class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceproposalsheuristic-flow-control><span>服务柔性</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceproposalsservice-discovery-li><input type=checkbox id=m-zh-cnoverviewreferenceproposalsservice-discovery-check>
<label for=m-zh-cnoverviewreferenceproposalsservice-discovery-check><a href=/zh-cn/overview/reference/proposals/service-discovery/ title="Dubbo3 应用级服务发现设计" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceproposalsservice-discovery><span>应用级服务发现</span></a></label></li></ul></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewreferenceprotocols-li><input type=checkbox id=m-zh-cnoverviewreferenceprotocols-check>
<label for=m-zh-cnoverviewreferenceprotocols-check><a href=/zh-cn/overview/reference/protocols/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewreferenceprotocols><span>协议规范</span></a></label><ul class="ul-3 foldable"><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceprotocolstriple-spec-li><input type=checkbox id=m-zh-cnoverviewreferenceprotocolstriple-spec-check>
<label for=m-zh-cnoverviewreferenceprotocolstriple-spec-check><a href=/zh-cn/overview/reference/protocols/triple-spec/ title="Triple 协议设计理念与规范" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceprotocolstriple-spec><span>Triple 协议规范</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceprotocolstriple-li><input type=checkbox id=m-zh-cnoverviewreferenceprotocolstriple-check>
<label for=m-zh-cnoverviewreferenceprotocolstriple-check><a href=/zh-cn/overview/reference/protocols/triple/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceprotocolstriple><span>Triple 协议优势与目标</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceprotocolstcp-li><input type=checkbox id=m-zh-cnoverviewreferenceprotocolstcp-check>
<label for=m-zh-cnoverviewreferenceprotocolstcp-check><a href=/zh-cn/overview/reference/protocols/tcp/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceprotocolstcp><span>Dubbo2 协议规范</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceprotocolshttp-li><input type=checkbox id=m-zh-cnoverviewreferenceprotocolshttp-check>
<label for=m-zh-cnoverviewreferenceprotocolshttp-check><a href=/zh-cn/overview/reference/protocols/http/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceprotocolshttp><span>HTTP 协议规范</span></a></label></li></ul></li></ul></li></ul></li></ul></nav></div></div><main class="col-12 col-md-9 col-xl-8 pl-md-5" role=main><nav aria-label=breadcrumb class=td-breadcrumbs><ol class=breadcrumb><li class=breadcrumb-item><a href=https://dubbo.apache.org/zh-cn/overview/>文档</a></li><li class=breadcrumb-item><a href=https://dubbo.apache.org/zh-cn/overview/mannual/>SDK 用户手册</a></li><li class=breadcrumb-item><a href=https://dubbo.apache.org/zh-cn/overview/mannual/java-sdk/>Java SDK</a></li><li class=breadcrumb-item><a href=https://dubbo.apache.org/zh-cn/overview/mannual/java-sdk/faq/>错误码 FAQ</a></li><li class="breadcrumb-item active" aria-current=page><a href=https://dubbo.apache.org/zh-cn/overview/mannual/java-sdk/faq/7/ aria-disabled=true class="btn-link disabled">7 - QoS 插件模块</a></li></ol></nav><div class=td-content><h1>7 - QoS 插件模块</h1><div class=lead>7 - QoS 插件模块</div><header class=article-meta></header><div class=section-index><hr class=panel-line><div class=entry><h5><a href=/zh-cn/overview/mannual/java-sdk/faq/7/1/>7-1 - QOS 已关闭</a></h5><p>7-1 - QOS 已关闭</p></div><div class=entry><h5><a href=/zh-cn/overview/mannual/java-sdk/faq/7/2/>7-2 - QOS 已开启</a></h5><p>7-2 - QOS 已开启</p></div><div class=entry><h5><a href=/zh-cn/overview/mannual/java-sdk/faq/7/3/>7-3 - 设置超时时间的警告百分比值</a></h5><p>7-3 - 设置超时时间的警告百分比值</p></div><div class=entry><h5><a href=/zh-cn/overview/mannual/java-sdk/faq/7/4/>7-4 - QOS 服务启动失败</a></h5><p>7-4 - QOS 服务启动失败</p></div><div class=entry><h5><a href=/zh-cn/overview/mannual/java-sdk/faq/7/5/>7-5 - QOS 命令未找到</a></h5><p>7-5 - QOS 命令未找到</p></div><div class=entry><h5><a href=/zh-cn/overview/mannual/java-sdk/faq/7/6/>7-6 - QOS 发生未知异常</a></h5><p>7-6 - QOS 发生未知异常</p></div><div class=entry><h5><a href=/zh-cn/overview/mannual/java-sdk/faq/7/7/>7-7 - QOS 无权限访问</a></h5><p>7-7 - QOS 无权限访问</p></div></div><div id=pre-footer><h2>反馈</h2><p class=feedback--prompt>此页是否对您有帮助？</p><button class="btn btn-primary mb-4 feedback--yes">是</button>
<button class="btn btn-primary mb-4 feedback--no">否</button></div><script>const yes=document.querySelector(".feedback--yes"),no=document.querySelector(".feedback--no");document.querySelectorAll(".feedback--link").forEach(e=>{e.href=e.href+window.location.pathname});const sendFeedback=e=>{gtag||console.log("!gtag"),gtag("event","click",{event_category:"Helpful",event_label:window.location.pathname,value:e})},disableButtons=()=>{yes.disabled=!0,yes.classList.add("feedback--button__disabled"),no.disabled=!0,no.classList.add("feedback--button__disabled")};yes.addEventListener("click",()=>{sendFeedback(1),disableButtons(),document.querySelector(".feedback--response").classList.remove("feedback--response__hidden")}),no.addEventListener("click",()=>{sendFeedback(0),disableButtons(),document.querySelector(".feedback--response").classList.remove("feedback--response__hidden")})</script><br><div class="text-muted mt-5 pt-3 border-top">最后修改 March 1, 2023: <a href=https://github.com/apache/dubbo-website/commit/ceab0ea115ae57b25d607864d9eb2e5e9423f4cb>Move sdk docs (#2337) (ceab0ea115)</a></div></div></main><div class="d-none d-xl-block col-xl-2 td-toc d-print-none"><div class="td-page-meta ml-2 pb-1 pt-2 mb-0"><a href=https://github.com/apache/dubbo-website/edit/master/content/zh-cn/overview/mannual/java-sdk/faq/7/_index.md target=_blank><i class="fa fa-edit fa-fw"></i> 编辑此页</a>
<a href="https://github.com/apache/dubbo-website/new/master/content/zh-cn/overview/mannual/java-sdk/faq/7/_index.md?filename=change-me.md&amp;value=---%0Atitle%3A+%22Long+Page+Title%22%0AlinkTitle%3A+%22Short+Nav+Title%22%0Aweight%3A+100%0Adescription%3A+%3E-%0A+++++Page+description+for+heading+and+indexes.%0A---%0A%0A%23%23+Heading%0A%0AEdit+this+template+to+create+your+new+page.%0A%0A%2A+Give+it+a+good+name%2C+ending+in+%60.md%60+-+e.g.+%60getting-started.md%60%0A%2A+Edit+the+%22front+matter%22+section+at+the+top+of+the+page+%28weight+controls+how+its+ordered+amongst+other+pages+in+the+same+directory%3B+lowest+number+first%29.%0A%2A+Add+a+good+commit+message+at+the+bottom+of+the+page+%28%3C80+characters%3B+use+the+extended+description+field+for+more+detail%29.%0A%2A+Create+a+new+branch+so+you+can+preview+your+new+file+and+request+a+review+via+Pull+Request.%0A" target=_blank><i class="fa fa-edit fa-fw"></i> 创建子页面</a>
<a href="https://github.com/apache/dubbo-website/issues/new?title=7%20-%20QoS%20%e6%8f%92%e4%bb%b6%e6%a8%a1%e5%9d%97" target=_blank><i class="fab fa-github fa-fw"></i> 登记问题</a>
<a href=https://github.com/apache/dubbo/issues/new target=_blank><i class="fas fa-tasks fa-fw"></i> 提交项目问题</a></div></div></div></div></div><footer class="bg-dark py-5 row d-print-none footer-margin-0"><div class="container-fluid mx-sm-5"><div class=row><div class="col-6 col-sm-4 text-xs-center order-sm-2"><ul class="list-inline mb-0"><li class="list-inline-item mx-2 h3" data-toggle=tooltip data-placement=top title="Dubbo mailing list archive" aria-label="Dubbo mailing list archive"><a class=text-white target=_blank rel="noopener noreferrer" href=https://lists.apache.org/list.html?dev@dubbo.apache.org><i class="fa fa-envelope"></i></a></li></ul></div><div class="col-6 col-sm-4 text-right text-xs-center order-sm-3"><ul class="list-inline mb-0"><li class="list-inline-item mx-2 h3" data-toggle=tooltip data-placement=top title=GitHub aria-label=GitHub><a class=text-white target=_blank rel="noopener noreferrer" href=https://github.com/apache/dubbo><i class="fab fa-github"></i></a></li><li class="list-inline-item mx-2 h3" data-toggle=tooltip data-placement=top title="Subscribe to mailing list" aria-label="Subscribe to mailing list"><a class=text-white target=_blank rel="noopener noreferrer" href=mailto:dev-subscribe@dubbo.apache.org><i class="fa fa-envelope"></i></a></li></ul></div><div class="col-12 col-sm-4 text-center py-2 order-sm-2"><small class=text-white>&copy; 2023 The Apache Software Foundation. Apache and the Apache feather logo are trademarks of The Apache Software Foundation. 保留所有权利</small></div></div></div></footer><div class="row pt-2 pb-2 footer-margin-0"><div class="container-fluid mx-sm-5"><div class=text-center id=my-footer><img style=float:left alt=apache_logo src=/imgs/apache_logo.png><ul><li><a href=https://www.apache.org>Foundation</a></li><li><a href=https://www.apache.org/licenses/>License</a></li><li><a href=https://dubbo.apache.org/en/docs/notices/security/>Security</a></li><li><a href=https://www.apache.org/events/current-event>Events</a></li><li><a href=https://www.apache.org/foundation/sponsorship.html>Sponsorship</a></li><li><a href=https://privacy.apache.org/policies/privacy-policy-public.html>Privacy</a></li><li><a href=https://www.apache.org/foundation/thanks.html>Thanks</a></li></ul></div></div></div><script src=/js/popper.min.js integrity=sha384-ZMP7rVo3mIykV+2+9J3UJ46jBk0WLaUAdn689aCwoqbBJiSnjAK/l8WvCWPIPm49 crossorigin=anonymous></script><script src=/js/bootstrap.min.js integrity=sha384-ChfqqxuZUCnJSK3+MXmPNIyE6ZbWh2IMqE241rYiqJxyMiZ6OW/JmZQ5stwEULTy crossorigin=anonymous></script><script src=/js/main.min.a4534a01940be8c082c4c0e6777b61df9884f202b61c9519352adb6d1039d5aa.js integrity="sha256-pFNKAZQL6MCCxMDmd3th35iE8gK2HJUZNSrbbRA51ao=" crossorigin=anonymous></script><script src=https://cdn.jsdelivr.net/npm/@docsearch/js@3></script><script>docsearch({appId:"L5F4T9F0I1",apiKey:"364ae307e1da9d02b2335675e9db1eb1",indexName:"apache_dubbo",container:"#docsearch",debug:!1}),docsearch({appId:"L5F4T9F0I1",apiKey:"364ae307e1da9d02b2335675e9db1eb1",indexName:"apache_dubbo",container:"#docsearch_zh_home",debug:!1})</script></body></html>