Java高级开发高频面试题(九)

🍊 Spring容器启动流程

Spring容器的启动流程主要分为以下几个步骤：

1. 加载配置文件：Spring容器会从指定的配置文件中读取配置信息，包括bean的定义、依赖关系、AOP切面等。
   
2. 创建容器：Spring容器启动后会创建一个容器实例，容器负责管理bean的生命周期和依赖关系。
   
3. 扫描包并创建bean定义：Spring容器会扫描指定的包路径，自动创建包中标注了@Component、@Service、@Controller、@Repository等注解的类的bean定义。
   
4. 解析依赖关系：Spring容器会根据bean定义中的依赖关系，自动将依赖的bean注入到需要的bean中。
   
5. 初始化bean：容器会按照指定的顺序依次对bean进行初始化，包括实例化、属性注入、初始化方法执行等。
   
6. 设置代理对象：如果bean需要被AOP切面增强，则容器会为其创建代理对象。
   
7. 完成容器初始化：所有bean初始化完成后，Spring容器启动完成。
   

在实际开发中，Spring容器的启动可以通过多种方式来实现，包括XML配置和注解配置等。其中XML配置主要通过applicationContext.xml文件来实现，这个配置文件中，告诉Spring容器要创建的bean的名称和类名，这样就可以在Spring容器中实例化这个类，并将其作为一个bean注册到Spring容器中。

除了XML配置之外，注解配置也是一种很常见的配置方式。在Java代码中，我们可以通过在类、字段、方法上添加一些特定的注解来告诉Spring容器如何创建和管理Bean对象。常见的注解包括@Component、@Service、@Controller、@Repository等。

启动Spring容器，首先需要创建一个ApplicationContext对象。这个对象是Spring框架的核心，负责管理所有的Bean对象，以及解决它们之间的依赖关系。ApplicationContext对象可以通过多种方式来创建。一般情况下，我们可以通过ClassPathXmlApplicationContext或AnnotationConfigApplicationContext类来创建一个ApplicationContext对象。其中ClassPathXmlApplicationContext类用于XML配置文件，AnnotationConfigApplicationContext用于注解配置。

一旦配置文件准备好了，就可以开始启动Spring容器了。为了启动容器，需要使用ApplicationContext接口的一个实现类。在这个实现类中，有一个非常重要的方法叫做refresh()，它会触发Spring框架开始加载和初始化所有的Bean对象。

refresh()方法是Spring框架启动过程中的核心方法。首先，refresh()方法会创建一个BeanFactory，这个BeanFactory是一个Bean工厂，是Spring框架中提供的一种对象创建和管理机制。BeanFactory会读取配置文件，通过反射机制实例化对应的Bean，然后将Bean注册到容器中。

接下来，refresh()方法会启动各种后置处理器PostProcessor，后置处理器是一种回调函数，它可以在Bean实例化、初始化之前或之后进行操作，比如修改Bean属性、替换Bean对象等。Spring框架中有很多内置的后置处理器。

比如AutowiredAnnotationBeanPostProcessor用于处理@Autowired和@Inject注解。它会在bean实例化后递归的处理bean的属性，并根据属性上的注解来自动装配依赖。

CommonAnnotationBeanPostProcessor用于处理JSR-250规范的注解，包括@Resource、@PostConstruct和@PreDestroy。

InitDestroyAnnotationBeanPostProcessor用于处理@PostConstruct和@PreDestroy注解，它会在bean的初始化和销毁阶段对相应的方法进行回调。

在执行了后置处理器之后，refresh()方法会执行BeanFactory的预实例化单例Bean，这个过程会通过调用getBean()方法来获取Bean实例。在这个过程中，如果Bean实现了InitializingBean接口，那么Spring容器会调用它的afterPropertiesSet()方法来完成Bean的初始化。如果Bean配置了init-method，那么Spring容器也会调用它指定的初始化方法。

最后，refresh()方法会发布上下文事件，这些事件会被注册到各种事件监听器中，用于监控和管理容器生命周期中的各个阶段。Spring框架中有很多内置的事件，这些事件可以在Spring应用程序上下文中定义的Bean中使用，以便在特定生命周期事件发生时执行特定的代码。例如，可以使用这些事件来处理数据源连接、缓存清除、应用程序状态检查等应用程序行为。

比如ContextRefreshedEvent：当ApplicationContext被初始化或刷新时，该事件被发布。该事件适用于需要在启动时执行某些操作的应用程序。

ContextStartedEvent：该事件表示ApplicationContext已启动，用于在应用程序启动后执行某些操作，例如在spring boot应用程序中启动一个后台线程。

ContextStoppedEvent：当ApplicationContext停止时，该事件被发布。该事件适用于在应用程序停止时执行某些清理操作的应用程序。

ContextClosedEvent：当ApplicationContext关闭时，该事件被发布。该事件适用于在应用程序关闭时执行某些清理操作的应用程序。

🍊 Spring事务及传播机制底层原理

Spring事务的实现原理就是通过拦截@Transactional注解标识的方法，使用事务增强器对这些方法进行事务管理。其中关键的是事务管理器和事务属性源的配置和使用。

Spring事务管理是基于AOP的，使用了代理模式和注解的方式来统一管理和控制业务方法的事务，使用了JDBC或Hibernate等ORM框架提供的事务支持。Spring 中事务处理的本质是对数据访问层（Data Access Layer，DAL）实现事务管理。

在开启事务的方法前，Spring通过动态代理为该方法生成一个代理对象，代理对象在调用方法之前会开启一个事务，在方法执行结束后，代理对象会根据方法的执行结果提交或回滚事务。在代理对象的实现中，Spring使用了TransactionSynchronizationManager类来维护和控制事务的状态和传播行为。

TransactionSynchronizationManager维护了一个ThreadLocal变量来保存当前事务的状态，包括当前事务是否已开启、当前事务的传播行为等信息。在多个事务方法相互调用时，Spring会根据事务方法的传播行为来判断是否开启新的事务，以及如何协调各个事务方法之间的事务管理。

Spring事务的实现原理可以简单理解为以下几个步骤：

1. 从配置文件中获取PlatformTransactionManager，这个事务管理器是管理事务的关键。
   
2. 创建TransactionAttributeSource，用来获取方法上定义的事务属性，如事务传播特性、事务隔离级别等。
   
3. 创建TransactionAdvisor，这个切面用来指定事务增强器的增强器和切入点，从而实现对@Transactional注解的拦截和增强。
   
4. 启用事务注解，通过tx:annotation-driven/标签启用事务注解，并指定事务管理器和事务属性源。这样就可以在代码中使用@Transactional注解来管理事务了。
   

1.从配置文件中获取PlatformTransactionManager

在配置文件中，我们可以使用tx:annotation-driven/标签来启用事务注解，这样就可以在代码中使用@Transactional注解来管理事务了。这个标签会自动为我们创建一个TransactionInterceptor，这个拦截器负责拦截@Transactional注解标识的方法，并对这些方法进行事务管理。

在TransactionInterceptor中，我们需要注入PlatformTransactionManager，这个事务管理器是事务实现的关键。在TransactionInterceptor中，会有一个initPlatformTransactionManager()方法，这个方法用来从配置文件中获取PlatformTransactionManager。通常我们会将DataSourceTransactionManager配置为默认的事务管理器，这个管理器可以管理单个数据源的事务。

2.创建TransactionAttributeSource

在Spring中，事务增强器负责事务的具体管理和控制，其中核心的实现是TransactionAttributeSource接口和TransactionInterceptor类。TransactionAttributeSource接口用来获取方法上定义的事务属性，而TransactionInterceptor则负责事务属性的解析和管理。

在TransactionInterceptor中，我们需要注入TransactionAttributeSource，这个事务属性源用来获取方法上定义的事务属性，如事务传播特性、事务隔离级别等。

在TransactionAttributeSource中，我们需要实现getTransactionAttribute方法，这个方法负责获取指定方法上的事务属性。通常我们会使用AnnotationTransactionAttributeSource来实现这个接口。

3.创建TransactionAdvisor

在Spring中，我们需要创建一个TransactionAdvisor，这个切面用来指定事务增强器的增强器和切入点。TransactionAdvisor会在Spring的AOP框架中注册，从而实现对@Transactional注解的拦截和增强。

在TransactionAdvisor中，我们需要注入TransactionInterceptor和Pointcut，这个切点用来指定需要拦截的方法。

4.启用事务注解

在Spring中，我们可以通过tx:annotation-driven/标签来启用事务注解。这个标签会为我们创建一个TransactionInterceptor，并自动配置TransactionAdvisor，从而实现了事务注解的管理和控制。同时，也需要注意在配置文件中指定事务管理器和事务属性源。

🍊 Spring传播机制底层原理

Spring支持以下7种事务传播行为：

1. PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；否则新建事务，并在方法执行结束后提交事务。
2. PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；否则不开启事务。
3. PROPAGATION_MANDATORY：如果当前存在事务，则加入该事务；否则抛出异常。
4. PROPAGATION_REQUIRES_NEW：不管当前是否存在事务，都新建一个事务，并在方法执行结束后提交事务。
5. PROPAGATION_NOT_SUPPORTED：不管当前是否存在事务，都不开启事务。
6. PROPAGATION_NEVER：如果当前存在事务，则抛出异常；否则不开启事务。
7. PROPAGATION_NESTED：如果当前存在事务，则在已有事务中嵌套一个事务；否则新建事务，并在方法执行结束后提交事务。

Spring的事务传播机制的实现原理：

在Spring框架内部，事务的传播机制是通过ThreadLocal对象来实现的。ThreadLocal是一个线程本地变量，它可以在当前线程中存储某个值，并且这个值可以被当前线程的任何方法所共享和修改。在Spring中，我们可以通过TransactionSynchronizationManager类来管理ThreadLocal变量。

在Spring中，开启事务的方法通常被称为事务模板方法。事务模板方法负责创建事务，并且将当前线程的状态保存在ThreadLocal变量中。在执行业务方法前，Spring事务管理器会检查当前线程的状态，如果当前线程已经存在事务，则直接使用该事务；否则创建一个新事务。

在Spring中，每个事务方法都是由一个或多个拦截器组成的。事务拦截器负责拦截业务方法执行前后的各种事件，并且在恰当的时候执行提交或回滚事务等操作。在Spring中，我们可以通过TransactionInterceptor类来实现事务拦截器。

在Spring的事务传播机制中，每个事务方法都是独立的，它们的事务行为是相互独立的。在事务方法内部调用其他事务方法时，Spring会根据所设置的传播行为来决定是否开启新事务，或者将当前事务合并到已有事务中。

Spring的事务传播机制是基于AOP实现的，它首先在调用业务方法之前，开启事务，并将事务状态保存在ThreadLocal变量中；然后执行业务方法；最后在业务方法执行结束后，根据事务状态来决定是提交还是回滚事务。

Spring的事务管理API主要包括以下三个接口：

PlatformTransactionManager是事务管理器的顶层接口，它定义了使用事务的基本方法，如开启、提交、回滚、暂停、恢复等。所有的事务管理器都需要实现PlatformTransactionManager接口。

TransactionDefinition是事务定义接口，它定义了一个事务的属性，如事务的隔离级别、传播行为、超时时间和只读属性等。所有的事务管理器必须支持TransactionDefinition接口的所有属性。

TransactionStatus是事务状态接口，它定义了事务的当前状态，例如是否已经开始、是否已经提交、是否已经回滚等。所有的事务管理器必须支持TransactionStatus接口的所有状态。

Spring的事务传播机制的实现主要涉及以下几个核心类：

TransactionSynchronizationManager是Spring事务同步管理器，它负责处理同步回调和资源清理，以及管理线程本地变量资源。 在Spring的事务传播机制中，TransactionSynchronizationManager使用ThreadLocal来保存当前线程的事务状态和事务资源。

TransactionAspectSupport是Spring事务切面支持类，它是Spring事务传播机制的核心实现类。TransactionAspectSupport类继承自AspectJAfterAdvice类，实现了org.aopalliance.intercept.MethodInterceptor接口，它可以作为一个通用的事务拦截器来拦截任何一个Spring Bean中的方法调用，并根据所设置的传播行为来决定是否开启新事务，或者将当前事务合并到已有事务中。

AbstractPlatformTransactionManager是PlatformTransactionManager接口的抽象实现类，它提供了大部分的PlatformTransactionManager接口方法的默认实现，具体实现细节由其子类来完成。

AbstractTransactionStatus是TransactionStatus接口的抽象实现类，它提供了大部分的TransactionStatus接口方法的默认实现，具体实现细节由其子类来完成。

🍊 Spring IOC容器加载过程

Spring IoC容器的加载过程主要包括加载配置文件、解析和注册BeanDefinition、初始化BeanDefinition、加载Bean、填充Bean属性、初始化Bean和销毁Bean等步骤。

Spring IOC容器加载过程：

1. 配置文件读取：Spring IOC容器会读取XML配置文件，通过解析XML文件获取Bean定义信息。
   
2. Bean实例化：通过反射机制，根据Bean定义信息创建Bean实例。
   
3. Bean属性注入：通过反射机制，将定义在XML文件中的属性值设置给Bean对象。
   
4. Bean对象注册：将实例化后的Bean对象注册到Spring IOC容器中，以供后续使用。
   
5. Bean生命周期管理：Spring IOC容器会管理Bean对象的整个生命周期，包括Bean的创建、初始化和销毁。
   

🍊 Spring依赖注入

依赖注入是Spring IOC容器的核心功能之一。它的作用是将Bean之间的依赖关系交给Spring来管理，而不是由程序员手动管理。Spring IOC容器在创建Bean实例时，会自动将依赖的对象注入到Bean中。

依赖注入的方式有三种：

1. 构造函数注入：通过构造函数参数传递，将依赖的对象注入到Bean中。
   
2. Setter方法注入：通过Setter方法设置，将依赖的对象注入到Bean中。
   
3. 接口注入：通过实现接口，在接口中定义Setter方法，将依赖的对象注入到Bean中。
   

依赖注入的好处是可以降低代码的耦合度，提高代码的可维护性和可扩展性。

🍊 Spring的自动装配

Spring的自动装配是一种自动化的任务分配方式，它能够自动地将应用程序中的各个模块组合在一起，形成完整的应用程序。从面试者的角度来讲，可以从以下几个方面来详细说明Spring的自动装配：

1. 什么是Spring的自动装配？

Spring的自动装配是一种基于控制反转（IoC）和依赖注入（DI）的实现方式，它能够自动地将应用程序中的Bean装配到各个模块中。当注入的Bean类型匹配时，Spring会自动完成Bean的注入。

2. Spring自动装配的优势是什么？

Spring的自动装配能够极大地简化开发操作，减少了手动配置Bean的步骤，提高了开发效率。同时，它也能够消除重复代码，增强了模块之间的解耦性，使得应用程序更加易于维护和扩展。

3. Spring自动装配的方式有哪些？

Spring自动装配有三种方式：默认的基于名称的自动装配、基于类型的自动装配和基于注解的自动装配。

• 基于名称的自动装配：这种方式是默认的自动装配方式，Spring会自动将属性名与容器中定义的Bean名称进行匹配，如果匹配成功，则将Bean注入到属性中。
• 基于类型的自动装配：这种方式是根据类型来自动进行装配的，Spring会自动将属性的类型与容器中定义的Bean类型进行匹配，如果匹配成功，则将Bean注入到属性中。
• 基于注解的自动装配：这种方式是根据注解来进行自动装配的，通过在属性上使用@Autowired和@Qualifier注解，Spring会自动将符合条件的Bean注入到属性中。

4. Spring的自动装配可能会出现的问题有哪些？

Spring的自动装配虽然能够提高开发效率，但在实际开发中也可能会遇到一些问题，比如：

• 自动装配的Bean可能会出现多个候选者的情况；
• 自动装配可能会造成Bean之间的循环依赖问题；
• 自动装配可能会导致开发者对Bean的装配过程不够清晰，降低了代码的可读性。

5. Spring使用以下规则来决定需要自动装配的Bean
   默认情况下，Spring会尝试按照名称进行自动装配。这意味着Spring会查找与依赖属性名称相同的Bean名称，并将Bean自动注入到属性中。
   如果按照名称进行自动装配失败，Spring会尝试按照类型进行自动装配。这意味着Spring会查找与依赖属性类型相同的Bean，并将Bean自动注入到属性中。
   如果按照类型进行自动装配失败，Spring会尝试使用构造函数进行自动装配。这意味着Spring会查找与构造函数参数类型相同的Bean，并将Bean作为参数自动注入到构造函数中。
   

如果以上三种规则均无法完成自动装配，则Spring会抛出异常。

需要注意的是，Spring在进行自动装配时会优先使用已经被标记为Primary的Bean，如果没有找到Primary Bean，才会使用其他的进行自动装配。

总的来说，Spring的自动装配是一种方便而快捷的开发方式，可以大大提高开发效率，但在实际使用中还是需要谨慎使用，避免出现不必要的问题。

🍊 Spring6.0核心新特性

作为面试者，要讲清楚Spring6.0的核心新特性可以从以下几个方面展开：

1. Spring6.0于2021年9月发布，Spring 6.0的核心新特性包括：支持Java 17和Java 18、将应用程序编译成原生镜像以支持云原生环境、引入AOT编译基础、改进Spring Boot自动配置、更新Spring Data以支持最新持久性框架、更新Spring WebSocket以支持最新WebSocket协议、改进Spring Security以支持OAuth 2.0和最新安全标准，以及改进测试模块以支持JUnit 5和其他测试框架。此外，还提供了对最新Web容器和持久性框架的访问。
   
2. 强调Spring6.0在模块化和打包方面的改进。采用更细粒度的模块化设计，每个模块更加独立和可替换。同时引入新的包布局，使依赖关系更清晰，便于开发和维护。
   
3. 提及Spring6.0在性能方面的优化措施。减少内存占用、提高启动速度和运行效率，使应用程序能更好地处理高并发和大数据量的场景。
   
4. 强调Spring6.0与Project Reactor的集成，为响应式编程提供更好的支持。使得开发响应式应用更加简单和高效。
   
5. 指出Spring6.0在安全性方面的改进。支持最新的安全标准如TLS 1.3和HTTP/2，提供更强的密码学支持，增强应用程序的安全性。
   
6. 强调Spring6.0在测试方面的简化。引入新的测试模块，使测试编写更加容易和直观。同时与主流测试框架如JUnit和Mockito等更好集成。
   
7. 强调Spring6.0将提供长期支持，确保应用程序的稳定性和可靠性。让开发人员放心使用Spring6.0进行开发。
   

🍊 Spring Boot自动装配

Spring Boot启动的时候会通过@EnableAutoConfiguration注解找到META-INF/spring.factories配置文件中的所有自动配置类，并对其进行加载，而这些自动配置类都是以AutoConfiguration结尾来命名的，它实际上就是一个JavaConfig形式的Spring容器配置类，它能通过以Properties结尾命名的类中取得在全局配置文件中配置的属性如：server.port，而XxxxProperties类是通过@ConfigurationProperties注解与全局配置文件中对应的属性进行绑定的。

启动类的@SpringBootApplication注解由@SpringBootConfiguration，@EnableAutoConfiguration，@ComponentScan三个注解组成，三个注解共同完成自动装配；

@SpringBootConfiguration 注解标记启动类为配置类

@ComponentScan 注解实现启动时扫描启动类所在的包以及子包下所有标记为bean的类由IOC容器注册为bean

@EnableAutoConfiguration通过 @Import 注解导入 AutoConfigurationImportSelector类，然后通过AutoConfigurationImportSelector 类的 selectImports 方法去读取需要被自动装配的组件依赖下的spring.factories文件配置的组件的类全名，并按照一定的规则过滤掉不符合要求的组件的类全名，将剩余读取到的各个组件的类全名集合返回给IOC容器并将这些组件注册为bean

Spring Boot自动装配的底层实现原理主要依赖于Spring Framework的核心组件：IoC容器。Spring Boot在启动时会自动扫描项目中的所有类，并通过IoC容器将这些类进行实例化和注入。

具体来说，Spring Boot通过以下几个步骤实现自动装配：

1. 扫描类路径下的所有类：在启动时，Spring Boot会自动扫描类路径下的所有类（包括jar包中的类），并将这些类进行解析和加载。
   
2. 根据条件自动装配：Spring Boot通过条件注解（如@ConditionalOnClass、@ConditionalOnBean等）来判断哪些类需要被自动装配。在满足条件的情况下，Spring Boot会自动创建该类的实例，并将其注入到IoC容器中。
   
3. 自动配置：除了通过条件注解判断哪些类需要被自动装配外，Spring Boot还提供了一系列自动配置类，用于自动配置各种常用的组件（如数据库连接池、Web容器等）。当自动装配某个组件时，Spring Boot会先检查该组件是否已经存在，如果不存在，则自动创建该组件的实例并注入到IoC容器中。
   
4. 处理自定义配置：Spring Boot还支持外部化配置，可以通过properties文件或YAML文件来配置应用程序。在启动时，Spring Boot会读取这些配置文件，并将其注入到IoC容器中，以便在应用程序中进行使用。
   

总的来说，Spring Boot的自动装配机制主要依赖于IoC容器和条件注解，通过自动扫描类路径、判断条件和自动配置组件来实现自动装配。这种机制可以大大简化应用程序的配置工作，提高开发效率。

🍊 Spring Framework的SPI机制

介绍SPI机制：SPI机制是Java平台提供的一种服务发现机制，被广泛用于实现框架扩展。SPI机制将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。Spring Framework将SPI机制用于实现可扩展性，使得第三方插件可以与Spring核心框架无缝集成。

SPI机制的实现方式：Spring Framework通过org.springframework.core.io.support.SpringFactoriesLoader类来实现SPI机制。该类会在META-INF/spring.factories文件中查找实现类的全限定名，并实例化对应的对象。第三方插件只需要在META-INF/spring.factories文件中声明自己的实现类，就可以被Spring Framework自动加载和集成。

SPI机制的优点：SPI机制为很多框架扩展提供了可能，使得Spring Framework具有很高的可扩展性。开发者可以通过实现Spring Framework提供的扩展点接口，将插件集成到Spring应用程序中。此外，SPI机制还使得代码更加模块化，降低了代码的耦合度，提高了代码的可维护性和可重用性。

SPI机制在Spring中的应用：SPI机制在Spring中广泛应用于各个模块，如JDBC、Web、AOP等。例如，在JDBC模块中，Spring通过SPI机制加载不同类型的数据库驱动；在Web模块中，Spring通过SPI机制加载不同类型的Web容器（如Tomcat、Jetty等）。

注意事项和限制：虽然SPI机制提供了很好的扩展性，但也存在一些注意事项和限制。首先，需要确保SPI机制所需的文件（如META-INF/spring.factories）正确配置；其次，需要避免实现类之间的冲突；最后，需要考虑性能开销，因为SPI机制需要加载和初始化实现类。

🍊 Spring Boot启动过程

Spring Boot的启动过程是一个逐步初始化的过程，主要包括以下几个步骤：

1. 创建SpringApplication对象：在启动过程中，首先会创建一个SpringApplication对象。该对象负责管理整个Spring Boot应用的生命周期。
   
2. 加载配置文件：Spring Boot会自动加载应用程序的配置文件，例如application.properties或application.yml。这些配置文件包含了各种配置项，如服务器端口、数据库连接等。
   
3. 创建并配置EmbeddedServletContainerFactory：EmbeddedServletContainerFactory是Spring Boot中用于创建内嵌的Servlet容器的工厂类。它会读取配置文件中的相关信息，如嵌入式服务器类型、上下文路径等，并根据这些信息创建一个内嵌的Servlet容器。
   
4. 注册监听器和事件处理器：在创建EmbeddedServletContainerFactory之后，Spring Boot会注册一些默认的监听器和事件处理器。这些监听器和事件处理器可以处理应用程序的生命周期事件，如应用程序启动、停止等。
   
5. 准备环境：在完成以上步骤之后，Spring Boot会进行一些准备工作，包括加载应用程序的基础依赖、配置环境变量等。这样可以使应用程序在一个合适的环境中运行。
   
6. 启动嵌入式Servlet容器：准备工作完成后，Spring Boot会调用EmbeddedServletContainerFactory的start()方法来启动内嵌的Servlet容器。这个容器负责处理HTTP请求和响应。
   

最后，通过以上步骤，Spring Boot应用程序会成功启动并运行起来。在整个启动过程中，Spring Boot会自动管理各种组件和依赖关系，使得开发者可以更加专注于业务逻辑的开发，而不需要过多关注底层的细节。

🍊 SpringMVC执行流程

🍊 Dubbo服务发现与调用

Dubbo的服务发现机制包含提供者、消费者和注册中心三个参与角色。Dubbo提供者实例注册URL地址到注册中心，注册中心负责对数据进行聚合，Dubbo消费者从注册中心读取地址列表并订阅变更，每当地址列表发生变化，注册中心将最新的列表通知到所有订阅的消费者实例。

简单来说，Dubbo服务发现与调用的流程如下：

1. 服务提供者启动时，向注册中心注册自己提供的服务。
2. 服务消费者启动时，向注册中心订阅自己所需要的服务。
3. 服务消费者从注册中心获取服务提供者的信息，然后通过网络调用服务提供者的方法。
4. 服务消费者调用完成后，将结果返回给服务消费者。
5. 服务消费者可以将结果存储到缓存中，提高性能。