【Java面试】2024年3月最新面试题系列 之 Spring系列

Spring

1、String、stringbuffer、stringbuilder区别

1、string是一个被final修饰的不可变字符序列；
2、stringBuffer和stringBuilder都是可变字符序列；
3、stringBuffer在字符修改时，效率较低，是线程安全的；
4、stringBuilder在字符修改时，效率较高，是线程不安全的；
5、在初始化时，string可以是空值，stringbuffer、stringbulider不可以；
6、String用于操作少量的数据；
7、StringBuffer用于多线程操作字符串缓冲区下操作大量数据；
8、StringBuilder用于单线程操作字符串缓冲区下操作大量数据。

2、Spring的生命周期（Bean的生命周期）

1、实例化bean方法
2、属性注入方法(包含beanName，ApplicationContext)
3、InitializingBean接口方法
4、bean自身初始化方法initMethod
5、DisposableBean接口方法
6、bean自身销毁方法destroyMethod

3、Spring的加载过程，如何解决循环依赖

//spring的加载过程：
1、在一个基于springMVC的web应用中，需要一个web容器，一般使用tomcat，这个容器提供了一个全局的上下文环境ServletContext，也就是SpringIOC的宿主环境；
2、宿主环境启动时，入口文件时web.xml,定义了两个基本内容 ContextLoaderListener 和 DispatcherServlet；
3、ContextLoaderListener是实现了ServletContextListener接口的监听器，在项目启动的时候会触发容器初始化方法contextInitialized；
  【
  contextInitialized容器初始化方法主要做3个事情：
  1、执行initWebApplicationContext方法，启动一个根上下文WebApplicationContext（一个接口类），其实现类为XmlWebApplicationContext（即传说的IOC容器）；
  2、根据配置路径加载spring文件创建Bean的实例，这些bean都放入XmlWebApplicationContxt容器中；
  3、将加载好Bean实例的WebApplicationContext按指定的key注册到ServletContext（Java Web全局变量宿主容器）容器中去。
   】
4、contextLoaderListener监听器监听容器初始化完成之后，开始初始化web.xml中配置的Servlet（可以配置多个），springmvc中以DispatcherServlet为例。DispatcherServlet，前端控制器，也可以叫请求分发控制器，用来接收、匹配、处理、转发每个servlet请求。
5、DispatcherServlet会以WebApplicationServlet作为自己的parent上下文，然后再初始化自己的上下文。DispatcherServlet初始化上下文主要包括处理器映射器，处理器适配器，视图解析器等。
6、最后再将初始化完成的Servlet注册到ServletContext中，这样每个Servlet都可以持有自己的上下文，同时又能共享根上下文，即IOC容器上下文WebApplicationContext。

4、spring声明bean的方式

1、调用构造器创建Bean
2、调用静态工厂方法创建Bean
3、调用实例工厂方法创建Bean

5、Spring框架的好处，为什么要用Spring？

1、方便解耦，便于开发（Spring就是一个大工厂，可以将所有对象的创建和依赖关系维护都交给spring管理）；
2、spring支持aop编程（spring提供面向切面编程，可以很方便的实现对程序进行权限拦截和运行监控等功能）；
3、声明式事务的支持（通过配置就完成对事务的支持，不需要手动编程）；
4、方便程序的测试，spring 对junit4支持，可以通过注解方便的测试spring 程序；
5、方便集成各种优秀的框架；
6、降低javaEE API的使用难度（Spring 对javaEE开发中非常难用的一些API 例如JDBC,javaMail,远程调用等，都提供了封装，是这些API应用难度大大降低）。

A、事物

1、事物的隔离级别

读未提交：read uncommitted 可以脏读、幻读、不可重复读
读已提交：read committed 可以幻读、不可重复读，不可脏读
可重复读：repeatable read 只允许幻读，而且在mysql中只支持InnoDB
串行化：serializable 不可脏读、幻读、不可重复读
  
脏读：一个事务读到另外一个事务还没有提交的数据
幻读：一个事务先后读取一个范围的记录，但两次读取的纪录数不同
不可重复读：一个事务先后读取同一条记录，但两次读取的数据不同

2、事务的传播行为

1、PROPAGATION_REQUIRED：表示当前方法必须运行在事务中。如果当前事物存在，方法将会在该事物中运行，否则，会启动一个新事物；
2、PROPAGATION_SUPPORTS：表示当前方法不需要事务上下文，但是如果存在当前事物的话，那么该方法会在该事物中运行；
3、PROPAGATION_MANDATORY：表示该方法必须在事务中运行，如果当前事物不存在，则会抛出一个异常；
4、PROPAGATION_MANDATORY：表示当前方法必须运行在他自己的事物中。一个新的事物将会被启动，如果存在当前事物，在该方法执行时，当前事物会被挂起；
5、PROPAGATION_NOT_SUPPORTED：表示该方法不应该运行在事务中。如果存在当前事物，在该方法运行期间，当前事物将会被挂起；
6、PROPAGATION_NEVER：表示当前方法不应该运行在事务的上下文中。如果当前正好有一个事物在运行，则会抛出异常；
7、PROPAGATION_NESTED：表示如果当前如果已经存在一个事物，那么该方法就会在嵌套事务中运行。嵌套的事务可以独立于当前事物进行单独的提交和回滚。如果当前事物不存在，那么就会启动一个新事物。

3、什么是脏读、幻读、不可重复读

脏读：一个事务读到另外一个事务还没有提交的数据
幻读：一个事务先后读取一个范围的记录，但两次读取的纪录数不同
不可重复读：一个事务先后读取同一条记录，但两次读取的数据不同

4、分布式事务解决方案

1、两阶段提交（2PC）：两段提交就是分两个阶段提交，第一阶段询问各个事务数据源是否准备好，第二阶段才真正将数据提交给事务数据源。为了满足ACID特性，引入了一个协调者（Cooradinator），其他的节点被称为参与者（Participant）。协调者负责调度参与者的行为，并最终决定这些参与者是否要把事务进行提交。
2、三阶段提交（3PC）：三阶段提交是在二阶段提交上的改进版本，3PC最关键要解决的就是协调者和参与者同时挂掉的问题，所以3PC把2PC的准备阶段再次一分为二，这样三阶段提交；
3、补偿事物（TCC）
4、本地消息表（消息队列）：通过在消费者额外新建事务消息表，消费者处理业务和记录事务消息在本地事务中完成，轮询事务消息表的数据发送事务消息，提供者基于消息中间件消费事务消息表中的事务
5、Sagas事物模型（最终一致性）：Saga模式是一种分布式异步事务，一种最终一致性事务，是一种柔性事务，有两种不同的方式来实现saga事务，最流行的两种方式是
  【
   一、 事件/编排Choreography：没有中央协调器（没有单点风险）时，每个服务产生并聆听其他服务的事件，并决定是否应采取行动。
   二、 命令/协调orchestrator：中央协调器负责集中处理事件的决策和业务逻辑排序。
   】

B、IOC 控制反转

1、IOC原理

1、IOC：是一种设计思想，就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。 IoC 在其他语言中也有应用，并非 Spirng 特有。 IOC 容器是 Spring 用来实现 IOC 的载体， IOC 容器实际上就是个Map（key，value）,Map 中存放的是各种对象。
  	将对象之间的相互依赖关系交给 IOC 容器来管理，并由 IOC 容器完成对象的注入。这样可以很大程度上简化应用的开发，把应用从复杂的依赖关系中解放出来。 IOC 容器就像是一个工厂一样，当我们需要创建一个对象的时候，只需要配置好配置文件/注解即可，完全不用考虑对象是如何被创建出来的。
  	这个描述最具体表现就是通过 xml，properties 文件等语义化配置文件表示。
2、Spring IOC的体系结构
  1、BeanFactory：bean工厂
  2、BeanDefinition：描述了定义的各种Bean对象及其相互的关系
3、IoC容器的初始化：包括BeanDefinition的Resource定位、载入和注册这三个基本的过程；
4、依赖注入发生的时间：1、用户第一次通过getBean方法向IoC容索要Bean时，IoC容器触发依赖注入。
                   2、当用户在Bean定义资源中为<Bean>元素配置了lazy-init属性，即让容器在解析注册Bean定义时进行预实例化，触发依赖注入。

2、spring如何做到控制反转

我们每次使用spring框架都需要配置xml文件，这个xml配置了bean的id和class。Spring中默认的bean为单实例模式，通过bean的class引用反射机制可以创建这个实例。因此，spring框架通过反射代替我们创建好了实例并且替我们维护他们。A需要引用B类，spring框架就会通过xml把B实例的引用传给了A的成员变量。

3、IOC的好处

对象的构建如果依赖非常多的对象，且层次很深，外层在构造对象时很麻烦且不一定知道如何构建这么多层次的对象。 IOC 帮我们管理对象的创建，只需要在配置文件里指定如何构建，每一个对象的配置文件都在类编写的时候指定了，所以最外层对象不需要关心深层次对象如何创建的。

C、AOP

1、AOP原理

1、AOP：AOP(Aspect-Oriented Programming:面向切面编程) 能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。
		Spring AOP就是基于动态代理的，如果要代理的对象，实现了某个接口，那么Spring AOP会使用JDK Proxy，去创建代理对象，而对于没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候Spring AOP会使用Cglib ，这时候Spring AOP会使用 Cglib 生成一个被代理对象的子类来作为代理。
		使用 AOP 之后我们可以把一些通用功能抽象出来，在需要用到的地方直接使用即可，这样大大简化了代码量。我们需要增加新功能时也方便，这样也提高了系统扩展性。日志功能、事务管理等等场景都用到了 AOP 。
2、实现技术：主要是由Spring AOP和AspectJ；
    AspectJ的底层技术是静态代理；
    Spring AOP采用的是动态代理，在运行期间对业务方法进行增强，所以不会生成新类，对于动态代理技术，Spring AOP提供了对JDK动态代理的支持以及CGLib的支持。
  
    JDK动态代理：只能为接口创建动态代理实例，而不能对类创建动态代理。需要获得被目标类的接口信息（应用Java的反射技术），生成一个实现了代理接口的动态代理类（字节码），再通过反射机制获得动态代理类的构造函数，利用构造函数生成动态代理类的实例对象，在调用具体方法前调用invokeHandler方法来处理。
    CGLib动态代理：需要依赖asm包，把被代理对象类的class文件加载进来，修改其字节码生成子类。

    Spring AOP基于注解配置的情况下，需要依赖于AspectJ包的标准注解，而基于XML配置不需要。

2、AOP+分布式锁是如何实现缓存问题的

1、在SpringBoot项目中引入Redis；
2、在在application.yml中配置Redis；
3、接着创建Redis配置类；
4、在需要使用的地方引入就可以。
  
  RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(redisConnectionFactory);
        template.setKeySerializer(jackson2JsonRedisSerializer); 设置键的序列化
        template.setValueSerializer(jackson2JsonRedisSerializer); 设置值的序列化
        template.setHashKeySerializer(jackson2JsonRedisSerializer); 设置哈希键的序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer); 设置哈希值的序列化
        template.afterPropertiesSet();  
        return template;

3、面向对象、面向过程、面向切面编程的区别

1、面向过程：是一种以过程为中心的编程思想。这些都是以什么正在发生为主要目标进行编程，不同于面向对象的是谁在受影响。与面向对象明显的不同就是封装、继承、类。
2、面向对象编程（OOP）：是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP 达到了软件工程的三个主要目标：重用性、灵活性和扩展性。为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息。
3、面向切面编程（AOP）：AOP主要实现的目的是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。

D、依赖

1、Spring如何解决循环依赖的

1、循环依赖：就是循环引用，就是两个或者多个Bean相互之间持有对象最终反映为一个环，注意此处不是循环调用，循环调用是方法之间的环调用，循环调用是无法解决的，除非有终结条件，否则就是死循环，最后导致栈内存溢出；
2、Spring如何解决循环依赖：通过构造器循环依赖和setter方法循环依赖两种方式：
    1、构造器循环依赖：表示通过构造器注入构成的循环依赖，此依赖是无法解决的，只能抛出BeanCurrentlyInCreationException异常表示循环依赖；
    2、setter循环依赖：表示通过setter注入方式构成的循环依赖，对于setter注入造成的依赖是通过Spring容器提前暴露刚完成构造器注入但未完成其他步骤（如setter注入）的bean来完成，而且只能解决单例作用域的bean循环依赖，通过提前暴露一个单列工厂方法，从而使其他bean能够引用到该bean

2、spring的依赖注入有几种

1、构造方法注入 
2、setter注入
3、基于注解的注入

SpringBoot

1、SpringBoot自动配置的原理及实现

@SpringBootConfiguration：标记当前类为配置类
@EnableAutoConfiguration：开启自动配置
@ComponentScan：扫描主类所在的同级包以及下级包里的Bean

主要是通过 @EnableAutoConfiguration下的@Import(EnableAutoConfigurationImportSelector.class)，借助 EnableAutoConfigurationImportSelector，@EnableAutoConfiguration 可以帮助 SpringBoot 应用将所有符合条件的 @Configuration 配置都加载到当前 SpringBoot 创建并使用的 IoC 容器:通过@Import(AutoConfigurationImportSelector.class) 导入的配置功能，AutoConfigurationImportSelector 中的方法 getCandidateConfigurations，得到待配置的 class 的类名集合,这个集合就是所有需要进行自动配置的类，而是是否配置的关键在于 META-INF/spring.factories 文件中是否存在该配置信息。

2、springboot的底层

SpringBoot是一个快速开发框架，通过Maven子父工程的方式快速的将一些常用的第三方依赖整合，简化XML配置，全部采用注解形式，内置Http服务器（Jetty和Tomcat），最终以java应用程序进行执行。

SpringBoot的核心原理：
1、基于SpringMVC无配置文件（纯Java）完全注解化+内置tomcat-embed-core实现SpringBoot框架，Main函数启动。
2、SpringBoot核心快速整合第三方框架原理:Maven继承依赖关系。

3、spring和springboot的区别

1、Spring Boot可以建立独立的Spring应用程序；
2、SpringBoot内嵌了如Tomcat，Jetty和Undertow这样的容器，也就是说可以直接跑起来，用不着再做部署工作了；
3、SpringBoot无需再像Spring那样搞一堆繁琐的xml文件的配置；
4、SpringBoot可以自动配置Spring。SpringBoot将原有的XML配置改为Java配置，将bean注入改为使用注解注入的方式(@Autowire)，并将多个xml、properties配置浓缩在一个appliaction.yml配置文件中。
5、提供了一些现有的功能，如量度工具，表单数据验证以及一些外部配置这样的一些第三方功能；
6、整合常用依赖（开发库，例如spring-webmvc、jackson-json、validation-api和tomcat等），提供的POM可以简化Maven的配置。当我们引入核心依赖时，SpringBoot会自引入其他依赖。

4、springboot如何解决跨域问题

只用在Controller类上添加一个“@CrossOrigin“注解。

5、springboot的优点

优点：
1、创建独立的Spring应用程序
2、嵌入的Tomcat，无需部署WAR文件
3、简化Maven配置
4、自动配置Spring
5、提供生产就绪型功能，如指标，健康检查和外部配置
6、绝对没有代码生成并且对XML也没有配置要求

6、springboot的配置文件有哪几种，谁先加载？为什么

yml配置文件 和 properties配置文件

yml文件先加载，进行覆盖，以properties为主

7、springboot如何查找上下文

1、实现ApplicationContextAware接口；
2、在springboot引导类里设置applicationContext；
3、在需要使用上下文的地方直接注入ApplicationContext。

A、SpringBoot注解

1、springboot常用注解

1、@SpringBootApplication：springboot中最核心的注解，标记启动类；
  是@Configuration、@EnableAutoConfiguration和@ComponentScan的组合注解。
2、@Configuration：指示一个类声明一个或者多个@Bean声明的方法并且由Spring容器管理；
3、@EnableAutoConfiguration：将SpringBoot中所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IoC容器；
4、@ComponentScan：扫描定义路径下的bean；
5、@Autowired：引入类或接口文件；
6、@RestController：主要作用于Controller的类上，主要用于返回json数据；
  它是@Controller和@ResponseBody的组合注解。
7、@Controller：主要作用于控制层类上，用于处理http请求等；
8、@ResponseBody：主要作用于控制层的类上，主要用于返回json数据；
9、@Service：主要作用于业务层上面，就是通常说的service的类上；
10、@RequestMapping：主要作用于Controller类及方法上，主要作用是请求地址的映射；
11、@Mapper：主要作用于DAO接口上，可以自动生成接口的实现类。如果DAO接口比较多，推荐使用@MapperScan注解，写法如@MapperScan("com.example.demo.dao")；
12、@PathVariable：主要是用于取url中的变量的值；
13、@RequestParam：将请求参数绑定到Controller的方法上面，@RequestParam(value=”参数名”)

2、@Autowired 和 @Resource的区别

1、@Autowired默认按类型装配，默认情况下必须要求依赖对象必须存在，如果要允许null值，可以设置它的required属性为false；
2、@Resource默认按照名称进行装配，名称可以通过name属性进行指定，如果没有指定name属性，当注解写在字段上时，默认取字段名进行安装名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

B、SpringMVC

1、dao层的注解

1、@Mapper
2、@param 指定参数

2、JSP、Servlet与MVC的区别

1、JSP：以进一步简化servlet程序开发；
2、Servlet：是一个Java程序，一个Servlet应用有一个或多个Servlet程序。Servlet也是Java的一个接口，JSP页面会被转换和编译成Servlet程序。
3、MVC：基于模型-视图-控制器的模式。一个实现MVC模式的应用包含模型、视图和控制器3个模块。视图负责应用的展示。模型封装了应用的数据和业务逻辑。Spring MVC 使用一个Servlet作为控制器，大部分都采用JSP页面作为应用的视图，而模型则采用POJO，实践中会采用一个JavaBean来持有模型状态。

3、SpringMVC流程

1、用户发送请求到前端控制器DispathcherServlet
2、前端控制器收到请求调用HandlerMapping处理器映射器
3、处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给前端控制器
4、前端控制器调用HandlerAdapter处理器适配器
5、处理器适配器 经过适配调用具体的 处理器(Controller,也叫后端控制器)
6、处理器 执行完成返回ModelAndView
7、处理器适配器 将 处理器 执行结果 ModelAndView 返回给 前端控制器
8、前端控制器 将 ModelAndView 传给ViewReslover视图解析器
9、视图解析器 解析后返回集体的View
10、前端控制器 根据View进行渲染视图(即将模型数据填充至视图中)dispatcherServlet响应用户

SpringCloud

1、SpringCloud的几大组件

1、Eureka（注册中心）：各个服务启动时，Eureka Client都会将服务注册到Eureka Server，并且Eureka Client还可以反过来从Eureka Server拉取注册表，从而知道其他服务在哪里；
2、Ribbon（负载均衡）：服务间发起请求的时候，基于Ribbon做负载均衡，从一个服务的多台机器中选择一台；
3、Fegin（远程调用）：基于Feign的动态代理机制，根据注解和选择的机器，拼接请求URL地址，发起请求；
4、Hystrix（熔断器）：发起请求是通过Hystrix的线程池来走的，不同的服务走不同的线程池，实现了不同服务调用的隔离，避免了服务雪崩的问题；
5、Zuul（网关）：如果前端、移动端要调用后端系统，统一从Zuul网关进入，由Zuul网关转发请求给对应的服务。

A、Nacos

1、nacos的注册原理

register是SpringCloud的注册入口。首先创建一个 NamingService 实例，namingServiceInstance()创建的一个NacosDiscoveryProperties类，是和配置文件对应的一个映射类，在application.properties文件中配置的有关spring.cloud.nacos.discovery均作为这个类的属性。

注册中心还有：Zookeeper、Consul、Eureka

2、nacos的配置原理

Nacos 服务端创建了相关的配置项后，客户端就可以进行监听了。
客户端是通过一个定时任务来检查自己监听的配置项的数据的，一旦服务端的数据发生变化时，客户端将会获取到最新的数据，并将最新的数据保存在一个 CacheData 对象中，然后会重新计算 CacheData 的 md5 属性的值，此时就会对该 CacheData 所绑定的 Listener 触发 receiveConfigInfo 回调。
考虑到服务端故障的问题，客户端将最新数据获取后会保存在本地的 snapshot 文件中，以后会优先从文件中获取配置信息的值。

3、nacos是如何实现的

nacos注册是通过properties实现。
nacos配置通过服务端创建相关配置，客户端进行监听。当数据发上变化，客户端获取到最新数据，并将数据保存在 CacheData 对象中，然后会重新计算 CacheData 的 md5 属性的值，并对该 CacheData 所绑定的 Listener 触发 receiveConfigInfo 回调。

4、nacos和cap原则的联系

CAP原则又称CAP定理，指的是在一个分布式系统中， Consistency（一致性）、 Availability（可用性）、Partition tolerance（分区容错性），三者不可得兼。
    一致性（C）：在分布式系统中的所有数据备份，在同一时刻是否同样的值。（等同于所有节点访问同一份最新的数据副本）
    可用性（A）：在集群中一部分节点故障后，集群整体是否还能响应客户端的读写请求。（对数据更新具备高可用性）
    分区容错性（P）：以实际效果而言，分区相当于对通信的时限要求。系统如果不能在时限内达成数据一致性，就意味着发生了分区的情况，必须就当前操作在C和A之间做出选择。

  nacos在实际中满足了 可用性 和 分区容错性。
  nacos各个节点都是平等的，几个节点挂掉不影响正常节点的工作，剩余的节点依然可以提供注册和查询服务。而nacos的客户端在向某个nacos注册时如果发现连接失败，则会自动切换至其他的节点，只要有一台nacos还在，就能保证注册服务可用（保证可用性），只不过查到的信息可能不是最新的（不保证一致性）。除此之外，nacos还有一种自我保护机制，如果在15分钟内超过85%的节点都没有正常的心跳，那么nacos就认为客户端与注册中心出现了网络故障，此时会出现以下几种情况：
  1、nacos不再从注册列表中移除因为长时间没有收到心跳而应该过期的服务
  2、nacos仍然能够接受新服务的注册和查询请求，但是不会被同步到其它节点上（即保证当前节点依然可用）
  3、当前网络稳定时，当前实例新的注册信息会被同步到其它节点中 因此，nacos可以很好的应对因网络故障导致节点失去联系的情况，而不会像zookeeper那样使整个注册服务瘫痪。

B、Gateway

1、Gateway网关与nginx的异同

网关(Gateway)就是一个网络连接到另一个网络的“关口”，用于拦截所有服务器请求进行控制。
nginx是采用服务器负载均衡进行转发，后面连接gateway网关。
过滤器是拦截某一个单个的服务器请求进行控制。

2、Gateway除了配置路由和拦截器，还做过哪些操作?

1、鉴权：做权限判断，校验权限信息；
2、路由：gateway网关根据路由和断言去转发请求到指定的服务，在gateway服务中的配置文件配置；
3、灰度发布、限流；
4、反向代理。
5、日志监控

3、Gateway如何实现全局拦截器?

所有的请求都走 fetcher , fetcher 里面加个 then 用来做拦截就行

4、自定义拦截器

1、继承接口 intercept
  三个方法：
  1.public void destroy();    //释放资源
  2.public void init();        //初始化
  3.public String intercept(ActionInvocation arg0); //核心方法
2、继承抽象类 abstractIntercept
  方法：public String Intercept(ActionInvocation  arg0);
3、继承methodFilterIntercept
  方法：public String doIntercept(ActionInvocation arg0);

5、Gateway如何实现负载均衡？默认策略是什么

gateway的负载均衡原则是：通过服务注册中心的服务名/接口实现负载均衡的能力。
  
7中负载均衡策略：1、RandomRule 随机策略 ：随机选择server
              2、RoundRobinRule 轮训策略 ：按照顺序选择server 【默认策略】
              3、RetryRule 重试策略 ：在一个配置时间内，当选择的server不成功，则一直尝试选择一个可用的server
              4、BastAvailableRule 最低并发策略 ：逐个考察server，如果server断路器打开则忽略，再选择其中并发连接最低的server
              5、AvailavilityFilteringRule 可用过滤策略
              6、ResponseTimeWeightedRule 响应时间加权重策略
              7、ZoneAvoidanceRule 区域全中策略

6、网关的作用

1、在所有内网(也就是局域网)计算机访问的不是本网段的数据时使用。
2、网关负责将内网IP转换为公网IP，公网IP转换为内网IP；
  
  网关的主要作用就是转载

7、Spring Cloud Gateway 的工作流程

1、客户端向 Spring Cloud Gateway 发出请求。然后在 Gateway Handler Mapping 中找到与请求相匹配的路由，将其发送到 Gateway Web Handler。
2、Handler 再通过指定的过滤器链来将请求发送到我们实际的服务执行业务逻辑，然后返回。
3、过滤器之间用虚线分开是因为过滤器可能会在发送代理请求之前( “pre” )或之后( “post” )执行业务逻辑。
4、Filter 在 “pre” 类型的过滤器可以做参数校验、权限校验、流量监控、日志输出、协议转换等，在 "post” 类型的过滤器中可以做响应内容、响应头的修改，日志的输出，流量监控等有着非常重要的作用。

C、Rabbon

1、ribbon在使用的过程中除了使用默认的轮询机制，还用过哪些?

1、RandomRule 随机策略 ：随机选择server
2、RoundRobinRule 轮训策略 ：按照顺序选择server 【默认策略】
3、RetryRule 重试策略 ：在一个配置时间内，当选择的server不成功，则一直尝试选择一个可用的server
4、BastAvailableRule 最低并发策略 ：逐个考察server，如果server断路器打开则忽略，再选择其中并发连接最低的server
5、AvailavilityFilteringRule 可用过滤策略
6、ResponseTimeWeightedRule 响应时间加权重策略
7、ZoneAvoidanceRule 区域全中策略

2、Rabbon怎么使用/配置

1、一 全局配置
  ribbon.<key>=<value>
  <key>代表了Ribbon客户端配置的参数名，<value>则代表了对应参数的值。
2、指定客户端配置
  <client>.ribbon.<key>=<value>
  <key>和<value>的含义同全局配置相同，而<client>代表了客户端的名称。

D、Openfeign

1、微服务间的调用方式

1、RPC：客户端和服务器之间建立TCP连接，可以一次建立一个，也可以多个调用复用一次链接（建立连接耗时）大公司多用RPC。支持同步、异步调用；
2、Rest（HTTP）：http请求，支持多种协议和功能，开发方便成本低，http数据包大；
3、OpenFeign：本质还是用HTTP。
  使用feign调用步骤：1、加入openfeign依赖；
                   2、 启动类增加@EnableFeignClients
                   3、增加一个接口，并添加注解@FeignClient(name="product-service")
   
  采用feign，默认集成了ribbon，写起来更加思路清晰和方便，采用注解方式进行配置，配置熔断等方式方便

E、Sentinel

1、对sentinel的理解

1、主要以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度来帮助您保护服务的稳定性。
2、Sentinel 作为一个调配器，可以根据需要把随机的请求调整成合适的形状，有顺序性的 实现流量控制。
3、Sentinel：当调用链路中某个资源出现不稳定，例如，表现为 timeout，异常比例升高的时候，则对这个资源的调用进行限制，并让请求快速失败，避免影响到其它的资源，最终产生雪崩的效果。实现熔断降级。
4、Sentinel 的工作机制：1、对主流框架提供适配或者显示的 API，来定义需要保护的资源，并提供设施对资源进行实时统计和调用链路分析。
                      2、根据预设的规则，结合对资源的实时统计信息，对流量进行控制。同时，Sentinel 提供开放的接口，方便您定义及改变规则。
                      3、Sentinel 提供实时的监控系统，方便您快速了解目前系统的状态。