<!doctype html><html lang=zh-cn class=no-js><head><meta name=ROBOTS content="INDEX, FOLLOW"><link rel=canonical href=https://cn.dubbo.apache.org/zh-cn/overview/mannual/java-sdk/faq/7/2/><script>var _hmt=_hmt||[];(function(){var e,t=document.createElement("script");t.src="https://hm.baidu.com/hm.js?3b78f49ba47181e4d998a66b689446e9",e=document.getElementsByTagName("script")[0],e.parentNode.insertBefore(t,e)})()</script><meta charset=utf-8><meta name=viewport content="width=device-width,initial-scale=1,shrink-to-fit=no"><meta http-equiv=Content-Security-Policy content="frame-src *"><meta name=generator content="Hugo 0.122.0"><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-2 - QOS 已开启 | Apache Dubbo</title><meta property="og:title" content="7-2 - QOS 已开启">
<meta property="og:description" content="7-2 - QOS 已开启"><meta property="og:type" content="article"><meta property="og:url" content="https://cn.dubbo.apache.org/zh-cn/overview/mannual/java-sdk/faq/7/2/"><meta property="article:section" content="overview"><meta property="article:modified_time" content="2023-03-02T10:12:02+08:00"><meta itemprop=name content="7-2 - QOS 已开启"><meta itemprop=description content="7-2 - QOS 已开启"><meta itemprop=dateModified content="2023-03-02T10:12:02+08:00"><meta itemprop=wordCount content="6"><meta itemprop=keywords content><meta name=twitter:card content="summary"><meta name=twitter:title content="7-2 - QOS 已开启"><meta name=twitter:description content="7-2 - QOS 已开启"><script async src="https://www.googletagmanager.com/gtag/js?id=G-NM6FFMT51J"></script><script>var doNotTrack=!1;if(!doNotTrack){window.dataLayer=window.dataLayer||[];function gtag(){dataLayer.push(arguments)}gtag("js",new Date),gtag("config","G-NM6FFMT51J",{anonymize_ip:!1})}</script><link rel=preload href=/scss/main.min.9e6561cc0361d4774cd6dea1f797b4d79df2a97001c1d51e86b490fa04cfc749.css as=style><link href=/scss/main.min.9e6561cc0361d4774cd6dea1f797b4d79df2a97001c1d51e86b490fa04cfc749.css rel=stylesheet integrity><script src=/js/jquery-3.5.1.min.js integrity="sha256-9/aliU8dGd2tb6OSsuzixeV4y/faTqgFtohetphbbj0=" crossorigin=anonymous></script><meta name=theme-color content="#326ce5"><link rel=stylesheet href=/css/feature-states.css><meta name=description content="7-2 - QOS 已开启"><meta property="og:description" content="7-2 - QOS 已开启"><meta name=twitter:description content="7-2 - QOS 已开启"><meta property="og:url" content="https://cn.dubbo.apache.org/zh-cn/overview/mannual/java-sdk/faq/7/2/"><meta property="og:title" content="7-2 - QOS 已开启"><meta name=twitter:title content="7-2 - 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-page 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></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-sdkfaq72").addClass("active"),$("#td-section-nav #m-zh-cnoverviewmannualjava-sdkfaq72-li span").addClass("td-sidebar-nav-active-item"),$("#td-section-nav #m-zh-cnoverviewmannualjava-sdkfaq72").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-sdkfaq72-li").siblings("li").addClass("show"),$("#td-section-nav #m-zh-cnoverviewmannualjava-sdkfaq72-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"><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><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageotherslogger-howto-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageotherslogger-howto-check>
<label for=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageotherslogger-howto-check><a href=/zh-cn/overview/mannual/java-sdk/advanced-features-and-usage/others/logger-howto/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkadvanced-features-and-usageotherslogger-howto><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-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-manualperformancepage-benchmarking-li><input type=checkbox id=m-zh-cnoverviewmannualjava-sdkreference-manualperformancepage-benchmarking-check>
<label for=m-zh-cnoverviewmannualjava-sdkreference-manualperformancepage-benchmarking-check><a href=/zh-cn/overview/mannual/java-sdk/reference-manual/performance/page-benchmarking/ title="RPC 基准测试 控制台" class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewmannualjava-sdkreference-manualperformancepage-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-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><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewreferenceproposalssupport-more-content-types-li><input type=checkbox id=m-zh-cnoverviewreferenceproposalssupport-more-content-types-check>
<label for=m-zh-cnoverviewreferenceproposalssupport-more-content-types-check><a href=/zh-cn/overview/reference/proposals/support-more-content-types/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewreferenceproposalssupport-more-content-types><span>Triple协议Http标准能力增强-多Content-Type支持</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><li class="td-sidebar-nav__section-title td-sidebar-nav__section with-child" id=m-zh-cnoverviewnotices-li><input type=checkbox id=m-zh-cnoverviewnotices-check>
<label for=m-zh-cnoverviewnotices-check><a href=/zh-cn/overview/notices/ class="align-left pl-0 td-sidebar-link td-sidebar-link__section" id=m-zh-cnoverviewnotices><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-cnoverviewnoticesserialization-li><input type=checkbox id=m-zh-cnoverviewnoticesserialization-check>
<label for=m-zh-cnoverviewnoticesserialization-check><a href=/zh-cn/overview/notices/serialization/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewnoticesserialization><span>序列化安全</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewnoticesprotocol-li><input type=checkbox id=m-zh-cnoverviewnoticesprotocol-check>
<label for=m-zh-cnoverviewnoticesprotocol-check><a href=/zh-cn/overview/notices/protocol/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewnoticesprotocol><span>RPC 协议安全</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewnoticesregistry-li><input type=checkbox id=m-zh-cnoverviewnoticesregistry-check>
<label for=m-zh-cnoverviewnoticesregistry-check><a href=/zh-cn/overview/notices/registry/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewnoticesregistry><span>注册中心安全</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewnoticesadmin-li><input type=checkbox id=m-zh-cnoverviewnoticesadmin-check>
<label for=m-zh-cnoverviewnoticesadmin-check><a href=/zh-cn/overview/notices/admin/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewnoticesadmin><span>Dubbo Admin 安全</span></a></label></li><li class="td-sidebar-nav__section-title td-sidebar-nav__section without-child" id=m-zh-cnoverviewnoticeslog4j-li><input type=checkbox id=m-zh-cnoverviewnoticeslog4j-check>
<label for=m-zh-cnoverviewnoticeslog4j-check><a href=/zh-cn/overview/notices/log4j/ class="align-left pl-0 td-sidebar-link td-sidebar-link__page" id=m-zh-cnoverviewnoticeslog4j><span>Log4j 漏洞影响</span></a></label></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://cn.dubbo.apache.org/zh-cn/overview/>文档</a></li><li class=breadcrumb-item><a href=https://cn.dubbo.apache.org/zh-cn/overview/mannual/>SDK 用户手册</a></li><li class=breadcrumb-item><a href=https://cn.dubbo.apache.org/zh-cn/overview/mannual/java-sdk/>Java SDK</a></li><li class=breadcrumb-item><a href=https://cn.dubbo.apache.org/zh-cn/overview/mannual/java-sdk/faq/>错误码 FAQ</a></li><li class=breadcrumb-item><a href=https://cn.dubbo.apache.org/zh-cn/overview/mannual/java-sdk/faq/7/>7 - QoS 插件模块</a></li><li class="breadcrumb-item active" aria-current=page><a href=https://cn.dubbo.apache.org/zh-cn/overview/mannual/java-sdk/faq/7/2/ aria-disabled=true class="btn-link disabled">7-2 - QOS 已开启</a></li></ol></nav><div class=td-content><h1>7-2 - QOS 已开启</h1><div class=lead>7-2 - QOS 已开启</div><header class=article-meta></header><h3 id=可能的原因>可能的原因</h3><p>QOS 已开启，默认为开启状态。</p><h3 id=排查和解决步骤>排查和解决步骤</h3><blockquote><p>请参考<a href=/zh-cn/overview/mannual/java-sdk/reference-manual/qos/>QOS 操作手册</a>。</p></blockquote><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 2, 2023: <a href=https://github.com/apache/dubbo-website/commit/f16c1535592b73754a93fcd0e65b78865ce84ca3>Fix alias forward in docs3-v2 (#2342) (f16c1535592)</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/2.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/2.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-2%20-%20QOS%20%e5%b7%b2%e5%bc%80%e5%90%af" 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><nav id=TableOfContents><ul><li><ul><li><a href=#可能的原因>可能的原因</a></li><li><a href=#排查和解决步骤>排查和解决步骤</a></li></ul></li></ul></nav></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; 2024 The Apache Software Foundation. Apache Dubbo, Dubbo, Apache, the Apache feather logo, and the Apache Dubbo project logo are either registered trademarks or trademarks of The Apache Software Foundation in the United States and other countries. 保留所有权利</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 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/overview/notices/>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.b075178d232d3b0039b3cb6af2fc2e9d90071820167a60f4eea3a79169975ee8.js integrity="sha256-sHUXjSMtOwA5s8tq8vwunZAHGCAWemD07qOnkWmXXug=" crossorigin=anonymous></script><script async src=https://widget.kapa.ai/kapa-widget.bundle.js data-website-id=d763c4f2-f871-400b-aeca-d986c4af73c2 data-project-name="Apache Dubbo" data-project-color=#E8442E data-button-text="Ask AI" data-search-mode-enabled=true data-modal-open-on-command-k=true data-modal-disclaimer="The AI supports multiple languages, but it may not be accessible in China due to recaptcha, a proxy is required." data-project-logo=https://pbs.twimg.com/profile_images/1011849068283191302/FJbH5vbF_400x400.jpg data-modal-example-questions="What is Apache Dubbo?,How to run Apache Dubbo?" data-button-position-top data-button-position-right=20px data-button-position-bottom=200px data-button-position-left></script><script>(function(e,t,n,s){e[s]=e[s]||[];var a=t.getElementsByTagName(n)[0],i=t.createElement(n);i.async=!0,i.id="beacon-aplus",i.setAttribute("exparams","userid=&aplus&sidx=aplusSidex&ckx=aplusCkx"),i.src="//g.alicdn.com/alilog/mlog/aplus_v2.js",i.crossorigin="anonymous",a.parentNode.insertBefore(i,a)})(window,document,"script","aplus_queue"),function(e){var t=e.createElement("script");t.type="text/javascript",t.async=!0,t.src="//g.alicdn.com/aes/??tracker/3.3.4/index.js,tracker-plugin-pv/3.0.5/index.js,tracker-plugin-event/3.0.0/index.js,tracker-plugin-autolog/3.0.3/index.js,tracker-plugin-survey/3.0.3/index.js,tracker-plugin-jserror/3.0.3/index.js,tracker-plugin-resourceError/3.0.3/index.js",t.onload=function(){window.AES_CONFIG=window.AES_CONFIG||{env:"prod"},window.aes=new AES({pid:"zN245h",user_type:6}),window.AESPluginAutologConfig={exposure:"auto"},window.AEMPluginInstances=[aes.use(AESPluginPV,window.AESPluginPVConfig||{enableHistory:!0}),aes.use(AESPluginEvent,window.AESPluginEventConfig||{}),aes.use(AESPluginSurvey,window.AESPluginEventConfig||{}),aes.use(AESPluginAutolog,window.AESPluginAutologConfig||{}),aes.use(AESPluginJSError,window.AESPluginJSError||{}),aes.use(AESPluginResourceError,window.AESPluginResourceError||{})]},setTimeout(function(){e.getElementsByTagName("body")[0].appendChild(t)},800)}(document)</script></body></html>