微服务（SpringCloud）使用汇总

<!--打包方式-->
<packaging>pom</packaging>
 <!--定义版本号-->
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-cloud.version>Hoxton.SR8</spring-cloud.version>
        <spring-cloud-alibaba.version>2.2.3.RELEASE</spring-cloud-alibaba.version>
    </properties>

    <!--dependencyManagement:它只负责jar的版本号管理，不负责jar的下载,交于子模块，子模块在使用时无需指定版本号
          :springboot springcloud  springcloudalibaba之间版本一定要匹配
    -->
    <dependencyManagement>
        <dependencies>
            <!--springcloud的版本管理-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--springcloudalibaba的版本管理-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

版本对应：

2.2 创建springcloud-commom公共模块

2.2.1 添加依赖

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.2</version>
        </dependency>
    </dependencies>

依赖中有对应的父工程

2.2.2 创建对应实体类

用户实体类：

@Data
@TableName("shop_order")
public class Order {
    @TableId(type = IdType.AUTO)
    private Long oid; //订单id
    private Integer uid;//用户id
    private String username;//用户名
    private Integer pid;//商品id
    private String pname;//商品名称
    private Double pprice;//商品价格
    private Integer number;//购买数量
}

产品对应实体类：

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName(value="shop_product")
public class Product {
    @TableId(type= IdType.AUTO)
    private Integer pid;
    private String pname;//商品名称
    private Double pprice;//商品价格
    private Integer stock;//库存
}

2.2.3 返回公共类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult {
    private Integer code;
    private String msg;
    private Object data;
}

2.3 创建springcloud-product产品模块

2.3.1 依赖

<dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.3.12.RELEASE</version>
        </dependency>
        <!--引用common内的所有的内容-->
        <dependency>
            <groupId>com.qy151wd</groupId>
            <artifactId>springcloud-common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

2.3.2 controller层

@RestController
@RequestMapping("/product")
public class ProductController {
    @Autowired
    private ProductService productService;

    @GetMapping("/findById/{pid}")
    public CommonResult findById(@PathVariable Integer pid){
        return productService.findById(pid);
    }
}

2.3.3 dao包

@Mapper
public interface ProductMapper extends BaseMapper<Product> {
}

2.3.4 service层

@Service
public class ProductService {
    @Autowired
    private ProductMapper productMapper;
    public CommonResult findById(Integer pid) {
        Product product = productMapper.selectById(pid);
        if(product!=null){
            return new CommonResult(2000,"查询成功",product);
        }else{
            return new CommonResult(5000,"查询失败",null);
        }
    }
}

2.3.5 配置类

#产品端口为8081——8089
server.port=8081

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.password=123456
spring.datasource.username=root
spring.datasource.url=jdbc:mysql://localhost:3306/student?serverTimezone=Asia/Shanghai

#打印日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

2.3.6 启动类

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

2.4 创建springcloud-order用户模块

2.4.1 依赖

<dependencies>
        <!--可以获取这两个所对应的依赖-->
        <dependency>
            <groupId>com.qy151wd</groupId>
            <artifactId>springcloud-common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.qy151wd</groupId>
            <artifactId>springcloud-product</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

2.4.2 controller层

@RestController
@RequestMapping("/order")
public class OrderController {
    @Autowired
    private OrderService orderService;

    @GetMapping("/buy/{pid}/{pnumber}")
    public CommonResult buy(@PathVariable Integer pid,@PathVariable Integer pnumber){
        return orderService.buy(pid,pnumber);
    }
}

2.4.3 dao包

@Mapper
public interface OrderMapper extends BaseMapper<Order> {
}

2.4.4 service层

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RestTemplate restTemplate;
    public CommonResult buy(Integer pid, Integer pnumber) {
        Order order=new Order();
        order.setUid(1010);
        order.setUsername("gzh");
        order.setPid(pid);
        order.setNumber(pnumber);
        //需要设置订单对象中商品的信息
        //商品操作都在商品微服务---订单微服务远程调用商品微服务即可拿到商品信息。远程调用:http协议的restFul风格调用适合微服务， 基于TCP协议的RPC调用适合SOA分布式
        //一定采用的为http协议: （1）自己写代码完成http调用【httpclient】微信支付 ---适合调用第三方网址。 （2）spring提高了一个工具类RestTemplate，该类也是基于http协议完成的调用
        CommonResult forObject = restTemplate.getForObject("http://localhost:8081/product/findById/" + pid, CommonResult.class);
        System.out.println("==========================="+forObject);
        //把json数据转换为java对象
        Product product = new ObjectMapper().convertValue(forObject.getData(),Product.class);

        order.setPname(product.getPname());
        order.setPprice(product.getPprice());
        int insert = orderMapper.insert(order);
        if(insert>0){
            return new CommonResult(2000,"添加成功",null);
        }else{
            return new CommonResult(5000,"添加失败",null);
        }
    }
}

2.4.5 启动类

@SpringBootApplication
public class ApplicationOrderRun {
    public static void main(String[] args) {
        SpringApplication.run(ApplicationOrderRun.class,args);
    }
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

2.4.6 配置类

#产品端口为8091——8099
server.port=8091

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.password=123456
spring.datasource.username=root
spring.datasource.url=jdbc:mysql://localhost:3306/student?serverTimezone=Asia/Shanghai

#打印日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

3.Nacos Discovery--服务治理

3.1 为何使用服务治理

通过之前的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址

（ip，端口）等硬编码到了代码中，这种做法存在许多问题：

（1）一旦服务提供者地址变化，就需要手工修改代码

（2）一旦是多个服务提供者，无法实现负载均衡功能

（3）一旦服务变得越来越多，人工维护调用关系困难

那么应该怎么解决呢，这时候就需要通过注册中心动态的实现服务治理。

3.2 什么是服务治理

服务治理是微服务架构中最核心最基本的模块。用于实现各个微服务的自动化注册与发现。

服务注册：在服务治理框架中，都会构建一个注册中心，每个服务单元向注册中心登记自己

提供服务的详细信息。并在注册中心形成一张服务的清单，服务注册中心需要以心跳30s 90s的方

式去监测清单中的服务是否可用，如果不可用，需要在服务清单中剔除不可用的服务。

服务发现：服务调用方向服务注册中心咨询服务，并获取所有服务的实例清单，实现对具体服务实例的访问。

注册中心一般包含如下几个功能：

1. 服务发现：

服务注册：保存服务提供者和服务调用者的信息

服务订阅：服务调用者订阅服务提供者的信息，注册中心向订阅者推送提供者的信息

2. 服务配置：

配置订阅：服务提供者和服务调用者订阅微服务相关的配置

配置下发：主动将配置推送给服务提供者和服务调用者

3. 服务健康检测

检测服务提供者的健康情况，如果发现异常，执行服务剔除

3.3 常见注册中心

Zookeeper

zookeeper是一个分布式服务框架，是Apache Hadoop 的一个子项目，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步服务、集群管理、分布式应用配置项的管理等。

Eureka

Eureka是Springcloud Netflix中的重要组件，主要作用就是做服务注册和发现。但是现在已经闭源，停更不停用。

Consul

Consul是基于GO语言开发的开源工具，主要面向分布式，服务化的系统提供服务注册、服务发现和配置管理的功能。Consul的功能都很实用，其中包括：服务注册/发现、健康检查、Key/Value存储、多数据中心和分布式一致性保证等特性。Consul本身只是一个二进制的可执行文件，所以安装和部署都非常简单，只需要从官网下载后，在执行对应的启动脚本即可。

Nacos (服务治理配置中心)

Nacos是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。它是 SpringCloud Alibaba 组件之一，负责服务注册发现和服务配置，可以这样认为nacos=eureka+config。

4.关于注册中心Nacos

4.1 nacos简介

Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助快速实现动态服务发现、服务配置、服务元数据及流量管理。

从上面的介绍就可以看出，nacos的作用就是一个注册中心，用来管理注册上来的各个微服务。

4.2 nacos实战入门

接下来，我们就在现有的环境中下载nacos，并将我们的两个微服务注册上去。

Releases · alibaba/nacos · GitHub

4.2.1 搭建nacos环境

第1步: 安装nacos（根据上边网址，下载zip格式的安装包，然后进行解压缩操作）

第2步: 启动nacos

#切换目录表名在当前安装目录下进入cmd命令

cd nacos/bin

#命令启动

startup.cmd -m standalone

第3步: 访问nacos

打开浏览器输入http://localhost:8848/nacos，即可访问服务，默认密码是nacos/nacos

4.2.2 将商品(product)微服务注册到nacos

接下来开始修改 springcloud-product 模块的代码，将其注册到nacos服务上。

1.在pom.xml中添加nacos的依赖

<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

2.在application.properties添加nacos的配置

#指定nacos注册中心地址 ip:port
spring.cloud.nacos.discovery.server-addr=localhost:8848

#指定微服务的名称，名称可以随便起，可在nacos处查看
spring.application.name=springcloud-product

3.开启两个相同的服务（模拟相同的项目部署到不同的服务器上）

4.启动服务，观察nacos的控制面板中是否有注册上来的商品微服务

4.2.3 将订单微服务注册到nacos

接下来开始修改 springcloud-order 模块的代码，将其注册到nacos服务上

1.在pom.xml中添加nacos的依赖(若之前图方便直接引用了product的依赖，可忽略)

<dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
    </dependencies>

2.在主启动类上添加nacos的开启注解

3.在application.properties添加nacos的配置

#指定nacos注册中心地址 ip:port
spring.cloud.nacos.discovery.server-addr=localhost:8848

#指定是否把该服务器注册到注册中心
#spring.cloud.nacos.discovery.register-enabled=false

#起个微服务的名称
spring.application.name=springcloud-order

4.启动服务，观察nacos的控制面板中是否有注册上来的商品微服务

5.修改orderService服务层代码（此处为只访问一个）

@Service
public class OrderService02 {
    @Autowired
    private OrderMapper orderMapper;
    //此处之所以可以引用，是因为引入依赖spring-cloud-starter-alibaba-nacos-discovery
    //spring中提供了一个工具类，该类可以从注册中心拉取微服务信息
    @Autowired
    private DiscoveryClient discoveryClient;
    @Autowired
    private RestTemplate restTemplate;

    public CommonResult buy(Integer pid, Integer pnumber) {
        Order order=new Order();
        order.setUid(1010);
        order.setUsername("gzh");
        order.setPid(pid);
        order.setNumber(pnumber);

        //根据服务名称获取对应的所有实例对象
        List<ServiceInstance> instances = discoveryClient.getInstances("springcloud-product");
        //获取第一个实例对象,下标在nacos为0处的端口启动类
        ServiceInstance serviceInstance = instances.get(0);
//        serviceInstance.getHost();//主机ip
//        serviceInstance.getPort();//主机端口号
        String path = serviceInstance.getUri().toString();

        //CommonResult.class返回的类型要和Controller类型一致
        CommonResult forObject = restTemplate.getForObject(path + "/product/findById/" + pid, CommonResult.class);
        //把json数据变为java对象
        Product product = new ObjectMapper().convertValue(forObject.getData(), Product.class);

        System.out.println("==========================="+product);

        order.setPname(product.getPname());
        order.setPprice(product.getPprice());
        int insert = orderMapper.insert(order);
        if(insert>0){
            return new CommonResult(2000,"添加成功",null);
        }else{
            return new CommonResult(5000,"添加失败",null);
        }
    }
}

6.启动服务，观察nacos的控制面板中是否有注册上来的订单微服务，然后通过访问消费者服务验证调用是否成功

4.3 实现服务调用的负载均衡

4.3.1 什么是负载均衡 nginx

通俗的讲，负载均衡就是将负载（工作任务，访问请求）进行分摊到多个操作单元（服务器,组件）上进行执行。

根据负载均衡发生位置的不同,一般分为服务端负载均衡和客户端负载均衡。

服务端负载均衡指的是发生在服务提供者一方,比如常见的nginx负载均衡

而客户端负载均衡指的是发生在服务请求的一方，也就是在发送请求之前已经选好了由哪个实例处理请求

我们在微服务调用关系中一般会选择客户端负载均衡，也就是在服务调用的一方来决定服务由哪个提供者执行.

4.3.2 自定义实现负载均衡

1. 通过idea再启动一个 shop-product 微服务，设置其端口为8082

2 通过nacos查看微服务的启动情况

3 修改orderService服务层代码（此处为手写随机访问策略）

@Service
public class OrderService03 {
    @Autowired
    private OrderMapper orderMapper;
    //此处之所以可以引用，是因为引入依赖spring-cloud-starter-alibaba-nacos-discovery
    //spring中提供了一个工具类，该类可以从注册中心拉取微服务信息
    @Autowired
    private DiscoveryClient discoveryClient;
    @Autowired
    private RestTemplate restTemplate;

    public CommonResult buy(Integer pid, Integer pnumber) {
        Order order=new Order();
        order.setUid(1010);
        order.setUsername("gzh");
        order.setPid(pid);
        order.setNumber(pnumber);

        //根据服务名称获取对应的所有实例对象
        List<ServiceInstance> instances = discoveryClient.getInstances("springcloud-product");
        //随机获取实例对象 new Random().nextInt(instance.size())
        //或随机获取实例对象通过 （int）(Math.random()*instances.size())
        ServiceInstance serviceInstance = instances.get(new Random().nextInt(instances.size()));
//        serviceInstance.getHost();//主机ip
//        serviceInstance.getPort();//主机端口号
        String path = serviceInstance.getUri().toString();

        //CommonResult.class返回的类型要和Controller类型一致
        CommonResult forObject = restTemplate.getForObject(path + "/product/findById/" + pid, CommonResult.class);
        //把json数据变为java对象
        Product product = new ObjectMapper().convertValue(forObject.getData(), Product.class);

        System.out.println("==========================="+product);

        order.setPname(product.getPname());
        order.setPprice(product.getPprice());
        int insert = orderMapper.insert(order);
        if(insert>0){
            return new CommonResult(2000,"添加成功",null);
        }else{
            return new CommonResult(5000,"添加失败",null);
        }
    }
}

4. 启动两个服务提供者和一个服务消费者，多访问几次消费者测试效果

4.3.3 基于Ribbon实现负载均衡 ---组件

1.什么是Ribbon
是 Netflix 发布的一个负载均衡器，有助于控制 HTTP 和 TCP客户端行为。在 SpringCloud 中， nacos一般配合Ribbon进行使用，Ribbon提供了客户端负载均衡的功能，Ribbon利用从nacos中读取到的服务信息，在调用服务节点提供的服务时，会合理（策略）的进行负载。

在SpringCloud中可以将注册中心和Ribbon配合使用，Ribbon自动的从注册中心中获取服务提供者的列表信息，并基于内置的负载均衡算法，请求服务。

是 Netflix 发布的一个负载均衡器，Ribbon自动的从注册中心中获取服务提供者的列表信息，并基于内置的负载均衡算法，请求服务。

2.Ribbon的主要作用

（1）服务调用

基于Ribbon实现服务调用，是通过拉取到的所有服务列表组成（服务名-请求路径的）映射关系。借助 RestTemplate 最终进行调用

（2）负载均衡

当有多个服务提供者时，Ribbon可以根据负载均衡的算法自动的选择需要调用的服务地址

Ribbon是Spring Cloud的一个组件，它可以让我们使用一个注解就能轻松的搞定负载均衡

第1步：在RestTemplate 的生成方法上添加@LoadBalanced注解

第2步：修改服务调用的方法(若配置类不进行修改，默认为负载均衡策略)

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private RestTemplate restTemplate;

    public CommonResult buy(Integer pid, Integer pnumber) {
        Order order=new Order();
        order.setUid(1010);
        order.setUsername("gzh");
        order.setPid(pid);
        order.setNumber(pnumber);

        //restTemplate调用处必须 http://服务提供资源路径
        CommonResult forObject = restTemplate.getForObject( "http://springcloud-product/product/findById/" + pid, CommonResult.class);
        //把json数据变为java对象
        Product product = new ObjectMapper().convertValue(forObject.getData(), Product.class);

        System.out.println("==========================="+product);

        order.setPname(product.getPname());
        order.setPprice(product.getPprice());
        int insert = orderMapper.insert(order);
        if(insert>0){
            return new CommonResult(2000,"添加成功",null);
        }else{
            return new CommonResult(5000,"添加失败",null);
        }
    }
}

Ribbon支持的负载均衡策略：

Ribbon内置了多种负载均衡策略,内部负载均衡的顶级接口为com.netflix.loadbalancer.IRule , 具体的负载策略如下图所示:

修改方式是在配置文件中添加:

#指定ribbon负载均衡的策略:springcloud-product微服务名称.ribbon.NFLoadBalancerRuleClassName=负载均衡策略类

springcloud-product.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule

4.4 基于OpenFeign实现服务调用

4.4.1 什么是OpenFeign

OpenFeign是Spring Cloud提供的一个声明式的伪Http客户端，它使得调用远程服务就像调用本地服务一样简单，只需要创建一个接口并添加一个注解即可。

Nacos很好的兼容了Feign， Feign负载均衡默认集成了 Ribbon，所以在Nacos下使用Fegin默认就实现了负载均衡的效果。

4.4.2 OpenFeign的使用

1 加入OpenFegin的依赖

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

2 在主启动类上加入开启feign的注解

3 创建feign的接口

//被调用的微服务名称
@FeignClient(value = "springcloud-product")
public interface ProductFeign {
    @RequestMapping("/product/findById/{pid}")
    public CommonResult findById(@PathVariable Integer pid);
}

4 修改OrderController的代码

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;


    @Autowired
    private ProductFeign productFeign;
    public CommonResult buy(Integer pid, Integer pnumber) {
        Order order=new Order();
        order.setUid(1010);
        order.setUsername("gzh");
        order.setPid(pid);
        order.setNumber(pnumber);

        CommonResult byId = productFeign.findById(pid);
        Product product = new ObjectMapper().convertValue(byId.getData(), Product.class);

        order.setPname(product.getPname());
        order.setPprice(product.getPprice());
        int insert = orderMapper.insert(order);
        if(insert>0){
            return new CommonResult(2000,"添加成功",null);
        }else{
            return new CommonResult(5000,"添加失败",null);
        }
    }
}

5 重启order微服务，查看效果

5.使用eureka作为注册中心

5.1 什么是eureka

Eureka是Netflix开发的服务发现框架，SpringCloud将它集成在自己的子项目spring-cloud-netflix中,实现SpringCloud的服务发现功能。

5.2 如何使用

5.2.1 创建一个eureka服务端

1.添加依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

2.添加配置类

server.port=7000

eureka.instance.hostname=localhost
#是否注册自己
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
#eureka访问地址
eureka.client.service-url.defaultZone=http://localhost:7001/eureka/

3.添加启动类

@SpringBootApplication
@EnableEurekaServer//eureka服务端
public class EurekaRun {
    public static void main(String[] args) {
        SpringApplication.run(EurekaRun.class,args);
    }
}

4.测试

5.2.2 注册product商品服务

1.添加依赖

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

2.启动类

3.配置类

eureka.client.service-url.defaultZone=http://localhost:7000/eureka/

eureka.instance.appname=product

4.测试结果

6.集群的部署

在实际开发过程中，如果使用Nacos的话，为了确保高可用，避免一台Nacos因为其他原因宕机，造成系统瘫痪，我们一般都会对其进行集群的部署。Nacos规定集群中Nacos节点的数量需要大于等于3个；同时，单机模式下Nacos的数据默认保存在其内嵌数据库中deby，不方便观察数据存储的基本情况。而且如果集群中启动多个默认配置下的Nacos节点，数据存储是存在一致性问题的。为了解决这个问题，Nacos采用了集中式存储的方式来支持集群化部署，目前只支持MySQL的存储；此外，我们还需要借助Nginx实现负载均衡。这一过程的部署架构图如下所示：

1. 准备三个 nacos 服务器 --- 为了操作方便统一部署到同一台电脑

【 8849.8850.8851 】

2. 准备 mysql--- 创建一个 nacos-config-- 创建相应的表

6.1 创建数据库

在数据库中创建nacos-config，表中内容由上述自带mysql内容：

6.2 指定使用mysql作为数据存储

6.3 配置集群文件

6.4 停止nacos并复制三份

并修改每一份的端口号

6.5 启动三个nacos并查看结果

6.6 搭建nginx代理上面三个nacos

6.7 微服务注册到nacos集群上

7.gateway网关

7.1 为何使用网关

大家都都知道在微服务架构中，一个系统会被拆分为很多个微服务。那么作为客户端（pc androud ios 平板）要如何去调用这么多的微服务呢？如果没有网关的存在，我们只能在客户端记录每个微服务的地址，然后分别去调用。

这样的架构，会存在着诸多的问题：

（1）客户端多次请求不同的微服务，增加客户端代码或配置编写的复杂性

（2）认证复杂，每个服务都需要独立认证。

（3）存在跨域请求，在一定场景下处理相对复杂。

上面的这些问题可以借助API网关来解决。
所谓的API网关，就是指系统的统一入口，它封装了应用程序的内部结构，为客户端提供统一服务，一些与业务本身功能无关的公共逻辑可以在这里实现，诸如认证、鉴权、监控（黑白名单）、路由转发等等。添加上API网关之后，系统的架构图就变成了如下所示：

7.2 比较流行的网关

（1）Ngnix+lua
        使用nginx的反向代理和负载均衡可实现对api服务器的负载均衡及高可用
        lua是一种脚本语言,可以来编写一些简单的逻辑, nginx支持lua脚本
（2）Kong
        基于Nginx+Lua开发，性能高，稳定，有多个可用的插件(限流、鉴权等等)可以开箱即用。问题：只支持Http协议；二次开发，自由扩展困难；提供管理API，缺乏更易用的管控、配置方式。
（3）Zuul 1.0（慢 servlet 2.0 ） zuul2.0 没出来。
        Netflix开源的网关，功能丰富，使用JAVA开发，易于二次开发问题：缺乏管控，无法动态配
置；依赖组件较多；处理Http请求依赖的是Web容器，性能不如Nginx
（4）Spring Cloud Gateway
        Spring公司为了替换Zuul而开发的网关服务，将在下面具体介绍。
        注意：SpringCloud alibaba技术栈中并没有提供自己的网关，我们可以采用Spring Cloud Gateway来做网关

7.3 如何使用gateway网关

(1 )创建一个 gateway 微服务模块

(2)加入相关的依赖

<dependencies>
        

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
    </dependencies>

(3) 配置文件

此处使用yml文件，注意层级关系

server:
  port: 7000

spring:
  application:
    name: springcloud-gateway

# 路由转发 List<RouteDefinition> routes进去这个route查看结果
  cloud:
    gateway:
      routes:
        - id: springcloud-product
        #路由转发的真实地址
          uri: http://localhost:8081
        # predicates ；当满足断言时，才会转发到真实的uri地址

          predicates:
          - Path=/product/**

        - id: springcloud-order
          uri: http://localhost:8091
          predicates:
            - Path=/order/**

(4)主启动类

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

(5)测试结果

(6)常见错误

出现微服务注册不到nacos上报错，因为我们开着虚拟机的虚拟ip，需要将nacos中配置的ip地址换为我们真实的ip地址，或者关闭虚拟机ip

7.4 让gateway网关从注册中心拉取服务型

发现: 路由配置时uri的地址还是一个固定的网络地址，如果后期微服务地址发送改变，也需要修改网关的配置。不能完成负载均衡。

解决: 我们知道，gateway他也是可一个微服务，它可以从注册中心拉取服务信息。

（1 ）引入依赖

<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

（2 ）配置文件中指定注册中心的地址

7.5 自动路由

发现: 有一个微服务需要配置一个路由，如果这时增加一个新的微服务，则需要在配置文件中增加一个新的路由配置。

能不能自动路由转发微服务呢!====能

（1）修改配置文件

（2）测试结果

7.6 介绍gateway断言

Predicate(断言, 谓词) 用于进行条件判断，只有断言都返回真，才会真正的执行路由。
断言就是说: 在什么条件下才能进行路由转发

SpringCloud Gateway包括许多内置的断言工厂，所有这些断言都与HTTP请求的不同属性匹配体如下：
（1）基于Datetime类型的断言工厂

此类型的断言根据时间做判断，主要有三个：

AfterRoutePredicateFactory：接收一个日期参数，判断请求日期是否晚于指定日期

BeforeRoutePredicateFactory：接收一个日期参数，判断请求日期是否早于指定日期

BetweenRoutePredicateFactory：接收两个日期参数，判断请求日期是否在指定时间段内

-After=2019-12-31T23:59:59.789+08:00[Asia/Shanghai]

（2）基于远程地址的断言工厂 RemoteAddrRoutePredicateFactory：

接收一个IP地址段，判断请求主机地址是否在地址段中

-RemoteAddr=192.168.1.1/24

（3）基于Cookie的断言工厂

CookieRoutePredicateFactory：接收两个参数，cookie 名字和一个正则表达式。判断请求

cookie是否具有给定名称且值与正则表达式匹配。

-Cookie=chocolate, ch.

（4）基于Header的断言工厂

HeaderRoutePredicateFactory：接收两个参数，标题名称和正则表达式。判断请求Header是否具有给定名称且值与正则表达式匹配。 key value

-Header=X-Request-Id, \d+

（5）基于Host的断言工厂

HostRoutePredicateFactory：接收一个参数，主机名模式。判断请求的Host是否满足匹配规则。

-Host=**.testhost.org

（6）基于Method请求方法的断言工厂

MethodRoutePredicateFactory：接收一个参数，判断请求类型是否跟指定的类型匹配。

-Method=GET

（7）基于Path请求路径的断言工厂

PathRoutePredicateFactory：接收一个参数，判断请求的URI部分是否满足路径规则。

-Path=/foo/{segment}基于Query请求参数的断言工厂

QueryRoutePredicateFactory ：接收两个参数，请求param和正则表达式，判断请求参数是否具有给定名称且值与正则表达式匹配。

-Query=baz, ba.

（8）基于路由权重的断言工厂

WeightRoutePredicateFactory：接收一个[组名,权重], 然后对于同一个组内的路由按照权重转发

routes:

-id: weight_route1 uri: host1 predicates:

-Path=/product/**

-Weight=group3, 1

-id: weight_route2 uri: host2 predicates:

-Path=/product/**

-Weight= group3, 9

（9）内置路由断言工厂的使用

7.7 全局过滤器

开发中的鉴权逻辑：
（1）当客户端第一次请求服务时，服务端对用户进行信息认证（登录）
（2）认证通过，将用户信息进行加密形成token，返回给客户端aaaa，作为登录凭证
（3）以后每次请求，客户端都携带认证的token
（4）服务端对token进行解密，判断是否有效。

如上图，对于验证用户是否已经登录鉴权的过程可以在网关统一检验。

检验的标准就是请求中是否携带token凭证以及token的正确性。

下面的我们自定义一个GlobalFilter，去校验所有请求的请求参数中是否包含“token”，如何不包含

请求参数“token”则不转发路由，否则执行正常的逻辑

自定义全局过滤器：

7.7.1 loginFilter

@Component
public class LoginFilter implements GlobalFilter , Ordered {
    @Autowired
    private Anon anon;
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        //0.获取请求
        String path = request.getPath().toString();
        //1.判断当前请求路径是否为放行路径
        if(anon.getUrl().contains(path)){
            return chain.filter(exchange);//放行
        }
        //2.判断是否携带token
        String token = request.getHeaders().getFirst("token");
        if(StringUtils.hasText(token)&&"admin".equals(token)){//此处写为硬代码
            return chain.filter(exchange);
        }
        //3.1 设置状态码
        response.setStatusCode(HttpStatus.UNAUTHORIZED);
        //3.2 封装返回数据
        Map<String,Object> map=new HashMap<>();
        map.put("msg","未登录");
        map.put("code",4000);
        //3.3 做json转换
        byte[] bytes = JSON.toJSONString(map).getBytes(StandardCharsets.UTF_8);
        //3.4. 调用bufferFactory方法，生成DataBuffer对象
        DataBuffer buffer = response.bufferFactory().wrap(bytes);
        //4.调用Mono中just方法，返回要写给前端的JSON数据
        return response.writeWith(Mono.just(buffer));
    }

    //优先级 返回的值越小优先级越高
    @Override
    public int getOrder() {
        return 0;
    }
}

7.7.2 Anon实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
@ConfigurationProperties(prefix = "anon")//前缀名
public class Anon {
    private List<String> url;
}

7.7.3 所需依赖

<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

7.7.4 所需配置（.properties文件）

anon.url[0]=/sso/login
anon.url[1]=/springcloud-product/product/getMsg

青柠果

关注

4
点赞
踩
8

收藏

觉得还不错? 一键收藏
1
评论
微服务（SpringCloud）使用汇总

微服务架构，简单的说就是将单体应用进一步拆分，拆分成更小的服务，每个服务都是一个可以独立运行的项目。服务治理是微服务架构中最核心最基本的模块。用于实现各个微服务的自动化注册与发现。服务注册：在服务治理框架中，都会构建一个注册中心，每个服务单元向注册中心登记自己提供服务的详细信息。并在注册中心形成一张服务的清单，服务注册中心需要以心跳30s 90s的方式去监测清单中的服务是否可用，如果不可用，需要在服务清单中剔除不可用的服务。
复制链接

扫一扫

专栏目录