3分钟带你了解：轻量级依赖注入框架Google Guice【享学Java】

野性酷女 2023-07-18 09:13 58阅读 0赞

> 程序必须是为了给人看而写，给机器去执行只是附带任务。

### 目录 ###

*   *  前言
     *  正文
     *   *  轻量级是什么意思？
         *  Google Guice
         *   *  公用基础代码
             *   *  如何保证单例？
             *  绑定
             *  注入
             *  Module之间的关系
         *  @ImplementedBy 与 @ProvidedBy
         *  Guice和Spring Boot整合
         *  Guice vs Spring
         *   *  优缺点
     *  总结
 *  关注A哥

## 前言 ##

说起依赖注入（DI），相信你首先想到的必然是`Spring`，Spring是Java技术全家桶，是Java EE开发的一站式解决方案和实际开发标准。但本文并不聊它，而是介绍一款谷歌开源的**轻量级**依赖注入框架：`Guice`。

`Guice`在Java领域并不流行（相较于Spring），但因为它轻量级，所以可以作为你去学习理解DI的一个抓手，适合你去进行独立的分析和理解依赖注入的思想，毕竟程序员经常说的：思想都是相通的。

另外，学习它还有一个重要原因是有些流行框架/库使用了它作为基础DI库，如：`Druid、Elastic Search、Play2`以及我们熟悉的携程开源的`Apollo`和Netflix的`Eureka`。

--------------------

## 正文 ##

正所谓谷歌出品，必属精品，况且`Guice`还出自于它的广告这种多金部门，自然也不例外。`Google Guice`被大量应用于谷歌内部，然后2010年开源出来。虽然业界反响并不大，但是因为它的轻量级，有些流行的开源框架（如`Druid、Apollo、Elastic Search、Play2`）把它作为基础的DI组件。

--------------------

### 轻量级是什么意思？ ###

轻量级是一个相对概念，它至少应该有如下特征：

1.  代码少
2.  易维护
3.  性能优异

`Google Guice`就是这么一个框架，它特别强调它的`Lightweight`特性。

--------------------

### Google Guice ###

`Google Guice`作为一个纯粹的DI框架，主要用于**减轻你对工厂的需求以及Java代码中对new的使用**。通过它来构建你的代码，能减少依赖，从而使得更容易更改以及更容易单元测试和重用。

下面我们就研究它的特性，然后辅以一定的代码示例对它展开基础学习。

--------------------

#### 公用基础代码 ####

导包：

<dependency>
        <groupId>com.google.inject</groupId>
        <artifactId>guice</artifactId>
        <version>4.1.0</version>
    </dependency>
    <dependency>
        <groupId>com.google.inject.extensions</groupId>
        <artifactId>guice-multibindings</artifactId>
        <version>4.1.0</version>
    </dependency>

基础代码：

public interface Animal { 
        void run();
    }
    
    public class Dog implements Animal { 
        @Override
        public void run() { 
            System.out.println("dog run...");
        }
    }
    
    public class Cat implements Animal { 
        @Override
        public void run() { 
            System.out.println("run run...");
        }
    }

DI配置类（模块）：

public class MainModule extends AbstractModule { 
        @Override
        protected void configure() { 
            bind(Animal.class).to(Dog.class);
        }
    }

测试类：

public class TestGuice { 
        @Inject
        private Animal animal;
    	
    	 官方推荐使用构造器注入，但本类是测试类，为了方便就使用属性注入喽
    	 当然喽，test类必须有空构造器~~~~这就另说了
    	//@Inject
    	//public TestGuice(Animal animal){ 
    	// this.animal = animal;
    	//}
        
        @Test
        public void fun1(){ 
            Injector injector = Guice.createInjector(new MainModule());
            // 为当前实例注入容器内的对象
            injector.injectMembers(this);
    
            System.out.println(animal);
            System.out.println(injector.getInstance(Animal.class));
            System.out.println(injector.getInstance(Animal.class));
            animal.run();
        }
    }

运行程序，控制台打印：

com.yourbatman.eurekaclient.guice.Dog@6fb0d3ed
    com.yourbatman.eurekaclient.guice.Dog@24b1d79b
    com.yourbatman.eurekaclient.guice.Dog@68ceda24
    dog run...

这便是一个最简单的使用Guice来实现依赖注入的示例，和Spring的`ApplicationContext`还蛮像的有木有。针对此实例的输出，你应该也意识到此处一个非常非常不一样的不同：**默认是多例的（每次get/注入的都是不同的实例）**。

--------------------

##### 如何保证单例？ #####

不同于Spring，它默认是多例的，因此需要我们做一些事情来保证单例。

**1、使用`@Singleton`注解**

@Singleton
    public class Dog implements Animal {  ... }

说明：该注解只能标注在实现类上，不能标注在接口/抽象类上

**2、绑定时指定单例**

bind(Animal.class).to(Dog.class).in(Singleton.class);

**3、绑定一个现存的实例**

bind(Animal.class).toInstance(new Dog());

以上三种方式处理后，使用依赖注入或者用API `injector.getInstance()`得到的均会是同一个实例对象，这就是单例了。

--------------------

#### 绑定 ####

任何需要依赖注入的资源，只有先实现了绑定才能注入，本处开始介绍它的绑定方式。

*  类名绑定：把实现类绑定到接口（当然也可以实现类绑到实现类），具体实例交给框架去帮你创建

bind(Animal.class).to(Dog.class);

*  实例绑定：绑定一个现有实例

bind(Animal.class).toInstance(new Dog())

> 注意：采用这种绑定，依赖注入时永远是单例（也就是这个实例）

*  连接绑定：对于已经绑定了的关系，可以无限一直连接下去

bind(Animal.class).to(Dog.class);
    bind(Dog.class).toInstance(new Dog(){ 
        @Override
        public void run() { 
            System.out.println("son dog");
            super.run();
        }
    });

*  `Provider`绑定：类似于Spring的@Bean注解，适合完成需要编程逻辑完成的实例

见基础代码，略。

*  泛型绑定：支持泛型类型的绑定。借助`TypeLiteral`来完成

bind(new TypeLiteral<List<Animal>>(){ }).toInstance(Arrays.asList(new Dog(),new Cat()));

*  集合绑定：可在不同的Module内向同一个集合分别去绑定自己所要支持的内容，当然喽也可以在同一个Module内

Multibinder<Animal> multibinder = Multibinder.newSetBinder(binder(), Animal.class);
    multibinder.addBinding().toInstance(new Dog());
    multibinder.addBinding().toInstance(new Cat());

> 说明：依赖于扩展包`guice-multibindings`，需要导入这个jar才行

--------------------

#### 注入 ####

常用的注入方式有多种。

*  简单的单一注入（接口的实现仅有一个类型）

如示例代码

*  `Provider`注入（具有延迟效果）

@Inject
    private Provider<Animal> animal;

对于`Provider`方式，配置的方式也可这样来提供（类似于`@Bean`）：

// 方法上是可以有入参的。但入参请确保已经是容器内的对象
    @Provides // 作用类似于@Bean
    @Singleton // 若这里不使用该注解，那就是多例，每次都会执行此方法
    private Animal getAnimal(){ 
        return new Dog();
    }

需要注意的是，若使用了@Provides方式配置了实例，那么向`bind(Animal.class).toInstance(new Dog())`这句话就不能再要了，否则就是重复绑定，启动时会抛错：

A binding to com.yourbatman.eurekaclient.guice.Animal was already configured at com.yourbatman.eurekaclient.guice.MainModule.configure(MainModule.java:11).
      at com.yourbatman.eurekaclient.guice.MainModule.getAnimal(MainModule.java:7)
      ...

*  命名注入：用于对同一接口多个实现类做区分注入

bind(Animal.class).annotatedWith(DogAnno.class).to(Dog.class);
    bind(Animal.class).annotatedWith(CatAnno.class).to(Cat.class);
    
    @Inject
    @DogAnno
    private Animal animal;

除了自定义注解，你还可以使用Guice自带的命令类：`Names.named("dog")`（它返丝线了注解接口，所以返回值是个注解类型）。

--------------------

#### Module之间的关系 ####

创建一个`Injector`可以使用多个任意多个`Module`，因此需要明确它们的关系。

*  并列：默认顺序传递就是此关系

Guice.createInjector(new MainModule(), .......);

*  嵌套：大的Module可以嵌套任意多个子Module

public class ServerModule extends AbstractModule { 
        @Override
        protected void configure() { 
            install(new MainModule());
        }
    }

*  覆盖：如果有冲突的话后者覆盖前者，没有的话就都生效

// 用后者覆盖前者
    Module finalModule = Modules.override(new MainModule()).with(new ServerModule());

--------------------

### @ImplementedBy 与 @ProvidedBy ###

单独介绍这两个注解，它是Guice提供的标注在类上的注解，用于简化绑定，他俩可以标注在接口上。

*  `@ImplementedB`：注解用于**简化绑定配置**，通常用于指定**默认的**实现类型。最常用的场景在于编写 Dao 或者 Service 时，指定 Interface 的实现类。
 *  `@ProvidedBy`：作用同上，只不过是通过Provider方式来提供

@ImplementedBy(Dog.class)
    // @Singleton // 不能标记在接口上，只能标记在Dog实现类上
    public interface Animal { 
        void run();
    }
    
    @Test
    public void fun1() { 
    	// 注意：并不需要使用使用模块，注解就行哦~~
        Injector injector = Guice.createInjector();
        injector.injectMembers(this);
    
        System.out.println(animal);
        System.out.println(injector.getInstance(Animal.class));
        System.out.println(injector.getInstance(Animal.class));
        animal.run();
    }

这样标注后效果完全同：

bind(Animal.class).to(Dog.class)

`@ProvidedBy`就不用演示了，它的效果同：

bind(Animal.class).toProvider(DogProvider.class)

--------------------

### Guice和Spring Boot整合 ###

作为主流的微服务开发框架`Spring Boot`，可以说`Guice`不可能撼动Spring的江湖地位，其实它也无意去撼动它，乖乖的专心做自己的DI就好。

那么如果一个开源的库是用`Guice`构建的，而你想在Spring Boot环境下使用肿么办呢？？？那就是整合。他俩并发冲突，反而也可以一起协作，总的思想有点类似于`Spring MVC`和`Spring`的协作：`MVC`负责请求控制，而Spring负载从当IoC容器，负责DI依赖注入。

当然喽，他俩的集成做不到那么的浑然天成， 思考的思路是：向`Spring Boot`容器内注入的业务Bean请不要new，请不要new，请不要new，而是通过`injector.getInstance(xxx)`从Guice里拿，这样便完成了整合。总之就是各自做各自的事，然后通过某个“接口”来完成融合即可，比如这里用Spring Boot总控（其实就是MVC），然后Guice负责管理**业务对象**之间的依赖关系（如Service、Dao等）。

另外，在web下使用/整合`Guice`，一般需要导入下面Jar包给与支持：

<dependency>
        <groupId>com.google.inject.extensions</groupId>
        <artifactId>guice-servlet</artifactId>
        <version>4.1.0</version>
    </dependency>

Tips：整合过程中，请一定一定一定要注意对象的生命周期以及**Scope**（Spring Boot一般要单例，而Guice需要做特殊的满足哦~~~）

--------------------

### Guice vs Spring ###

虽然这两者没有太大的可比性，但由于都是DI框架，所以做一个简单的比较吧。

*  Spring不仅仅是DI，它是一个全家桶技术总和；Guice是个轻量级的DI框架，只聚焦于依赖的管理、注入
 *  Spring的配置文件（xml or Confiuration以及扫描的）体现了完整的装配结构；`Guice`使用Java代码来描述绑定关系
 *  Spring使用字符串来表示Bean的key；Guice一般使用类型绑定关系来描述一个实例，且是分模块的、局部的
 *  Spring在容器初始化时候完成所有关系的绑定；Guice只记录绑定关系，然后在运行时有需要的时候帮你完成注入

--------------------

#### 优缺点 ####

Spring 的优缺点此处不做说明，主要描述`Guice`它的DI领域的优缺点。

*  **优点**
    
     *  轻量级（代码量少）
     *  性能优异
     *  良好的泛型支持
     *  因为都用Java语言绑定，所以是强类型的，不容易出错
     *  易于重构Refactor（也得益于是Java代码的强类型）
 *  **缺点**
    
     *  学习成本颇高，学习曲线相对陡峭
     *  `Module`的众多绑定规则不太容易理解，导致出错了不易排查
     *  教程少，文档少，中文文档、案例就更少了
     *  社区活跃度无法同Spring相提并论
     *  无法解决循环依赖注入的问题
        
         *  此问题官方认为不是问题，因为官方建议你通过别的方式避免循环依赖（说明：Spring是解决了循环依赖注入问题的）
     *  编译器支持相对差些（比如它的Guice的AOP不能方便的跳转）

总之，Spring大而全，Guice小而美。企业级应用当然还是推荐使用Spring，而如果你是自己写写组件，不妨用`Guice`去管理的依赖吧，它能让你的代码结构更加优美且显得不那么臃肿。

> 当然，理想归理想，说去真心话国内的Java技术毕竟还是阿里这种大厂主导，而非Google系，因此实际生产中若你要使用请三思而后行，毕竟你还有同伴~

--------------------

## 总结 ##

关于轻量级依赖注入框架Google Guice就先介绍到这了，相信通过本文的学习，你只需要花几分钟的时间就能了解到`Guice`的几乎全貌了。

我个人意见，此门DI技术不用深究，但却有必要了解，因为文首说了有些流行的开源框架是基于它构建的，所以了解`Guice`才能更好的阅读学习其源码。

--------------------

# 关注A哥 #

<table> 
 <thead> 
  <tr> 
   <th>Author</th> 
   <th><a href="https://www.yourbatman.cn/about" rel="nofollow">A哥(YourBatman)</a></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>个人站点</td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow">www.yourbatman.cn</a></td> 
  </tr> 
  <tr> 
   <td>E-mail</td> 
   <td>yourbatman@qq.com</td> 
  </tr> 
  <tr> 
   <td><strong>微 信</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat.png" rel="nofollow">fsx641385712</a></td> 
  </tr> 
  <tr> 
   <td><strong><code>活跃平台</code></strong></td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow"><img src="https://img-blog.csdnimg.cn/2020071015182276.png" alt=""></a> <a href="https://fangshixiang.blog.csdn.net/" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151913394.png" alt=""></a><a href="https://yourbatman.cnblogs.com" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151929355.png" alt=""></a><a href="https://juejin.im/user/5b44d178f265da0fa1220efe/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151938937.png" alt=""></a><a href="https://www.zhihu.com/people/fangshixiang/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151950629.png" alt=""></a><a href="https://www.jianshu.com/u/8740f1fdd684" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152000530.png" alt=""></a><a href="https://segmentfault.com/u/yourbatman/articles" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152008726.png" alt=""></a><a href="https://github.com/yourbatman" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152015895.png" alt=""></a></td> 
  </tr> 
  <tr> 
   <td><strong>公众号</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat_channel.jpg" rel="nofollow">BAT的乌托邦（ID：BAT-utopia）</a></td> 
  </tr> 
  <tr> 
   <td>知识星球</td> 
   <td><a href="https://t.zsxq.com/nQBi66I" rel="nofollow">BAT的乌托邦</a></td> 
  </tr> 
  <tr> 
   <td>每日文章推荐</td> 
   <td><a href="https://github.com/yourbatman/reading/issues" rel="nofollow">每日文章推荐</a></td> 
  </tr> 
 </tbody> 
</table>

![BAT的乌托邦][BAT]

![往期精选][20200211101926949.gif_pic_center]

*  [\[享学Eureka\] 一、源生Eureka介绍 — 基于注册中心的服务发现][Eureka_ _Eureka_ _]
 *  [\[享学Eureka\] 二、Eureka的最核心概念：InstanceInfo实例信息][Eureka_ _Eureka_InstanceInfo]
 *  [\[享学Eureka\] 三、Eureka配置之：EurekaInstanceConfig实例配置][Eureka_ _Eureka_EurekaInstanceConfig]
 *  [\[享学Eureka\] 四、Eureka配置之：EurekaClientConfig客户端配置][Eureka_ _Eureka_EurekaClientConfig]
 *  [\[享学Eureka\] 五、Eureka核心概念：应用(Application)和注册表(Applications)][Eureka_ _Eureka_Application_Applications]
 *  [\[享学Eureka\] 六、InstanceInfo实例管理器：ApplicationInfoManager][Eureka_ _InstanceInfo_ApplicationInfoManager]
 *  [\[享学Eureka\] 七、远程通信模块：EurekaHttpClient接口抽象以及基于Jersey的Low-Level实现JerseyApplicationClient][Eureka_ _EurekaHttpClient_Jersey_Low-Level_JerseyApplicationClient]
 *  [\[享学Eureka\] 八、远程通信模块：手动构建JerseyApplicationClient客户端完成服务注册、服务下线…][Eureka_ _JerseyApplicationClient]
 *  [\[享学Eureka\] 九、远程通信模块：使用TransportClientFactory构建底层请求客户端完成服务注册、服务下线][Eureka_ _TransportClientFactory]
 *  [\[享学Eureka\] 十、迷人小工具之TimedSupervisorTask：自动调节执行间隔的周期性任务][Eureka_ _TimedSupervisorTask]
 *  [\[享学Eureka\] 十一、迷人小工具之EndpointUtils：从配置文件中解析出serviceUrl（非常重要）][Eureka_ _EndpointUtils_serviceUrl]
 *  [\[享学Eureka\] 十二、远程通信模块：集群解析器ClusterResolver(一) ConfigClusterResolver][Eureka_ _ClusterResolver_ ConfigClusterResolver]
 *  [\[享学Eureka\] 十三、集群解析器ClusterResolver(二)：ApplicationsResolver和EurekaHttpResolver][Eureka_ _ClusterResolver_ApplicationsResolver_EurekaHttpResolver]
 *  [\[享学Eureka\] 十四、集群解析器ClusterResolver(三)：ZoneAffinityClusterResolver区域感知解析器][Eureka_ _ClusterResolver_ZoneAffinityClusterResolver]
 *  [\[享学Eureka\] 十五、集群解析器ClusterResolver(四)：AsyncResolver异步解析器][Eureka_ _ClusterResolver_AsyncResolver]
 *  [\[享学Eureka\] 十六、远程通信模块：Top Level部分之EurekaHttpClientFactory和SessionedEurekaHttpClient][Eureka_ _Top Level_EurekaHttpClientFactory_SessionedEurekaHttpClient]
 *  [\[享学Eureka\] 十七、远程通信模块：RetryableEurekaHttpClient高可用Client端的重试机制][Eureka_ _RetryableEurekaHttpClient_Client]
 *  [\[享学Eureka\] 十八、远程通信模块：结合代码示例详解transport.retryableClientQuarantineRefreshPercentage配置项][Eureka_ _transport.retryableClientQuarantineRefreshPercentage]
 *  [\[享学Eureka\] 十九、远程通信模块：EurekaHttpClients工具快速构建ClusterResolver集群解析器][Eureka_ _EurekaHttpClients_ClusterResolver]
 *  [\[享学Eureka\] 二十、远程通信模块：EurekaHttpClients工具快速构建EurekaHttpClient请求客户端][Eureka_ _EurekaHttpClients_EurekaHttpClient]
 *  [\[享学Eureka\] 二十一、LookupService服务发现之客户端实现：EurekaClient接口][Eureka_ _LookupService_EurekaClient]
 *  [\[享学Eureka\] 二十二、DiscoveryClient服务注册的小工具：InstanceInfoReplicator][Eureka_ _DiscoveryClient_InstanceInfoReplicator]
 *  [\[享学Eureka\] 二十三、DiscoveryClient前置知识：BackupRegistry备用注册中心、HealthCheckHandler健康检查处理器…][Eureka_ _DiscoveryClient_BackupRegistry_HealthCheckHandler]
 *  [\[享学Eureka\] 二十四、DiscoveryClient透彻解析(一)：功能概述 + 成员属性详解][Eureka_ _DiscoveryClient_ _]
 *  [\[享学Eureka\] 二十五、DiscoveryClient透彻解析(二)：初始化逻辑详解][Eureka_ _DiscoveryClient]
 *  [\[享学Eureka\] 二十六、DiscoveryClient透彻解析(三)：全量获取注册表][Eureka_ _DiscoveryClient 1]
 *  [\[享学Eureka\] 二十七、DiscoveryClient透彻解析(四)：增量获取注册表][Eureka_ _DiscoveryClient 2]
 *  [\[享学Eureka\] 二十八、DiscoveryClient透彻解析(五)：HeartbeatThread和CacheRefreshThread][Eureka_ _DiscoveryClient_HeartbeatThread_CacheRefreshThread]
 *  [\[享学Eureka\] 二十九、DiscoveryClient透彻解析(六)：fetchRegistry() 拉取注册表信息][Eureka_ _DiscoveryClient_fetchRegistry_]
 *  [\[享学Eureka\] 三十、DiscoveryClient透彻解析(七)：initScheduledTasks() 初始化调度任务][Eureka_ _DiscoveryClient_initScheduledTasks_]
 *  [\[享学Eureka\] 三十一、DiscoveryClient透彻解析(八)：接口方法和shutdown()方法详解][Eureka_ _DiscoveryClient_shutdown]
 *  [\[享学Eureka\] 三十二、Eureka内置公用小工具：基于令牌桶算法的RateLimiter限流器][Eureka_ _Eureka_RateLimiter]
 *  [\[享学Eureka\] 三十三、Eureka内置公用小工具：StringCache及详解String\#intern()][Eureka_ _Eureka_StringCache_String_intern]
 *  [\[享学Eureka\] 三十四、借助Guice的DI依赖管理，轻松实现一键启动Eureka Client端完成服务注册][Eureka_ _Guice_DI_Eureka Client]

[BAT]: /images/20230528/0a19712a5f90414980ffd7a87a6230f3.png
[20200211101926949.gif_pic_center]: /images/20230528/d51a225b4a6141bca4edb1fc28819df1.png
[Eureka_ _Eureka_ _]: https://fangshixiang.blog.csdn.net/article/details/105043241
[Eureka_ _Eureka_InstanceInfo]: https://blog.csdn.net/f641385712/article/details/105090695
[Eureka_ _Eureka_EurekaInstanceConfig]: https://blog.csdn.net/f641385712/article/details/105078864
[Eureka_ _Eureka_EurekaClientConfig]: https://blog.csdn.net/f641385712/article/details/105128652
[Eureka_ _Eureka_Application_Applications]: https://blog.csdn.net/f641385712/article/details/105142519
[Eureka_ _InstanceInfo_ApplicationInfoManager]: https://fangshixiang.blog.csdn.net/article/details/105150793
[Eureka_ _EurekaHttpClient_Jersey_Low-Level_JerseyApplicationClient]: https://fangshixiang.blog.csdn.net/article/details/105153918
[Eureka_ _JerseyApplicationClient]: https://fangshixiang.blog.csdn.net/article/details/105170447
[Eureka_ _TransportClientFactory]: https://blog.csdn.net/f641385712/article/details/105156957
[Eureka_ _TimedSupervisorTask]: https://blog.csdn.net/f641385712/article/details/105258678
[Eureka_ _EndpointUtils_serviceUrl]: https://blog.csdn.net/f641385712/article/details/105280511
[Eureka_ _ClusterResolver_ ConfigClusterResolver]: https://fangshixiang.blog.csdn.net/article/details/105281884
[Eureka_ _ClusterResolver_ApplicationsResolver_EurekaHttpResolver]: https://fangshixiang.blog.csdn.net/article/details/105181641
[Eureka_ _ClusterResolver_ZoneAffinityClusterResolver]: https://fangshixiang.blog.csdn.net/article/details/105293790
[Eureka_ _ClusterResolver_AsyncResolver]: https://fangshixiang.blog.csdn.net/article/details/105301994
[Eureka_ _Top Level_EurekaHttpClientFactory_SessionedEurekaHttpClient]: https://fangshixiang.blog.csdn.net/article/details/105180872
[Eureka_ _RetryableEurekaHttpClient_Client]: https://fangshixiang.blog.csdn.net/article/details/105322307
[Eureka_ _transport.retryableClientQuarantineRefreshPercentage]: https://fangshixiang.blog.csdn.net/article/details/105328717
[Eureka_ _EurekaHttpClients_ClusterResolver]: https://fangshixiang.blog.csdn.net/article/details/105344569
[Eureka_ _EurekaHttpClients_EurekaHttpClient]: https://fangshixiang.blog.csdn.net/article/details/105312284
[Eureka_ _LookupService_EurekaClient]: https://fangshixiang.blog.csdn.net/article/details/105354450
[Eureka_ _DiscoveryClient_InstanceInfoReplicator]: https://fangshixiang.blog.csdn.net/article/details/105369622
[Eureka_ _DiscoveryClient_BackupRegistry_HealthCheckHandler]: https://fangshixiang.blog.csdn.net/article/details/105364035
[Eureka_ _DiscoveryClient_ _]: https://fangshixiang.blog.csdn.net/article/details/105354325
[Eureka_ _DiscoveryClient]: https://fangshixiang.blog.csdn.net/article/details/105374718
[Eureka_ _DiscoveryClient 1]: https://fangshixiang.blog.csdn.net/article/details/105459120
[Eureka_ _DiscoveryClient 2]: https://fangshixiang.blog.csdn.net/article/details/105461627
[Eureka_ _DiscoveryClient_HeartbeatThread_CacheRefreshThread]: https://fangshixiang.blog.csdn.net/article/details/105464173
[Eureka_ _DiscoveryClient_fetchRegistry_]: https://fangshixiang.blog.csdn.net/article/details/105416402
[Eureka_ _DiscoveryClient_initScheduledTasks_]: https://fangshixiang.blog.csdn.net/article/details/105470593
[Eureka_ _DiscoveryClient_shutdown]: https://fangshixiang.blog.csdn.net/article/details/105471991
[Eureka_ _Eureka_RateLimiter]: https://fangshixiang.blog.csdn.net/article/details/105480906
[Eureka_ _Eureka_StringCache_String_intern]: https://fangshixiang.blog.csdn.net/article/details/105503957
[Eureka_ _Guice_DI_Eureka Client]: https://blog.csdn.net/f641385712/article/details/105310790