微服务——SpringCloud

一、认识微服务

微服务是一种经过良好架构设计的分布式架构方案，微服务架构特征：
● 单一职责：微服务拆分力度更小，每一个服务都应对唯一的业务能力，做到单一职责，避免重复业务开发

● 面向服务：微服务对外暴露业务接口

● 自治：团队独立、技术独立、数据独立、部署独立

● 隔离性强：服务调用做好隔离、容错、降级，避免出现级联问题

优点： 拆分粒度更小、服务更独立、耦合度更低
缺点： 架构非常复杂，运维、监控、部署难度提高

微服务结构
微服务这种方案需要技术框架来落地，全球的互联网公司都在积极尝试自己的微服务落地技术。在国内最知名的就是SpringCloud和阿里巴巴的Dubbo。

微服务技术对比：

	Dubbo	SpringCloud	SpringCloudAlibaba
注册中心	zookeeper	Eureka 、Consul	Nacos、Eureka
服务远程调用	Dubbo协议	Feign（http协议）	Doubbo、Feign
配置中心	无	SpringCloudConfig	SpringCloudConfig、Nacos
服务网关	无	SpringCloudGateway、Zuul	SpringCouldGateway、Zuul
服务监控和保护	dubbo-admin，功能弱	Hystrix	Sentinel

企业需求

二、SpringCloud

● SpringCloud是目前国内使用最广泛的微服务框架。官方地址：http://spring.io/projects/spring-cloud

● SpringCloud集成了各种微服务功能组件，并基于SpringBoot实现了这些组件的自动装配，从而提供了良好的开箱即用体验

● SpringCloud与SpringBoot的版本兼容关系如下：

三、服务拆分及调用

服务拆分注意事项

1、不同的微服务，不要重复开发相同的业务

2、微服务数据独立，不要访问其他微服务的数据库

3、微服务可以将自己的业务暴露为接口，供其他微服务调用

微服务拆分案例

将用户模块与订单模块进行拆分

微服务调用

● 基于RestTemplate发起http请求实现远程调用

● http请求做远程调用是与语言无关的调用，只要知道对方的ip、端口、接口路径、请求参数即可

需求： 根据订单id查询订单的同时，将订单所属的用户信息一起返回
步骤
1、注册 RestTemplate（在order-service的OrderApplication中注册RestTemplate）

  @MapperScan("cn.itcast.order.mapper")
  @SpringBootApplication
   public class OrderApplication {
   public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }

    //创建RestTemplate并注入Spring容器
  @Bean
    public RestTemplate  restTemplate(){
        return  new RestTemplate();
  }
 }

2、远程服务调用RestTemplate中的order-service的queryOrderById方法

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RestTemplate restTemplate;

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        // 2.利用RestTemplate发起http请求(get请求），实现远程调用
       User user= restTemplate.getForObject("http://localhost:8081/user/"+order.getUserId(), User.class);
        // 3.封装User对象到Order
        order.setUser(user);
        // 4.返回
        return order;
    }
}

提供者与消费者
● 服务提供者：一次业务中，被其他微服务调用的服务。（提供接口给其他微服务）

● 服务消费者：一次业务中，调用其他微服务的服务。（调用其他微服务的接口）

【 问题】服务A调用服务B，服务B调用服务C，那么服务B是什么角色？

● 提供者与消费者角色是相对的
● 一个服务可以同时是服务提供者和服务消费者

四、Eureka注册中心

Eureka原理

远程调用的问题：硬编码、为应对更多并发,服务可能部署为多实例形成集群，此时硬编码该如何写哪个地址

● 服务消费者该如何获取服务提供者的地址信息？
         微服务启动时均向eureka注册自己的信息 
         eureka保存这些信息
         消费者根据服务名称向 eureka 拉取提供者信息

● 如果有多个服务提供者，消费者该如何选择？
         服务消费者利用负载均衡算法，从服务列表中挑选一个
              
● 消费者该如何得知提供服务者的健康状态？
         服务提供者会每隔30秒向 EurekaServer发送心跳请求，报告健康状态
         eureka会更新记录服务列表信息，心跳不正常会被剔除
         消费者就不可以拉取到最新的信息

在Eureka架构中，微服务角色有两种：

●  EurekaServer：服务端，注册中心
      ◆ 记录服务信息
      ◆ 心跳监控

●  EurekaClient：客户端
      ◆ Provider：服务提供者，例如案例中的user-service
            注册自己的信息到EurekaServer
            每隔30秒向EurekaServer发送心跳
      ◆ consumer：服务消费者，例如案例中的order-service
            根据服务名称从EurekaServer拉取服务列表
            基于服务列表做负载均衡，选中一个微服务后发起远程调用

搭建EurekaServer

1、在父工程下创建项目（eureka-server），引入spring-cloud-starter-netflix-eureka-server的依赖

<!--eureka服务端依赖-->
<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>

2、编写启动类，添加注解

package com.GY.eureka;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class,args);
    }
}

3、添加application.yml文件，编写下面的配置：

server:
  port: 10086  #服务端口
spring:
  application:
    name: eurekaserver  #eureka的服务名称
eureka:
    client:
      service-url:      #eureka的地址信息
        defaultZone: http://127.0.0.1:10086/eureka

服务注册

将user-service服务注册到Eurekaserver中
① 在user-service项目引入spring-cloud-starter-netflix-eureka-client的依赖

<!--eureka客户端依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

②在application.yml文件，编写下面的配置

spring:
  application:
    name: userserver  #user服务的服务名称
eureka:
    client:
      service-url:     
        defaultZone: http://127.0.0.1:10086/eureka

启动服务，此时均已注册到Eureka服务列表中

【另外，我们可以将user-service多次启动，模拟多实例部署，但是为了避免端口冲突，需要修改端口设置】

注册user-service多实例成功

服务发现

在order-service完成服务拉取（服务拉取是基于服务名称获取服务列表，然后再对服务器列表做负载均衡）
① 修改order-service的代码，修改访问的路径，用服务名代替 ip、端口

User user= restTemplate.getForObject("http://userservice/user/"+order.getUserId(), User.class);

② 在order-service项目的启动类OrderApplication中的RestTemplate添加负载均衡注解：

@Bean
@LoadBalanced    //负载均衡
    public RestTemplate  restTemplate(){
        return  new RestTemplate();
 }

五、Ribbon负载均衡

负载均衡

负载均衡流程

负载均衡策略
Ribbon的负载均衡是一个叫做IRule的接口来实现的，每一个子接口都是一种规则：

通过定义IRule实现可以修改负载均衡规则，有两种方式（作用范围不同）
① 代码方式：在order-service中的OrderApplication类中，定义一个新的IRule【全局配置】

 @Bean
    public IRule randomRule(){
        return  new RandomRule();
        }

② 配置文件方式：在order-service的application.yml文件中，添加新的配置也可以修改规则【指定调用的服务做负载均衡（某个）】

userservice:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule  #负载均衡规则

饥饿加载

Ribbon默认采用懒加载，即第一次访问时才会去创建LoadBalanceClient，请求时间会很长。
而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，通过下面的配置开启饥饿加载：

ribbon:
  eager-load:
    enabled: true             #开启饥饿加载
    clients:  userservice     #指定饥饿加载的服务名称（list）

 clients:                     #加载多个
       - userservice
       - xxservice