注册中心的分类和概述以及总结

一.总结eureka微服务创建的流程

简述：Eureka负责管理、记录服务提供者的信息。服务调用者无需自己寻找服务，而是把自己的需求告诉Eureka，然后Eureka会把符合你需求的服务告诉你。同时，服务提供方与Eureka之间通过“心跳”机制进行监控，当某个服务提供方出现问题，Eureka自然会把它从服务列表中剔除。这就实现了服务的自动注册、发现、状态监控。

• Eureka：就是服务注册中心，对外暴露自己的地址
• 提供者：启动后向Eureka注册自己信息
• 消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者地址列表发送给消费者，并且定期更新
• 心跳(续约)：提供者定期通过http方式向Eureka刷新自己的状态

1.构建一个子模块，命名结尾以默认端口号标识7001。
2.引入pom.xml文件

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
    <dependency>
        <groupId>com.baidu.cloud</groupId><!--自定义路径-->
        <artifactId>cloud-api-commons</artifactId>
        <version>${project.version}</version>
    </dependency>
</dependencies>

3.编写application.yml文件

server:
  port: 7001

eureka:
  instance:
    hostname: localhost  # eureka 服务器的实例名称  127.0.0.1
  client:
    # false 代表不向服务注册中心注册自己，因为它本身就是服务中心
    register-with-eureka: false
    # false 代表自己就是服务注册中心，自己的作用就是维护服务实例，并不需要去检索服务
    fetch-registry: false
    service-url:
    # 设置与 Eureka Server 交互的地址，查询服务 和 注册服务都依赖这个地址
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

4.编写启动类

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)// exclude ：启动时不启用 DataSource的自动配置检查
@EnableEurekaServer //开启Eureka服务
public class EurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class,args);
    }
}

5.开启启动类测试：

访问7001端口号：
	http://localhost:7001

二.如何搭建eureka集群

假设要运行两个集群，端口号分别为：7001,7002
第一步：首先得修改电脑C盘内部的配置文件
进入C:\Windows\System32\drivers\etc\hosts
修改hosts内部的内容，在其尾部添加：

127.0.0.1 eureka7001.com
127.0.0.1 eureka7002.com

用于在端口号调用的时候识别端口号。如果C盘 有权限无法修改，
两种解决方案：
第一种：复制hosts文件到桌面，然后进行修改，修改完毕后直接剪切到hosts所在的C盘目录下覆盖原来的hosts文件。
第二种：修改C盘权限，直至权限最大，可以修改配置文件。(不建议使用)
第二步：创建另一个服务，以默认结尾是7002的子模块，所有配置文件都复制7001内的就可以。server.port: 后的端口号要修改为7002。
第三步：修改7001和7002内部的配置文件：
7001：

server:
  port: 7001

eureka:
  instance:
    hostname: eureka7001.com  # eureka 服务器的实例名称
  client:
    # false 代表不向服务注册中心注册自己，因为它本身就是服务中心
    register-with-eureka: false
    # false 代表自己就是服务注册中心，自己的作用就是维护服务实例，并不需要去检索服务
    fetch-registry: false
    service-url:
    #一定要注意这里的地址，这是搭建集群的关键
      defaultZone: http://eureka7002.com:7002/eureka/

映射7002。
7002：

server:
  port: 7002

eureka:
  instance:
    hostname: eureka7002.com  # eureka 服务器的实例名称
  client:
    # false 代表不向服务注册中心注册自己，因为它本身就是服务中心
    register-with-eureka: false
    # false 代表自己就是服务注册中心，自己的作用就是维护服务实例，并不需要去检索服务
    fetch-registry: false
    service-url:
    # 设置与 Eureka Server 交互的地址，查询服务 和 注册服务都依赖这个地址
      defaultZone: http://eureka7001.com:7001/eureka/

映射7001。
第四步：将提供方和消费方的yml文件中注册进 Eureka Server

eureka:
  client:
    # 注册进 Eureka 的服务中心
    register-with-eureka: true
    # 检索 服务中心 的其它服务
    fetch-registry: true
    service-url:
      # 设置与 Eureka Server 交互的地址
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/

第五步：开启启动类测试：
访问路径：

eureka7001.com:7001
eureka7002.com:7002

总结：
eureka.instance.hostname 才是启动以后本Server 的注册地址，而 service-url 是 map 类型，只要保证 key:value 格式就行，它代表本Server 指向了那些 其它Server 。利用这个，就可以实现Eureka Server 相互之间的注册，从而实现集群的搭建。

三.服务提供方集群如何搭建

1.构建一个新的子模块，尾部默认以8002结尾命名。
2.配置文件全部复制8001模块中的即可，注意修改端口号为8002。
3.启动类的名称注意区分，不能和8001一样。
4.启动测试查看是否成功。如果 相互调用成功，则表示访问成功，
否则表示搭建失败。
5.然后修改服务的消费方和提供方。单机版通过服务地址+端口号调用(http://localhost:8001)，
修改为：根据提供方的名称访问**(http://提供方名称)**。
注意！！！"提供方的名称不能含有下划线，如果有下划线则会报错，导致访问失败。"
6.修改完成后，使消费方的访问路径进行访问，检查是否修改成功和访问成功。

四.RestTemplate如何使用?

1.在服务的消费方创建一个config目录。
2.在config目录下创建一个Class类。
3.利用RestTemplate进行服务调用，创建一个返回值类型是RestTemplate的方法，return new RestTemplate();
4.在消费方Controller层用@Autowired注入RestTemplate方法。
5.在消费方的Controller层，调用各种方法都用RestTemplate方法名调用。

五.简述eureka的自我保护模式？ 如何配置其自我保护模式

简述：某一时刻某一个微服务不能用了，Eureka不会立即清理，依旧会对该微服务的信息进行保存。
如何配置：
1.禁止自我保护: 在 Eureka Server 的模块中的 yml 文件进行配置

server:#关闭自我保护机制，保证不可用的服务会被及时清理
	enable-self-preservation: false
	evicetion-interval-timer-in-ms: 2000

2修改 Eureka Client 模块的心跳间隔时间:

 instance:
 	instance-id: payment8001
 	#Eureka客户端向服务端发送心跳的时间间隔，时间单位为秒：(默认是30秒)
 	prefer-ip-address: 1
 	#Eureka服务端在收到最后一次心跳后等待时间上限，时间单位为秒：(默认是90秒)超时则会剔除服务
 	lease-expiration-duration-in-seconds: 2
 	

六、什么是CAP理论? cp ap原则的含义

1.什么是CAP理论

分布式系统的最大难点，就是各个节点的状态如何保持一致。
CAP理论是在设计分布式系统的过程中，处理数据一致性问题时必须考虑的理论。
cap分为：Consistency（一致性）和Availability（可用性）以及Partition tolerance（分区容忍性）

权衡CA
之前提到,CAP理论说一个分布式系统不可能同时满足C、A、P这三个特性。
那么我们就来分析C、A、P的权衡吧。
note：其实这里有个关于CAP理论理解的误区。不要以为在所有时候都只能选择两个特性。在不存在网络失败的情况下（分布式系										统正常运行时），C和A能够同时保证。只有当网络发生分区或失败时，才会在C和A之间做出选择。
对于一个分布式系统而言，P是前提，必须保证，因为只要有网络交互就一定会有延迟和数据丢失，这种状况我们必须接受，必须保证系统不能挂掉。
所以只剩下C、A可以选择。要么保证数据一致性（保证数据绝对正确），要么保证可用性（保证系统不出错）。
当选择了C（一致性）时，如果由于网络分区而无法保证特定信息是最新的，则系统将返回错误或超时。
当选择了A（可用性）时，系统将始终处理客户端的查询并尝试返回最新的可用的信息版本，即使由于网络分区而无法保证其是	最新的。	

ZK定位于分布式协调服务，在其管辖下的所有服务之间保持同步、一致(Zab算法，CP)，若作Service发现服务，其本身没有正确处		理网络分割的问题<当多个zk之间网络出现问题-造成出现多个leader-脑裂>，即在同一个网络分区的节点数达不到zk选取leader的数	目，它们就会从zk中断开，同时也不能提供Service发现服务l。

Eureka相对于ZK剔除了选取Leader或事务日志机制，它有独立的客户端程序库，同时提供心跳、服务健康监测、自动发布等服务与自动刷新缓存的功能，在网络分割故障发生时，每个节点会持续的对外提供服务，接收新的服务注册同时将它们提供给下游的服务发现请求(AP)l

3
七、eureka 和zookeeper consul的区别?

三者的共同点

它们都是springcloud集成的

2.不同点

1.Eureka和ZooKeeper是java语言而Consul是Go语言
2.Consul和ZooKeeper的CAP是CP而Eureka是Ap
3.Consul和ZooKeeper支持服务建康检查，Eureka是可配支持
4.Eureka对外暴露接口是HTTP，Consul是HTTP/DNS,ZooJKeeper是客户端

八、使用ribbon进行负载均衡的步骤

1.一般来说，使用原生ribbon而不搭配feign的话，使用的都是RestTemplate，通过这个RestTemplate 来访问其他的服务

@LoadBalanced
@Bean
public RestTemplate getRestTemplate() {
    return new RestTemplate();
}

2.RestTemplate本身并没有负载均衡的功能，只是一个单纯的http请求组件而已，通过上面的代码，我们可以发现多了一个@LoadBalanced注解，这个注解就是ribbon实现负载均衡的一个入口

@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited

. 在application.yml文件中配置向注册中心注册，如果是作为消费者模块不提供服务，不应该注册自己；

server:
  port: 9001
 
eureka:
  client:
    register-with-eureka: false #作为消费者不提供服务，不应该注册自己
    service-url: 
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka

4. 主启动类中加入@EnableEurekaClient注解

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})
@EnableEurekaClient
public class DeptConsumer_9001_App {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_9001_App.class, args);
    }

5.consumer应用中controller实现如下：

*自动注入RestTemplate*/
    @Autowired
    RestTemplate restTemplate;
    /*封装提供方的访问路径*/
    private static final String URL="http://cloud-payment-service";
    /*调用提供方查询*/
    @GetMapping("consumer/payment/{id}")
    public CommonResult<Payment> findPaymentById(@PathVariable("id") Long id){
        CommonResult commonResult = restTemplate.getForObject(URL + "/payment/" + id, CommonResult.class);
        return commonResult;
    }

6.如何切换Ribbon中赋值均衡的规则，而不是使用默认的轮询方式

只需在客户端（consume）工程中的SpringBoot配置类ConfigBean配置一个返回具体方法的bean即可

@Bean
	public IRule MyRule(){
		/* RandomRule为Ribbon中自带规则实现之一，随机规则 */
		return new RandomRule();

九、 ribbon负载均衡的策略有哪些

1.负载均衡有好几种实现策略，常见的有：

1.随机 (Random)
2.轮询 (RoundRobin)
3.一致性哈希 (ConsistentHash)
4.哈希 (Hash)
5.加权（Weighted）
6.ILoadBalance 负载均衡器

IRule接口代表负载均衡策略：

@Configuration
public class RibbonConfig {
    @Bean
    public IRule iRule(){
        return new RandomRule();
    }
}

其中RandomRule表示随机策略、RoundRobinRule表示轮询策略、WeightedResponseTimeRule表示加权策略、BestAvailableRule表示请求数最少策略等等。

随机策略很简单，就是从服务器中随机选择一个服务器，RandomRule的实现代码如下：

public Server choose(ILoadBalancer lb, Object key) {
    if (lb == null) {
        return null;
    }
    Server server = null;
 
    while (server == null) {
        if (Thread.interrupted()) {
            return null;
        }
        List<Server> upList = lb.getReachableServers();
        List<Server> allList = lb.getAllServers();
        int serverCount = allList.size();
        if (serverCount == 0) {
            return null;
        }
        int index = rand.nextInt(serverCount); // 使用jdk内部的Random类随机获取索引值index
        server = upList.get(index); // 得到服务器实例
 
        if (server == null) {
            Thread.yield();
            continue;
        }
 
        if (server.isAlive()) {
            return (server);
        }
 
        server = null;
        Thread.yield();
    }
    return server;

使用Ribbon提供的负载均衡策略很简单，只需以下几部：

创建具有负载均衡功能的RestTemplate实例

@Bean
@LoadBalanced
RestTemplate restTemplate() {
    return new RestTemplate();

十、如何自定义负载均衡

1.引入关键类 RibbonClientConfiguration：

@Bean
	@ConditionalOnMissingBean
	public IRule ribbonRule(IClientConfig config) {
		if (this.propertiesFactory.isSet(IRule.class, name)) {
			return this.propertiesFactory.get(IRule.class, config, name);
		}
		ZoneAvoidanceRule rule = new ZoneAvoidanceRule();
		rule.initWithNiwsConfig(config);
		return rule;

2.判断当前环境是否设置了IRule类：

public boolean isSet(Class clazz, String name) {
		return StringUtils.hasText(getClassName(clazz, name));

3.getClassName 具体实现如下：

public String getClassName(Class clazz, String name) {
		if (this.classToProperty.containsKey(clazz)) {
			String classNameProperty = this.classToProperty.get(clazz);
			String className = environment.getProperty(name + "." + NAMESPACE + "." + classNameProperty);
			return className;
		}
		return null;

4.配置文件中我们只需要配置所需要的配置即可：

ribbon.NFLoadBalancerRuleClassName=自定义负载均衡策略
loadBalancedService=需要使用自定义负载均衡策略的服务