SpringCloud超详细笔记（附源码）

已于 2022-02-08 11:57:05 修改
阅读量3.9k 收藏 72
点赞数 23
分类专栏： SpringCloud 文章标签： 1024程序员节 java 分布式 SpringCloud
于 2020-10-24 09:08:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42601136/article/details/109253906
版权

SpringCloud超详细笔记（附源码）

引言：

        本文主要分享了SpringCloud相关的知识，几乎包含了所有有关的知识并附有若干案例，篇幅较长；主要包括：SpringCloud五大神兽的简介、一个简单的访问外部链接的案例引入SpringCloud、Eureka的简介、Eureka的基本配置以及相关案例、Robbin（服务间的负载均衡）、Feign（服务间的调用）、基于Robbin与feign的增删查改案例、Hystrix（服务的隔离及断路器）、Zuul网关的简介及配置、Config（服务的动态配置）、Sidecar（多语言支持）的配置，均附加相应案例；

文章目录

0. 微服务

         微服务架构样式就是把一个单体项目拆分为多个微小的服务,每个微服务可以在自己的进程中运行并与HTTP资源API进行通信。围绕业务功能进行构建，独立技术选型，独立开发，独立部署，独立运维，并且多个服务相互协调，相互配合，最终完成用户的价值；

微服务与单体项目的区别：

  1. 单体架构所有的模块全都耦合在一块，代码量大，维护困难，微服务每个模块就相当于一个单独的项目，代码量明显减少，遇到问题也相对来说比较好解决。
  2. 单体架构所有的模块都共用一个数据库，存储方式比较单一，微服务每个模块都可以使用不同的存储方式（比如有的用redis，有的用mysql等），数据库也是单个模块对应自己的数据库。
  3. 单体架构所有的模块开发所使用的技术一样，微服务每个模块都可以使用不同的开发技术，开发模式更灵活。

注：

  • 微服务架构只是一个样式，一种风格；
  • 可以将一个项目，拆分成多个模块去开发；
  • 每一个模块都是单独运行在自己的容器中的；
  • 每个模块需要相互通讯（HTTP、MQ）；
  • 每一个模块之间没有依赖关系，都是单独部署；
  • 可以使用多种语言去开发不同模块；

将复杂的单体应用进行细粒度的划分，每个拆分出来的服务各自打包并且部署；

1. SpringCloud简介

         SpringCloud是一个基于Spring Boot实现的服务治理工具包，在微服务架构中用于管理和协调服务；

本文包含七个技术点：

  1. Eureka：服务的注册发现
  2. Robbin：服务之间的负载均衡
  3. Feign：服务之间的通讯
  4. Hystrix：服务 线程隔离以及断路器
  5. Zuul：服务网关
  6. Config：动态配置
  7. Sidecar：多语言支持

2. 利用httpClient访问外部链接

使用Java访问外部链接，也就是访问外部服务；用到httpClient

2.1 创建SpringBoot项目

创建一个简单的SpringBoot的Web项目，充当外部访问服务

在java文件下创建controller包，在包下创建ExportController，模拟外部服务！！！

@RestController
public class ExportController {
    @RequestMapping("/hello")
    public String sayHello(String name){
        return "welcome to web http service!!!";
    }
}

在这里插入图片描述

2.2 编写访问程序

新建一个项目，作为访问的程序；

  • 导入依赖
  • 编写代码

2.2.1 导入依赖

<!--添加HttpClient依赖-->
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
</dependency>

2.2.2 编写代码

在测试类中编写

  • 共有五步
package com.sx.kak;

import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;

@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class WebSpringcloud02ApplicationTests {
    /**
     * 远程过程调用
     * RPC
     * Remote   Procedure   Call
     * Java程序访问现有的网站
     * @throws IOException
     */

    @Test
    public void contextLoads() throws IOException {
//        1、获取一个可以关闭的http访问客户端
        CloseableHttpClient httpClient = HttpClients.createDefault();
        String url="http://localhost:8080/hello?name=kaka";
//        2、构造一个get请求
        HttpGet httpGet = new HttpGet(url);
//        3、使用http客户端对象发出get请求，获取response响应对象
        CloseableHttpResponse execute = httpClient.execute(httpGet);
        //4、获取相应状态码
        int i = execute.getStatusLine().getStatusCode();
        if(i == 200){
            //5、获取相应体中的实体内容
            HttpEntity entity = execute.getEntity();
            //通过EntityUtils工具类将实体转为字符串
            String result = EntityUtils.toString(entity);
            log.info("请求响应的结果："+result);
        }
    }
}

在这里插入图片描述

SpringCloud就是对以上的操作进行封装，不需要每次都记住连接，知道接口即可；

3. Eureka_服务的注册发现

          Eureka是服务的注册与发现，便于服务之间的相互调用，用于任何需要注册的场景；基于REST的服务，由两个组件组成：Eureka服务器和Eureka客户端；

类似于房屋中介

  • Eureka服务器用作服务注册服务器，也就是注册中心。
  • Eureka客户端是一个java客户端，用来简化与服务器的交互、作为轮询负载均衡器，并提供服务的故障切换支持；
  • Netflix在其生产环境中使用的是另外的客户端，它提供基于流量、资源利用率以及出错状态的加权负载均衡；

Eureka注册原理

首先搞清楚EurekaServer担任注册中心职责：

  1. 管理服务的注册
  2. 搜索服务
  3. 向调用者提供服务清单
  4. 监听服务状态，动态更新服务列表

从下图看出：

  • Eureka Server担任注册中心的角色，提供了服务的获取和注册功能；

  • Service Provider：服务提供者，将自身的服务注册到Eureka Server；

  • Service Consumer：服务调用者，从Eureka Server得到注册的服务列表，找到对应的服务地址调用并使用；

在这里插入图片描述

注册执行的步骤：

  1. 启动Eurekaserver
  2. 启动Provider-server（生产者启动）
  3. 向注册中心注册服务
  4. EurekaServer登记注册的服务，维护一个服务列表
  5. 启动Consumer-server（消费者启动 ），同时向注册中心注册滋生服务
  6. EurekaServer登记注册的服务，维护一个服务列表
  7. Consumer-server搜索服务
  8. 如果有，向Consumer-server返回一个服务清单
  9. 从服务清单中选择一个服务，获取服务的地址
  10. Consumer-server调用具体的服务（Producer-server）
  11. Producer-server返回响应服务结果
  12. EurekaServer通过心跳来检验Producer-server或者Consumer-server是否挂掉，默认情况下每30秒向注册中心的服务发送一次心跳，有响应表示存活；没有响应，隔60秒再次发送，还是没有响应；隔90秒再次发送一次请求；三次都没有响应就标记为不可达，需要使用时应该再次注册服务；
  13. 有两个EurekaService时应该互相注册，在第一个注册中心注册，注册不到在向下一个EurekaService中注册，直到注册成功（共同维护一份清单，只能在一份中看到清单）；

3.1 Eureka的简单引入

分别创建三个项目：作为Eureka的服务端、服务的提供者、服务的调用者；

3.1.1 Eureka的服务端

创建SpringBoot项目(springcloud_eurekaserver)，只导入Eureka Server；

  • 在启动文件中加入@EnableEurekaServer注解用于开启Eureka服务注册功能

在这里插入图片描述

<!--注册中心必须依赖的包-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

配置application.yml

server:
#默认端口号
  port: 8761
eureka:
  instance:
    hostname: 127.0.0.1
  client:
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      #是否注册，把自己当做一个服务注册到自身
    register-with-eureka: false
    #要不要抓取注册信息
    fetch-registry: false

运行结果

浏览器输入localhost:8761

在这里插入图片描述

3.1.2 服务的提供者

创建SpringBoot项目(springcloud_producer)，选择以下依赖；

  • 在启动文件中加入@EnableEurekaClient用于启动Eureka客户端注册功能

在这里插入图片描述

<!--web服务在EurekaServer中注册必须的依赖包-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

配置application.yml

在这里插入图片描述

编写MessageController

用于模拟提供者信息

@RestController
public class MessageController {
    @RequestMapping("/msg")
    public String getMsg(String name){
        return "this is a springcloud web service message"+name;
    }
}

在这里插入图片描述

3.1.3 服务的调用者

创建SpringBoot项目(springcloud_consumer)，选择以下依赖；

  • 在启动文件中加入@EnableEurekaClient用于启动Eureka客户端注册功能

在这里插入图片描述

<!--web服务在EurekaServer中注册必须的依赖包-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

配置application.yml

server:
  port: 9092
spring:
  application:
    name:  CONSUMER  #在eurekaserver中的服务名
#    注册中心的地址
eureka:
  client:
    service-url:
       defaultZone: http://localhost:8761/eureka

配置ConsumerMsgConfig

用于注册RestTemplate

@Configuration
public class ConsumerMsgConfig {
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

编写ConsumerMsgController

@RestController
public class ConsumerMsgController {
    //注入EurekaClient对象
    @Autowired(required = false)
    private EurekaClient eurekaClient;
    //提供访问webMVC服务
    @Autowired(required = false)
//    包含在springboot-web
    private RestTemplate restTemplate;

    @RequestMapping("/msg/{name}")
    public String getMsg(@PathVariable("name") String name) {
//        从EurekaClient中获取服务实例对象
        InstanceInfo producer = eurekaClient.getNextServerFromEureka("UNKNOWN", false);
        String url = producer.getHomePageUrl()+"msg?name="+name;
        System.out.println(url);
        String result = restTemplate.getForObject(url, String.class);
        return result;
    }
}

运行结果

在这里插入图片描述

在这里插入图片描述

  • 调用者访问到了提供者，实现了两单体项目的交互！！！

3.2 Eureka安全性的处理

创建一个SpringBoot的web项目

在这里插入图片描述

  • 在启动文件中加入@EnableEurekaServer注解用于开启Eureka服务注册功能

3.2.1 添加依赖

<!--添加security依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

3.2.2 配置application.yml

server:
  port: 8761
eureka:
  instance:
    hostname: 127.0.0.1
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
       defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
# 指定用户名和密码
spring:
  security:
    user:
      name: root
      password: root

3.2.3 编写WebSecurityConfig

用于拦截

@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter{
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 忽略掉/eureka/**
        http.csrf().ignoringAntMatchers("/eureka/**");
        super.configure(http);
    }
}

3.2.4 运行的结果

在这里插入图片描述
在这里插入图片描述

3.3 使用Eureka实现跨服务的增删查改

同上分别创建三个项目：作为Eureka的服务端、服务的提供者、服务的调用者；

  • 两个服务间交互，需要序列化
  • 链接的数据库：bd0711
  • 表名：student

3.3.1 Eureka的服务端

创建SpringBoot项目(springcloud_eurekaserver)，只导入Eureka Server；

  • 具体查看3.2板块

服务的提供者和服务调用者在编写代码前应看看是否写入成功！！！

在这里插入图片描述

3.3.2 服务的提供者

创建SpringBoot项目(springcloud_studentserver)，选择以下依赖；

在这里插入图片描述

3.3.2.1 配置application.yml

对格式的要求很严格

server:
   port: 8081
spring:
  application:
    name: student-service
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db0711?serverTimezone=UTC
    username: root
    password: root
eureka:
  client:
    service-url:
       defaultZone: http://root:root@localhost:8761/eureka
mybatis:
  mapper-locations: classpath:mapping/*.xml
  type-aliases-package: com.sx.kak.po
3.3.2.2 修改启动文件SpringcloudStudentserverApplication

在启动文件中加入@EnableEurekaClient用于启动Eureka客户端注册功能

/**
 * 对数据库的访问封装为一个服务
 */
@SpringBootApplication
@EnableEurekaClient
@MapperScan(basePackages = {"com.sx.kak.mapper"})
public class SpringcloudStudentserverApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringcloudStudentserverApplication.class, args);
    }
}
3.3.2.3 添加对应的mapper、po、mapping

操作数据库的基本技能，这里是利用mybatis-generator-core-1.3.2生成：参考Mybatis中自动生成代码(利用mybatis-generator-core-1.3.2)一文；

  • 注意序列化
3.3.2.4 编写ActionResult

用于接受传递状态

package com.sx.kak.utils;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;

import java.io.Serializable;

/**
 * 封装统一的响应对象
 * Created by Kak on 2020/9/22.
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ActionResult implements Serializable{
    private Integer statusCode;
    private String msg;
    private Object data;
}
3.3.2.5 编写Service服务层

分别对应增删查改包括单查

public interface StudentService {
    public List<Student> findAllStudentService();

    public Student addStudentService(Student student);

    public void updateStudent(Student student);

    public void deleteStudent(int id);

    public Student findOneById(int id);
}

package com.sx.kak.service.serviceImpl;

import com.sx.kak.mapper.StudentMapper;
import com.sx.kak.po.Student;
import com.sx.kak.po.StudentExample;
import com.sx.kak.service.StudentService;
import lombok.extern.log4j.Log4j;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * Created by Kak on 2020/9/22.
 */
@Service
@Slf4j
public class StudentServiceImpl implements StudentService {
    @Autowired(required = false)
    private StudentMapper studentMapper;

    @Override
    public List<Student> findAllStudentService() {
        try {
            StudentExample example = new StudentExample();
            List<Student> students = studentMapper.selectByExample(example);
            return students;
        } catch (Exception ex) {
            log.info(ex.getMessage());
        }
        return null;
    }

    @Override
    public Student addStudentService(Student student) {
        try {
            studentMapper.insertSelective(student);
            return student;
        } catch (Exception ex) {
            log.info(ex.getMessage());
        }
        return null;
    }

    @Override
    public void updateStudent(Student student) {
        try {
            studentMapper.updateByPrimaryKeySelective(student);
        } catch (Exception ex) {
            log.info(ex.getMessage());
        }
    }

    @Override
    public void deleteStudent(int id) {
        try {
            studentMapper.deleteByPrimaryKey(id);
        } catch (Exception ex) {
            log.info(ex.getMessage());
        }
    }

    @Override
    public Student findOneById(int id) {
        try{
            Student student = studentMapper.selectByPrimaryKey(id);
            return student;
        }catch (Exception ex){
            log.info(ex.getMessage());
        }
        return null;
    }
}
3.3.2.6编写StudentController

用于模拟提供者信息

package com.sx.kak.controller;

import com.sx.kak.po.Student;
import com.sx.kak.service.StudentService;
import com.sx.kak.utils.ActionResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * Created by Kak on 2020/9/22.
 */
@RestController
public class StudentController {
    @Autowired
    private StudentService studentService;

    @RequestMapping("/students")
    public ActionResult findAllStu(){
        List<Student> allStudentService = studentService.findAllStudentService();
        ActionResult actionResult = new ActionResult();
        actionResult.setStatusCode(200);
        actionResult.setData(allStudentService);
        return actionResult;
    }

    @RequestMapping("/student")
    public ActionResult findStuById(int id){
        System.out.println("getId =====:"+id);
        Student oneById = studentService.findOneById(id);
        System.out.println(oneById);
        ActionResult result = new ActionResult(200, "", oneById);
        return result;
    }

    @PostMapping("/student")
    public ActionResult addStu(@RequestBody Student student){
        System.out.println("生产端接收参数："+student);
        Student student1 = studentService.addStudentService(student);
        System.out.println(student1);
        ActionResult result = new ActionResult(200, "", student1);
        return result;
    }

    @PutMapping("/student")
    public ActionResult updateStudent(@RequestBody Student student){
        System.out.println("生产端接收参数："+ student);
        studentService.updateStudent(student);
        ActionResult result = new ActionResult(200, "update ok", null);
        return result;
    }

    @DeleteMapping("/student/{id}")
    public ActionResult deleteStudent(@PathVariable("id") int id ){
        System.out.println("生产端接收参数："+id);
        studentService.deleteStudent(id);
        ActionResult result = new ActionResult(200, "delete ok", null);
        return result;
    }
}
3.3.2.7 核心测试结果

在这里插入图片描述

在这里插入图片描述

3.3.3 服务的调用者

创建SpringBoot项目(springcloud_guest)，选择以下依赖；

在这里插入图片描述

3.3.3.1 配置application.yml
server:
  port: 8082
spring:
  application:
    name: guest-service
eureka:
  client:
    service-url:
       defaultZone: http://root:root@localhost:8761/eureka
3.3.3.2 修改启动文件SpringcloudGuestApplication

在启动文件中加入@EnableDiscoveryClient用于启动Eureka客户端接收功能

@SpringBootApplication
@EnableDiscoveryClient
public class SpringcloudGuestApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringcloudGuestApplication.class, args);
    }
}
3.3.3.3 添加po包下的Student
package com.sx.kak.po;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student implements Serializable{
    private Integer id;

    private String name;

    private String sex;

    private String age;
}
3.3.3.4 编写ActionResult

用于接受传递状态

package com.sx.kak.utils;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;

import java.io.Serializable;

/**
 * 封装统一的响应对象
 * Created by Kak on 2020/9/22.
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ActionResult implements Serializable{
    private Integer statusCode;
    private String msg;
    private Object data;
}
3.3.3.5 配置RestConfig

用于注册RestTemplate

@Configuration
public class RestConfig {
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}
3.3.3.6 编写StudentController
package com.sx.kak.controller;

import com.netflix.appinfo.InstanceInfo;
import com.netflix.discovery.EurekaClient;
import com.sx.kak.po.Student;
import com.sx.kak.utils.ActionResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * Created by Kak on 2020/9/23.
 */
@RestController
public class StudentController {
    @Autowired
    private EurekaClient eurekaClient;
    @Autowired
    private RestTemplate restTemplate;

    @RequestMapping("/students")
    public String getStudents() {
        //获取服务实例对象
        InstanceInfo info = eurekaClient.getNextServerFromEureka("student-service", false);
        //接口url
        String url = info.getHomePageUrl() + "students";
        //访问接口
        ActionResult result = restTemplate.getForObject(url, ActionResult.class);
        System.out.println(result);
        return "get students ok";
    }

    @RequestMapping("/student")
    public String getStudent(int id) {
        //获取服务实例对象
        InstanceInfo info = eurekaClient.getNextServerFromEureka("student-service", false);
        //接口url
        String url = info.getHomePageUrl() + "student?id={0}";
        // 访问接口
        ActionResult result = restTemplate.getForObject(url, ActionResult.class, id);
        System.out.println(result);
        return "get studentById:" + id + " ok";
    }

    @RequestMapping("/addStudent")
    public String addStudent() {
        //获取服务实例对象
        InstanceInfo info = eurekaClient.getNextServerFromEureka("student-service", false);
        // 接口url
        String url = info.getHomePageUrl() + "student";
        Student student = new Student(10, "gr", "woman", "23");

        //访问接口，发出post请求
        ActionResult result = restTemplate.postForObject(url, student, ActionResult.class);
        System.out.println(result);
        return "addstudent ok";
    }

    @RequestMapping("/studentUpdate")
    public String UpdateStudent() {
        //获取服务实例对象
        InstanceInfo info = eurekaClient.getNextServerFromEureka("student-service", false);
        //接口url
        String url = info.getHomePageUrl() + "student";
        Student student = new Student(10, "gr", "man", "33");
        // 访问接口，发出PUT
        try {
            restTemplate.put(url, student);
        } catch (Exception ex) {
            System.out.println("error....");
        }
        return "update student ok";
    }

    @RequestMapping("/studentDel")
    public String delStudent() {
        // 获取服务实例对象
        InstanceInfo info = eurekaClient.getNextServerFromEureka("student-service", false);
        //接口url
        String url = info.getHomePageUrl() + "student/{0}";

        // 访问接口发出delete请求
        try {
            restTemplate.delete(url, 10);
        } catch (Exception ex) {
            System.out.println("error....");
        }
        return "delete student ok";
    }
}
3.3.3.7 运行结果

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

3.4 Eureka心跳

EurekaClient启动是将自己的信息注册到EurekaServer上，EurekaServer就会存储上EurekaClient的注册信息；当EurekaClient调用服务时，本地没有缓冲信息时就回去EurekaServer中获取注册信息；EurekaClient会通过心跳的方式和EurekaServer进行连接；

eureka:
  instance:
    lease-renewal-interval-in-seconds: 30 #心跳的间隔
    lease-expiration-duration-in-seconds: 90 #多久没发送认为不可达

client:
  registry-fetch-interval-seconds: 30 #每隔30秒更新一下本地注册信息

Eureka的自我保护机制：

  • 15分钟内如果一个服务的心跳发送低于85%，EurekaServer就会开启保护机制；
  • 不会从EurekaServer中移除长时间没有收到心跳的服务；
  • 网络稳定时，EurekaServer才会开始将自己的信息被其他节点同步过去；
server:
  enable-self-preservation: true #开启自我保护机制

4. Robbin_服务间的负载均衡

但是实际环境中，我们往往会开启很多个user-service的集群。此时我们获取的服务列表中就会有多个，这种情况下我们就需要编写负载均衡算法，在多个实例列表中进行选择；就有了负载均衡组件：Ribbon；

        Robbin帮助我们实现服务间的负载均衡，属于客户端的负载均衡，一般配合Eureka进行使用；

  • 客户端负载均衡：将Search模块全部拉取到本地缓冲，在customer中自己做一个负载均衡策略，选中某一服务；
  • 服务端负载均衡：在注册中心中根据指定对的负载均衡策略，选中一个指定的服务信息返回；

4.1 创建Eurekaserver

创建SpringBoot项目(springcloud_eurekaserver_01)，只导入Eureka Server；

  • 在启动文件中加入@EnableEurekaServer注解用于开启Eureka服务注册功能

4.1.1 配置application.yml

server:
  port: 10003
eureka:
  instance:
    hostname: localhost
  client:
    service-url:
      defaultZone: http://localhost:10003/eureka/
    register-with-eureka: false
    fetch-registry: false

在这里插入图片描述

4.2 创建producer

创建SpringBoot项目(springcloud_producer_01)，选择以下依赖；

  • 在启动文件中加入@EnableEurekaClient用于启动Eureka客户端注册功能

4.2.1 配置application.yml

#配置服务端口
server:
  port: 10004
  #port: 1005
spring:
  application:
    name: producer-service1 #配置服务名
eureka:
  client:
    service-url:
      defaultZone: http://localhost:10003/eureka/ #配置Eureka注册地址

4.2.2 修改为双实例运行

在这里插入图片描述

在这里插入图片描述

  • 利用Robbin选择两个服务

4.2.3 编写ProducerController

@RestController
public class ProducerController {
    @Value("${server.port}") //将配置文件中的Server.port参数注入到port属性中
    private String port;
    @RequestMapping(value = "/proMsg",method = RequestMethod.GET)
    public String getMess(String msg){
        System.out.println("收到的参数："+msg+"---port:"+port);
        return "recieve ok"+msg;
    }

4.3 创建ribbon

实现服务间的负载均衡，创建SpringBoot项目(springcloud_comsumer_ribbon)，选择以下依赖；

  • 在启动文件中加入@EnableEurekaClient用于启动Eureka客户端注册功能

在这里插入图片描述

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

4.3.1 配置RibbonConfig

用于注册RestTemplate，实现客户端负载均衡；

@Configuration
public class RibbonConfig {
    @Bean
    @LoadBalanced //实现客户端负载均衡
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

4.3.2 配置server层

public interface RibbonService {
    public String getMsgFromRemote(String msg);
}

/**
 * 远程调用
 * Created by Kak on 2020/9/23.
 */
@Service
@Slf4j
public class RibbonServiceImpl implements RibbonService {
    @Autowired
    private RestTemplate restTemplate;

    @Override
    public String getMsgFromRemote(String msg) {
        try {
            String url = "http://producer-service1/proMsg?msg={0}";
            String object = restTemplate.getForObject(url,String.class,msg);
            return object;
        } catch (Exception ex) {
            log.info(ex.getMessage());
        }
        return null;
    }
}

4.3.3 配置application.yml

加入了负载均衡策略

server:
  port: 10006
spring:
  application:
    name: consumer-ribbon
eureka:
  client:
    service-url:
      defaultZone: http://localhost:10003/eureka/
 #指定具体服务的负载均衡策略
producer-service1:      # 编写服务名称
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.WeightedResponseTimeRule  # 具体负载均衡使用的类

4.3.4 编写ConsumerController

调用本类

@RestController
public class ConsumerController {
    @Autowired(required = false)
    private RibbonService ribbonService;
    @RequestMapping("/msg")
    public String msg(String msg){
        String s = ribbonService.getMsgFromRemote(msg);
        return "get msg ok:"+ s;
    }
}

4.3.5 运行结果

在这里插入图片描述

在这里插入图片描述

4.4 Robbin配置负载均衡策略

负载均衡策略：

  • RandomRule：随机策略；
  • RoundRobbinRule：轮询策略；
  • WeightedResponseTimeRule：默认采用轮询策略，后续会根据服务的响应时间自动分配权重；
  • BestAvailableRule：根据被调用方并发数量最小的去分配；

4.4.1 采用注解的形式

在Ribbon的config中编写

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

4.4.2 通过配置文件去指定负载均衡的策略

在Ribbon的yml中编写

#指定具体服务的负载均衡策略
producer-service1:      # 编写服务名称
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.WeightedResponseTimeRule  # 具体负载均衡使用的类

5. Feign_服务间的调用

5.1 Feign简介

         Feign可以帮助我们实现面向接口编程，它使得写Http客户端变得更简单；使用Feign只需要创建一个接口并注解。它具有可插拔的注解特性，可使用Feign注解和JAX-RS注解。Feign默认集成了Ribbon和Eureka结合实现了负载均衡的效果；

  • Feign 采用的是基于接口的注解
  • Feign 整合了ribbon

5.2 注册中心、提供者的编写

在Robbin的基础上增加的，代码见4.1和4.2

5.3 创建Feign

实现面向接口的编程，创建SpringBoot项目(springcloud_comsumer_feign)，选择以下依赖；

在这里插入图片描述

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

5.3.1 修改SpringcloudComsumerFeignApplication启动文件

在启动文件中加入@EnableEurekaClient用于启动Eureka客户端注册功能，@EnableFeignClients用于开启feign客户端

5.3.2 配置application.yml

server:
  port: 10007
spring:
  application:
    name: consumer-feign
eureka:
  client:
    service-url:
      defaultZone: http://localhost:10003/eureka/

5.3.3 编写FeignRemoteService接口

@FeignClient("producer-service1") //设置调用的服务名称
public interface FeignRemoteService {
    @RequestMapping(value = "/proMsg",method = RequestMethod.GET)
    public String remoteMsg(@RequestParam(value = "msg") String msg);
}

5.3.3 编写FeignController

@RestController
public class FeignController {
    @Autowired(required = false)
    private FeignRemoteService feignRemoteService;
    @RequestMapping("/msg/{msg}")
    public String getMsg(@PathVariable(value = "msg") String msg){
        String s = feignRemoteService.remoteMsg(msg);
        return "getMsg ok from feign client:"+s;
    }
}

5.3.4 运行结果

在这里插入图片描述

5.4 Feign的传递参数方式

  • 传递的参数复杂时，默认采用POST的请求方式
  • 传递单个参数时，使用@PathVariable，如传递参数较多时可以采用@RequestParam，不省略value属性；
  • 传递对象信息时，统一采用json的方式，添加@RequestBody
  • Client接口必须采用@RequestMapping

6. Ribbon和Feign实现增删查改

四个项目：

  1. 注册中心：springcloud_eurekaserver
  2. 生产者提供数据源：springcloud_producer
  3. Ribbon的客户端（增删查改）：springcloud_ribbonclient
  4. Feign的客户端（增删查改）：springcloud_feignclient
  5. 管理实体类Maven项目：springcloud_entity
  • 数据库同上

6.1 注册中心springcloud_eurekaserver

创建SpringBoot项目(springcloud_eurekaserver)，只导入Eureka Server；

  • 在启动文件中加入@EnableEurekaServer注解用于开启Eureka服务注册功能

在这里插入图片描述

6.1.1 配置application.yml

server:
  port: 8761
eureka:
  instance:
    hostname: 127.0.0.1
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
    register-with-eureka: false
    fetch-registry: false

6.1.2 运行结果

浏览器输入localhost:8761

在这里插入图片描述

6.2 生产者springcloud_producer

创建SpringBoot项目(springcloud_studentserver)，选择以下依赖；

在这里插入图片描述

6.2.1 配置application.yml

对格式的要求很严格

server:
   port: 9091
spring:
  application:
    name: producer-service
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db0711?serverTimezone=UTC
    username: root
    password: root
eureka:
  client:
    service-url:
       defaultZone: http://localhost:8761/eureka
mybatis:
  mapper-locations: classpath:mapping/*.xml
  type-aliases-package: com.sx.kak.po

6.2.2 修改启动文件SpringcloudProducerApplication

在启动文件中加入@EnableEurekaClient用于启动Eureka客户端注册功能

/**
 * 对数据库的访问封装为一个服务
 */
@SpringBootApplication
@EnableEurekaClient
@MapperScan(basePackages = {"com.sx.kak.mapper"})
public class SpringcloudProducerApplication {

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

6.2.3 添加对应的mapper、po、mapping

操作数据库的基本技能，这里是利用mybatis-generator-core-1.3.2生成：参考Mybatis中自动生成代码(利用mybatis-generator-core-1.3.2)一文；

  • 注意序列化

6.2.4 编写StudentService接口

/**
 * Created by Kak on 2020/9/22.
 */
public interface StudentService {
    public List<Student> findAllStudentService();

    public Student addStudentService(Student student);

    public void updateStudent(Student student);

    public void deleteStudent(int id);

    public Student findOneById(int id);
}

6.2.5 编写StudentServiceImpl实现类

/**
 * Created by Kak on 2020/9/22.
 */
@Service
@Slf4j
public class StudentServiceImpl implements StudentService {
    @Autowired(required = false)
    private StudentMapper studentMapper;

    @Override
    public List<Student> findAllStudentService() {
        try {
            StudentExample example = new StudentExample();
            List<Student> students = studentMapper.selectByExample(example);
            return students;
        } catch (Exception ex) {
            log.info(ex.getMessage());
        }
        return null;
    }

    @Override
    public Student addStudentService(Student student) {
        try {
            studentMapper.insertSelective(student);
            return student;
        } catch (Exception ex) {
            log.info(ex.getMessage());
        }
        return null;
    }

    @Override
    public void updateStudent(Student student) {
        try {
            studentMapper.updateByPrimaryKeySelective(student);
        } catch (Exception ex) {
            log.info(ex.getMessage());
        }
    }

    @Override
    public void deleteStudent(int id) {
        try {
            studentMapper.deleteByPrimaryKey(id);
        } catch (Exception ex) {
            log.info(ex.getMessage());
        }
    }

    @Override
    public Student findOneById(int id) {
        try{
            Student student = studentMapper.selectByPrimaryKey(id);
            return student;
        }catch (Exception ex){
            log.info(ex.getMessage());
        }
        return null;
    }
}

6.2.6 编写StudentController

/**
 * Created by Kak on 2020/9/23.
 */
@RestController
public class StudentController {

    @Autowired(required = false)
    private StudentService studentService;

    @RequestMapping(value = "/students",method = RequestMethod.GET)
    public ActionResult findAllStudent(){
        List<Student> allStudentService = studentService.findAllStudentService();
        ActionResult actionResult = new ActionResult(200,"",allStudentService);
        return actionResult;
    }

    @RequestMapping(value="/student/{id}",method = RequestMethod.GET)
    public ActionResult findStuById(@PathVariable(value="id") int id){
        Student oneById = studentService.findOneById(id);
        ActionResult result = new ActionResult(200, "", oneById);
        return result;
    }

    @RequestMapping(value = "/student",method = RequestMethod.POST)
    public ActionResult addStu(@RequestBody Student student){
        Student student1 = studentService.addStudentService(student);
        System.out.println(student1);
        ActionResult result = new ActionResult(200, "", student1);
        return result;
    }

    @RequestMapping(value = "/student",method = RequestMethod.PUT)
    public ActionResult updateStudent(@RequestBody Student student){
        ActionResult result = null;
        try {
            studentService.updateStudent(student);
            result = new ActionResult(200, "update ok", null);
            return result;
        }catch(Exception ex){
            result = new ActionResult(404, "error", null);
        }
        return result;
    }


    @RequestMapping(value = "/student/{id}",method = RequestMethod.DELETE)
    public ActionResult deleteStudent(@PathVariable("id") int id ){
        studentService.deleteStudent(id);
        ActionResult result = new ActionResult(200, "delete ok", null);
        return result;
    }
}

6.2.7 测试

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

6.3 Ribbon的客户端springcloud_ribbonclient

实现服务间的负载均衡，创建SpringBoot项目(springcloud_ribbonclient)，选择以下依赖；

  • 在启动文件中加入@EnableEurekaClient用于启动Eureka客户端注册功能

在这里插入图片描述

6.3.1 配置application.yml

server:
  port: 9092
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
spring:
  application:
    name: ribbon-client

6.3.2 RibbonConfig

用于注册RestTemplate，实现客户端负载均衡；

@Configuration
public class RibbonConfig {
    @Bean
    @LoadBalanced //实现客户端负载均衡
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
    @Bean
    public IRule ribbonRule(){
        //轮询策略
        return  new RoundRobinRule();
    }
}

6.3.3 配置server层

/**
 * Created by Kak on 2020/9/23.
 */
public interface StudentRibbonService {
    public List<Student> findAllStudentService();

    public boolean addStudentService(Student student);

    public boolean updateStudent(Student student);

    public boolean deleteStudent(int id);

    public Map findOneById(int id);
}

/**
 * Created by Kak on 2020/9/24.
 */
@Service
@Slf4j
public class StudentRibbonServiceImpl implements StudentRibbonService {
    @Autowired(required = false)
    private RestTemplate restTemplate;

    @Override
    public List<Student> findAllStudentService() {
        String url = "http://producer-service/students";
        ActionResult actionResult = restTemplate.getForObject(url, ActionResult.class);
        List<Student> data = null;
        if (actionResult != null) {
            data = (List<Student>) actionResult.getData();
        }
        return data;
    }

    @Override
    public boolean addStudentService(Student student) {
        String url = "http://producer-service/student";
        ActionResult actionResult = restTemplate.postForObject(url, student, ActionResult.class);
        if (actionResult.getStatusCode() == 200) {
            return true;
        }
        return false;
    }

    @Override
    public boolean updateStudent(Student student) {
        String url = "http://producer-service/student";
        try {
            restTemplate.put(url, student);
            return true;
        } catch (Exception ex) {
            log.info(ex.getMessage());
        }
        return false;
    }

    @Override
    public boolean deleteStudent(int id) {
        String url = "http://producer-service/student/{0}";
        try {
            restTemplate.delete(url, id);
            return true;
        }catch (Exception ex){
            log.info(ex.getMessage());
        }
        return false;
    }

    @Override
    public Map findOneById(int id) {
        String url = "http://producer-service/student/"+id;
        ActionResult actionResult = restTemplate.getForObject(url, ActionResult.class);
        Map data = null;
        if(actionResult!=null&&actionResult.getData()!=null){
            data =(Map) actionResult.getData();
        }
        return data;
    }
}

6.3.4 配置StudentRibbonController层

/**
 * Created by Kak on 2020/9/24.
 */
@RestController
public class StudentRibbonController {
    @Autowired(required = false)
    private StudentRibbonService studentRibbonService;
    @RequestMapping("/students")
    public String findAllStudent(){
        List<Student> allStudentService = studentRibbonService.findAllStudentService();
        System.out.println(allStudentService);
        return "get student ok!";
    }

    @RequestMapping("/findOneStudent")
    public String findOneStu(int id){
        Map byId = studentRibbonService.findOneById(id);
        System.out.println(byId);
        return "get one student ok!";
    }
    @RequestMapping("/addStudent")
    public String addStu(Student student){
        boolean b = studentRibbonService.addStudentService(student);
        System.out.println(" addStudent:"+b);
        return "add student ok!"+b;
    }
    @RequestMapping("/updateStudent")
    public String updateStu(Student student){
        boolean b = studentRibbonService.updateStudent(student);
        return "update student ok!";
    }
    @RequestMapping("/deleteStudent")
    public String deleteStu(int id){
        boolean b = studentRibbonService.deleteStudent(id);
        return "delete student ok!";
    }
}

6.3.5 测试

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

6.4 Feign的客户端springcloud_feignclient

创建SpringBoot项目(springcloud_feignclient)，选择以下依赖；

在这里插入图片描述

6.4.1 修改SpringcloudComsumerFeignApplication启动文件

在启动文件中加入@EnableEurekaClient用于启动Eureka客户端注册功能，@EnableFeignClients用于开启feign客户端

6.4.2 配置application.yml

server:
  port: 9093
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
spring:
  application:
    name: feign-client

6.4.3 编写StudentFeignService接口

/**
 * Created by Kak on 2020/9/23.
 */
@FeignClient(value = "producer-service")
public interface StudentFeignService {
    @RequestMapping(value = "/students",method = RequestMethod.GET)
    public ActionResult findStudentService();

    @RequestMapping(value = "/student/{id}",method = RequestMethod.GET)
    public ActionResult findStuById(@PathVariable(value="id") int id);

    @RequestMapping(value = "/student",method = RequestMethod.POST)
    public ActionResult addStu(@RequestBody Student student);

    @RequestMapping(value = "/student",method = RequestMethod.PUT)
    public ActionResult updateStudent(@RequestBody Student student);

    @RequestMapping(value = "/student/{id}",method = RequestMethod.DELETE)
    public ActionResult deleteStudent(@PathVariable(value = "id") int id );
}

6.4.4 编写StudentFeigncontroller

/**
 * Created by Kak on 2020/9/23.
 */
@RestController
public class StudentFeigncontroller {
    @Autowired(required = false)
    private StudentFeignService studentFeignService;
    @RequestMapping("/students")
    public String findStu(){
        ActionResult studentService = studentFeignService.findStudentService();
        System.out.println(studentService);
        return "getStudents OK!!!";
    }

    @RequestMapping("/findOneStudent")
    public String findByIdStu(int id){
        ActionResult stuById = studentFeignService.findStuById(id);
        System.out.println(stuById);
        return "get one student ok!";
    }

    @RequestMapping("/addStudent")
    public String addStu(Student student){
        ActionResult actionResult = studentFeignService.addStu(student);
        System.out.println(actionResult);
        return "add student OK!!!";
    }

    @RequestMapping("/updateStudent")
    public String updateStu(Student student){
        ActionResult actionResult = studentFeignService.updateStudent(student);
        System.out.println(actionResult);
        return "update student OK!!!";
    }

    @RequestMapping("/deleteStudent")
    public String deleteStu(int id){
        ActionResult actionResult = studentFeignService.deleteStudent(id);
        System.out.println(actionResult);
        return "delete student OK!!!";
    }
}

6.4.5 测试

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

6.5 管理实体类springcloud_entity

将通用的po以及ActionResult封装在Maven中，分别导入以下依赖：

<!--添加公共的po-->
<dependency>
 <groupId>com.sx.kak</groupId>
 <artifactId>springcloud_entity</artifactId>
 <version>1.0-SNAPSHOT</version>
</dependency>

6.5.1 编写ActionResult

用于接受传递状态

package com.sx.kak.utils;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;

import java.io.Serializable;

/**
 * 封装统一的响应对象
 * Created by Kak on 2020/9/22.
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ActionResult implements Serializable{
    private Integer statusCode;
    private String msg;
    private Object data;
}

6.5.2 编写po

package com.sx.kak.po;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student implements Serializable{
    private Integer id;

    private String name;

    private String sex;

    private String age;
}

package com.sx.kak.po;

import java.util.ArrayList;
import java.util.List;

public class StudentExample {
    protected String orderByClause;

    protected boolean distinct;

    protected List<Criteria> oredCriteria;

    public StudentExample() {
        oredCriteria = new ArrayList<Criteria>();
    }

    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    public String getOrderByClause() {
        return orderByClause;
    }

    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    public boolean isDistinct() {
        return distinct;
    }

    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    protected abstract static class GeneratedCriteria {
        protected List<Criterion> criteria;

        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }

        public boolean isValid() {
            return criteria.size() > 0;
        }

        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        public List<Criterion> getCriteria() {
            return criteria;
        }

        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }

        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }

        public Criteria andIdIsNull() {
            addCriterion("id is null");
            return (Criteria) this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion("id is not null");
            return (Criteria) this;
        }

        public Criteria andIdEqualTo(Integer value) {
            addCriterion("id =", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotEqualTo(Integer value) {
            addCriterion("id <>", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThan(Integer value) {
            addCriterion("id >", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("id >=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThan(Integer value) {
            addCriterion("id <", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThanOrEqualTo(Integer value) {
            addCriterion("id <=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdIn(List<Integer> values) {
            addCriterion("id in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotIn(List<Integer> values) {
            addCriterion("id not in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdBetween(Integer value1, Integer value2) {
            addCriterion("id between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotBetween(Integer value1, Integer value2) {
            addCriterion("id not between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andNameIsNull() {
            addCriterion("NAME is null");
            return (Criteria) this;
        }

        public Criteria andNameIsNotNull() {
            addCriterion("NAME is not null");
            return (Criteria) this;
        }

        public Criteria andNameEqualTo(String value) {
            addCriterion("NAME =", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameNotEqualTo(String value) {
            addCriterion("NAME <>", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameGreaterThan(String value) {
            addCriterion("NAME >", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameGreaterThanOrEqualTo(String value) {
            addCriterion("NAME >=", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameLessThan(String value) {
            addCriterion("NAME <", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameLessThanOrEqualTo(String value) {
            addCriterion("NAME <=", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameLike(String value) {
            addCriterion("NAME like", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameNotLike(String value) {
            addCriterion("NAME not like", value, "name");
            return (Criteria) this;
        }

        public Criteria andNameIn(List<String> values) {
            addCriterion("NAME in", values, "name");
            return (Criteria) this;
        }

        public Criteria andNameNotIn(List<String> values) {
            addCriterion("NAME not in", values, "name");
            return (Criteria) this;
        }

        public Criteria andNameBetween(String value1, String value2) {
            addCriterion("NAME between", value1, value2, "name");
            return (Criteria) this;
        }

        public Criteria andNameNotBetween(String value1, String value2) {
            addCriterion("NAME not between", value1, value2, "name");
            return (Criteria) this;
        }

        public Criteria andSexIsNull() {
            addCriterion("sex is null");
            return (Criteria) this;
        }

        public Criteria andSexIsNotNull() {
            addCriterion("sex is not null");
            return (Criteria) this;
        }

        public Criteria andSexEqualTo(String value) {
            addCriterion("sex =", value, "sex");
            return (Criteria) this;
        }

        public Criteria andSexNotEqualTo(String value) {
            addCriterion("sex <>", value, "sex");
            return (Criteria) this;
        }

        public Criteria andSexGreaterThan(String value) {
            addCriterion("sex >", value, "sex");
            return (Criteria) this;
        }

        public Criteria andSexGreaterThanOrEqualTo(String value) {
            addCriterion("sex >=", value, "sex");
            return (Criteria) this;
        }

        public Criteria andSexLessThan(String value) {
            addCriterion("sex <", value, "sex");
            return (Criteria) this;
        }

        public Criteria andSexLessThanOrEqualTo(String value) {
            addCriterion("sex <=", value, "sex");
            return (Criteria) this;
        }

        public Criteria andSexLike(String value) {
            addCriterion("sex like", value, "sex");
            return (Criteria) this;
        }

        public Criteria andSexNotLike(String value) {
            addCriterion("sex not like", value, "sex");
            return (Criteria) this;
        }

        public Criteria andSexIn(List<String> values) {
            addCriterion("sex in", values, "sex");
            return (Criteria) this;
        }

        public Criteria andSexNotIn(List<String> values) {
            addCriterion("sex not in", values, "sex");
            return (Criteria) this;
        }

        public Criteria andSexBetween(String value1, String value2) {
            addCriterion("sex between", value1, value2, "sex");
            return (Criteria) this;
        }

        public Criteria andSexNotBetween(String value1, String value2) {
            addCriterion("sex not between", value1, value2, "sex");
            return (Criteria) this;
        }

        public Criteria andAgeIsNull() {
            addCriterion("age is null");
            return (Criteria) this;
        }

        public Criteria andAgeIsNotNull() {
            addCriterion("age is not null");
            return (Criteria) this;
        }

        public Criteria andAgeEqualTo(String value) {
            addCriterion("age =", value, "age");
            return (Criteria) this;
        }

        public Criteria andAgeNotEqualTo(String value) {
            addCriterion("age <>", value, "age");
            return (Criteria) this;
        }

        public Criteria andAgeGreaterThan(String value) {
            addCriterion("age >", value, "age");
            return (Criteria) this;
        }

        public Criteria andAgeGreaterThanOrEqualTo(String value) {
            addCriterion("age >=", value, "age");
            return (Criteria) this;
        }

        public Criteria andAgeLessThan(String value) {
            addCriterion("age <", value, "age");
            return (Criteria) this;
        }

        public Criteria andAgeLessThanOrEqualTo(String value) {
            addCriterion("age <=", value, "age");
            return (Criteria) this;
        }

        public Criteria andAgeLike(String value) {
            addCriterion("age like", value, "age");
            return (Criteria) this;
        }

        public Criteria andAgeNotLike(String value) {
            addCriterion("age not like", value, "age");
            return (Criteria) this;
        }

        public Criteria andAgeIn(List<String> values) {
            addCriterion("age in", values, "age");
            return (Criteria) this;
        }

        public Criteria andAgeNotIn(List<String> values) {
            addCriterion("age not in", values, "age");
            return (Criteria) this;
        }

        public Criteria andAgeBetween(String value1, String value2) {
            addCriterion("age between", value1, value2, "age");
            return (Criteria) this;
        }

        public Criteria andAgeNotBetween(String value1, String value2) {
            addCriterion("age not between", value1, value2, "age");
            return (Criteria) this;
        }
    }

    public static class Criteria extends GeneratedCriteria {

        protected Criteria() {
            super();
        }
    }

    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}

7. Hystrix_服务的隔离及断路器

7.1 Hystrix简介

         Hystrix主要是为了解决服务雪崩问题，Hystrix是一个用于分布式系统的延迟和容错的开源库。在分布式系统里，许多依赖不可避免的调用失败，比如超时、异常等，Hystrix能够保证在一个依赖出问题的情况下，不会导致整个服务失败，避免级联故障，以提高分布式系统的弹性；

雪崩效应：是一种因服务提供者的不可用导致服务调用者的不可用,并将不可用逐渐放大的过程；如我们去访问一个服务的时候，发现这个服务崩了，然后我们一直在访问，后面的也一直排队等访问，但是我们有没有成功，导致后面所有的请求在排队，就越来越多的请求等待，这时候系统的资源也会被逐渐的给耗尽，导致所有的服务都可能崩；

7.2 环境的搭建

创建四个spring Boot项目：

  1. 注册中心：springcloud_eurekaserver
  2. 服务提供者：springcloud_producer
  3. Ribbon客户端：springcloud_ribbon_hystrix
  4. Feign客户端：springcloud_feign

7.2.1 创建Eurekaserver

创建SpringBoot项目(springcloud_eurekaserver)，只导入EurekaServer；

  • 在启动文件中加入@EnableEurekaServer注解用于开启Eureka服务注册功能
7.2.1.1 配置application.yml
server:
  port: 8761
eureka:
  instance:
    hostname: 127.0.0.1
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
    register-with-eureka: false
    fetch-registry: false

在这里插入图片描述

7.2.2 创建springcloud_producer

创建SpringBoot项目(springcloud_producer)，选择以下依赖；

在这里插入图片描述

  • 在启动文件中加入@EnableEurekaClient用于启动Eureka客户端注册功能
7.2.2.1 配置application.yml
	server:
  port: 9091
spring:
  application:
    name: producer-server
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
7.2.2.2 配置StudentController

用于提供服务信息

@RestController
public class StudentController {
    @RequestMapping(value = "/msg",method = RequestMethod.GET)
    public String sendMsg(){
        return "this is producer message";
    }
}

在这里插入图片描述

7.2.3 创建springcloud_consumer_ribbon_hystrix

创建SpringBoot项目(springcloud_consumer_ribbon_hystrix)，选择以下依赖；

在这里插入图片描述

  • 在启动文件中加入@EnableDiscoveryClient用于启动Eureka客户端注册功能
7.2.3.1 配置application.yml
server:
  port: 9092
spring:
  application:
    name: consumer-server-hystrix
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
7.2.3.2 配置Ribbon

编写RibbonConfig

@Configuration
public class RibbonConfig {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}
7.2.3.3 配置Server层
/**
 * Created by Kak on 2020/9/24.
 */
public interface RemoteRibbonService {
    public String fetchMsg();
}

/**
 * Created by Kak on 2020/9/24.
 */
@Service
public class RemoteRibbonServiceImpl implements RemoteRibbonService {
    @Autowired(required = false)
    private RestTemplate restTemplate;

    /**
     * 通过ribbon远程访问
     * @return
     */
    @Override
    public String fetchMsg() {
        String url = "http://producer-server/msg";
        String forObject = restTemplate.getForObject(url, String.class);
        return forObject;
    }
}
7.2.3.3 配置StuController层
/**
 * Created by Kak on 2020/9/24.
 */
@RestController
public class StuController {
    @Autowired(required = false)
    private RemoteRibbonService remoteRibbonService;
    @RequestMapping("/msg")
    public String getMsg(){
        String s = remoteRibbonService.fetchMsg();
        System.out.println(s);
        return s;
    }
}
7.2.3.4 测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iPeptJSw-1603452930717)(19_SpringCloud.assets/image-20200924173920766.png)]

7.2.4 创建springcloud_feign

实现面向接口的编程，创建SpringBoot项目(springcloud_feign)，选择以下依赖；

在这里插入图片描述

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
7.2.4.1 修改SpringcloudConsumerFeignApplication启动文件

在启动文件中加入@EnableEurekaClient用于启动Eureka客户端注册功能，@EnableFeignClients用于开启feign客户端

7.2.4.2 配置application.yml
server:
  port: 9093
spring:
  application:
    name: feign-server-hystrix
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
7.2.4.3 编写RemoteFeignServer接口
@FeignClient("producer-service") //设置调用的服务名称
public interface RemoteFeignServer {
    @RequestMapping(value = "/msg",method = RequestMethod.GET)
    public String fetchMsg();
}
7.2.4.3 编写StuController
/**
 * Created by Kak on 2020/9/24.
 */
@RestController
public class StuController {
    @Autowired(required = false)
    private RemoteFeignServer remoteFeignServer;
    @RequestMapping("/msg")
    public String getMsg(){
        String s = remoteFeignServer.fetchMsg();
        return s;
    }
}
7.2.4.4 测试

在这里插入图片描述

7.3 降级机制实现_ribbon

当某个服务熔断之后，服务器将不再被调用，此刻客户端可以自己准备一个本地的fallback回调，返回一个托底数据，虽然服务水平下降，但比直接挂掉要强；

7.3.1 添加熔断的依赖

<!--添加熔断的依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    <version>2.1.4.RELEASE</version>
</dependency>

7.3.2 修改启动类

在启动类之前加入注解，开启熔断服务（任选其一）：

  1. @EnableHystrix
  2. @EnableCircuitBreaker

7.3.3 编写降级方法

服务降级时执行的方法注意：

  • 方法名和fallbackmethod值一致
  • 参数列表与原来原过程调用的方法参数列表一致
  • 返回值与原方法一致
/**
 * Created by Kak on 2020/9/24.
 */
@Service
public class RemoteRibbonServiceImpl implements RemoteRibbonService {
    @Autowired(required = false)
    private RestTemplate restTemplate;
    /**
     * 通过ribbon远程访问
     * @return
     */
    //当远程调用出现异常，退一步执行fetchMsgError方法
    @HystrixCommand(fallbackMethod = "fetchMsgError")
    @Override
    public String fetchMsg() {
        String url = "http://producer-server/msg";
        String forObject = restTemplate.getForObject(url, String.class);
        return forObject;
    }
    public String fetchMsgError() {
        System.out.println("执行降级服务！！！");
        return "拖底数据";
    }
}

7.3.4 测试

关掉producer，制造异常

在这里插入图片描述

7.4 降级机制实现_fiegn

如果我们用Fiegn调用另外一个服务时，出现问题，为了避免因一个服务而使所有的服务失效就会使用Fallback自带的依赖包；

7.4.1 配置application.yml

在yml中开启feign的熔断设置

feign:
  hystrix:
    enabled: true #开启feign的熔断设置

7.4.2 修改接口属性

/**
 * Created by Kak on 2020/9/24.
 */
//调用的服务名        降级后执行的类
@FeignClient(value = "producer-server",fallback = RemoteFeignServerHystrix.class)
public interface RemoteFeignServer {
    @RequestMapping(value = "/msg",method = RequestMethod.GET)
    public String fetchMsg();
}

7.4.3 创建feign降级执行的类

/**
 * 创建feign降级执行的类
 * Created by Kak on 2020/9/24.
 */
@Component
public class RemoteFeignServerHystrix implements RemoteFeignServer{
    @Override
    public String fetchMsg() {
        System.out.println("执行降级");
        return "this is feign hystrix fallback msg ";
    }
}

7.4.4 测试

关掉producer，制造异常

在这里插入图片描述

7.5 线程隔离

如果我们很多业务都依赖于同一个线程池,当其中一个业务因为各种不可控的原因消耗了所有的线程，导致线程池全部占满，这样其他的业务也就不能正常运转了；如使用Tomcat的线程池去接收用户的请求，使用当前线程去执行其他服务的功能，如果某一个服务出现了故障，导致tomcat的线程大量的堆积；线程资源得不到回收释放；线程池慢慢被占满，最坏的情况就是整个应用都不能提供服务，因此我们需要将线程池进行隔离；

7.5.1 代码实现

    @HystrixCommand(fallbackMethod = "fetchMsgError",commandProperties = {
            @HystrixProperty(name = "execution.isolation.strategy",value = "THREAD")
    })

7.5.2 Hystrix线程池的配置

参数描述默认值
execution.isolation.strategy隔离策略默认：THREAD
execution.isolation.thread.timeoutInMilliseconds超时时间默认值：1000
execution.timeout.enabled执行是否应该有超时默认值：true
execution.isolation.thread.interruptOnTimeout在发生超时时是否应中断默认值：true
execution.isolation.thread.interruptOnCancel当发生取消时，执行是否应该中断默认值：false

7.6 断路器

         断容器可以说是一个算法，我们在调用服务时，如果服务的当服务的失败率达到阈值，就会从close状态转为open状态，是无法访问这个服务的；如果访问就会走fallback方法，一段时间后open会转化为half open状态，允许一个请求发送到指定服务，成功转变为close，失败再次转化为open状态，一直到回到closed状态；

  • 通俗点说就是，当一个服务挂掉断容器就会标记一个状态，下次请求时直接查看标记，节省了时间；当服务可达时断容器就会转换为closed状态；

在springcloud_ribbon_hystrix中操作

7.6.1 导入依赖

<!--添加断路仪表盘依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
    <version>2.1.1.RELEASE</version>
</dependency>

7.6.2 修改启动文件

在启动文件中加入：

  1. @EnableHystrixDashboard用于开启熔断仪表功能
  2. 添加扫描Servlet的注解：@ServletComponentScan(“com.sx.kak.servlet”)

7.6.3 配置Servlet路径

配置一个Servlet路径，指定Hystrix

/**
 * 开发熔断监控的Servlet
 * Created by Kak on 2020/9/24.
 */
@WebServlet("/hystrix.stream")
public class HystrixServlet extends HystrixMetricsStreamServlet{
}

7.6.4 测试

在这里插入图片描述

映射路径：http://localhost:9092/hystrix.stream

在这里插入图片描述

7.6.5 断路器属性

在这里插入图片描述

根据需求增加

@HystrixCommand(fallbackMethod = "fetchMsgError",commandProperties = {
    @HystrixProperty(name = "circuitBreaker.enabled",value = "true"),
    @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold",value = "10")
})

7.7 请求缓存

  • 请求缓存的周期是一次请求
  • 请求缓存是缓存当前线程的一个方法，将方法的参数作为key，返回结果作为value
  • 在一次请求中，目标方法被调用过一次后，就会被缓存
  • 是局部缓存，而redis是全局缓存

在springcloud_ribbon_hystrix和springcloud_producer中操作

7.7.1 springcloud_producer中的controller

增加以下代码

@RequestMapping(value = "/msg2/{id}",method = RequestMethod.GET)
public String sendMsg2(@PathVariable(value = "id") Integer id){
    String str = "this is producer message2"+ UUID.randomUUID().toString();
    System.out.println("producer message2:"+str);
    return str;
}

7.7.2 修改springcloud_ribbon_hystrix中server层

/**
/**
 * Created by Kak on 2020/9/24.
 */
public interface RemoteRibbonService {
    public String fetchMsg();

    public String fetchObject(Integer id);

    public void  clearCacheResult(Integer id);
}

实现类中添加以下代码：

@CacheResult：帮助我们缓存当前方法的返回结果（必须与@HystrixCommand配合使用）

@CacheRemove：帮助我们基于某一个缓存信息（基于commandKey）

@CacheKey：指定那个参数作为缓存标识

/**
 * @param id 方法参数id作为缓存的key
 * @return 作为value
 */
@CacheResult
@HystrixCommand(commandKey = "fetchObject")
@Override
public String fetchObject(@CacheKey Integer id) {
    String url = "http://producer-server/msg2/"+id;
    String forObject = restTemplate.getForObject(url, String.class);
    return forObject;
}

/**
 * 清除缓冲 @CacheRemove依赖@HystrixCommand生效
 *
 * @param id
 */
@CacheRemove(commandKey = "fetchObject")
@HystrixCommand
public void clearCacheResult(@CacheKey Integer id) {
    System.out.println("缓冲清除！！！");
}

7.7.3 修改springcloud_ribbon_hystrix中StuController

@RequestMapping("/msg2")
public String getMsg2() {
    String s = remoteRibbonService.fetchObject(10);
    System.out.println(s);

    String s2 = remoteRibbonService.fetchObject(10);
    System.out.println(s2);

    remoteRibbonService.clearCacheResult(10);
    String s3 = remoteRibbonService.fetchObject(10);
    System.out.println(s3);

    return s;
}

7.7.4 测试结果

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

  • 根据以上可以知道：Ribbon发送请求后存入了本地缓存中，下次调用时直接取出数据，所以两个一样；当调用remoteRibbonService.clearCacheResult(10)时，清除本地缓存；之后再次向提供者请求，于是就有了上上图的东西；

8. Zuul_服务的网关

Zuul是Netflix开源的服务网关，它可以和前面介绍的Eureka/Ribbon/Hystrix/Feign等组件很好的兼任使用，并称五大神兽；Zuul的核心是过滤器，通过过滤器实现功能；客户端会有大量的服务，每一块都需要进行添加认证和授权的操作，统一将安全性校验放在Zuul中；

8.1 创建springcloud_zuul

创建SpringBoot项目(springcloud_zuul)，选择以下依赖；

在这里插入图片描述

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

8.1.1 修改配置文件

在启动文件中加入以下注解：

  1. @EnableDiscoveryClient：用于启动Eureka客户端注册功能
  2. @EnableZuulProxy：用于开启zuul路由代理服务

8.1.2 配置application.yml

server:
  port: 9098
spring:
  application:
    name: consumer-server-zuul
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

8.1.3 直接访问测试

在这里插入图片描述

8.2 Zuul中常用的配置

8.2.1 自定义路由

#自定义路由
zuul:
  routes:
  #自定义路由名称
    a:
    #映射路径
      path: /a/**
      #服务名称
      serviceId: feign-server-hystrix
    b:
      path: /b/**
      serviceId: consumer-server-hystrix

在这里插入图片描述

8.2.2 Zuul的监控信息

8.2.2.1 导入依赖
<!--导入依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
8.2.2.2 编写配置文件
management:
  endpoints:
    web:
      exposure:
        include: "*"
8.2.2.2 测试结果

actuator/routes

在这里插入图片描述

8.2.3 忽略服务配置

忽略consumer-server-hystrix

 #忽略服务配置，自定义除外
ignored-services: consumer-server-hystrix

在这里插入图片描述

8.2.4 灰度发布

8.2.4.1 修改Zuul的启动类
@SpringBootApplication
@EnableEurekaClient
@EnableZuulProxy    //开启zuul路由代理服务
public class SpringcloudZuulApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringcloudZuulApplication.class, args);
    }
    @Bean
    public PatternServiceRouteMapper serviceRouteMapper(){
        return new PatternServiceRouteMapper(
                "(?<name>^.+)-(?<version>v.+$)",
                "${version}/${name}"
        );
    }
}
8.2.4.2 在feign的yml中添加

在这里插入图片描述

8.2.4.3 测试

在这里插入图片描述

8.3 Zuul过滤器的执行流程

PreFilter：在调用服务之先调用的过滤器

PostFilter：在调用服务之后调用的过滤器

ErrorFilter：发生异常调用的过滤器

RoutingFilter：路由过滤器（正在执行）

在这里插入图片描述

  1. 客户端请求发送到Zuul上，如果含有PreFilter的过滤器就会先通过PreFilter过滤器，正常放行；
  2. 请求到路由过滤器
  3. 在路由过滤器中调用相应的微服务
  4. 之后就会返回到路由过滤器（指定服务相应了结果）
  5. 然后执行PostFilter过滤器
  6. 最终将响应信息交给客户端
  7. 如果没有直接执行默认的路由过滤器，执行微服务
  8. 发生错误执行ErrorFilter过滤器

8.4 Zuul过滤器简单案例

  1. 创建FirstFilter，继承ZuulFilter抽象类
  2. 指定过滤类型
  3. 指定过滤器的执行顺序
  4. 配置是否启用
  5. 指定过滤器中的业务代码

8.4.1 FirstZuulFilter

/**
 * Created by Kak on 2020/9/25.
 */
@Component
public class FirstZuulFilter extends ZuulFilter {
    //定义过滤器的类型(前置)
    @Override
    public String filterType() {
        return FilterConstants.PRE_TYPE;
//        return "pre";
    }

    //定义过滤器的执行顺序。数字越小，优先执行默认5
    @Override
    public int filterOrder() {
        return FilterConstants.PRE_DECORATION_FILTER_ORDER-2;
    }
//设定过滤器是否生效 true生效
    @Override
    public boolean shouldFilter() {
        return true;
    }
//过滤器的逻辑
    @Override
    public Object run() throws ZuulException {
        System.out.println("this is my first zuulfilter.....");
        return null;
    }
}

8.4.2 SecondZuulFilter

/**
 * Created by Kak on 2020/9/25.
 */
@Component
public class SecondZuulFilter extends ZuulFilter {
    @Override
    public String filterType() {
        return FilterConstants.POST_TYPE;
    }

    @Override
    public int filterOrder() {
        return FilterConstants.PRE_DECORATION_FILTER_ORDER - 3;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() throws ZuulException {
        System.out.println("this is my second zuulfilter.....");
        return null;
    }
}

8.4.3 结果

在这里插入图片描述

  • 由上可知首先触发前置类型，之后才触发后置类型

8.5 PreFilter实现token的检验

创建AuthenFilter,使用前置的方式

  • 当token为1234时访问成功
/**
 * Created by Kak on 2020/9/25.
 */
@Component
public class AuthenFilter extends ZuulFilter {
    //定义过滤器的类型
    @Override
    public String filterType() {
        return FilterConstants.PRE_TYPE;
    }

    //定义过滤器的执行顺序。数字越小，优先执行默认5
    @Override
    public int filterOrder() {
        return FilterConstants.PRE_DECORATION_FILTER_ORDER - 2;
    }

    //设定过滤器是否生效 true生效
    @Override
    public boolean shouldFilter() {
        return true;
    }

    //过滤器的逻辑
    @Override
    public Object run() throws ZuulException {
        //获取当前上下文
        RequestContext currentContext = RequestContext.getCurrentContext();
        //得到HttpServletRequest
        HttpServletRequest request = currentContext.getRequest();
        //从参数中获取token
        String token = request.getParameter("token");
        //从请求头部获取认证令牌信息
        request.getHeader("Authentication");
        //令牌无效或不合法
        if (token == null || !"1234".equalsIgnoreCase(token)) {
            currentContext.setSendZuulResponse(false);//阻止请求继续发送到微服务
            
            currentContext.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value());
            currentContext.setResponseBody("no permission......");
        }
        return null;
    }
}

在这里插入图片描述

在这里插入图片描述

9. Sidecar_多语言支持

在我们开发中，需要接入一些非java的程序（第三方接口），因此需要启动一个代理的微服务，代理微服务与非java程序交接，使用Sidecar边车模式；

9.1 创建第三方服务

创建一个SpringBoot的web项目（springcloud_multipart）模拟第三方；

  • 端口号为10008
/**
 *业务代码
 * Created by Kak on 2020/9/25.
 */
@RestController
public class MultiController {
    @GetMapping("/multi")
    public String getMsg(){
        return "this is multipart service";
    }
}

在这里插入图片描述

9.2 创建sidecar客户端

创建SpringBoot项目(springcloud_sidecar)，只导入Eureka Discovery Client；

9.2.1 导入依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-netflix-sidecar</artifactId>
</dependency>

9.2.2 配置application.yml

server:
  port: 9099
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
spring:
  application:
    name: sidecar-server
#配置第三方服务代理
sidecar:
  port: 10008

9.2.3 在启动类中加入注解

  • @EnableEurekaClient：用于启动Eureka客户端注册功能
  • @EnableSidecar：用于开启第三方服务代理功能

9.2.4 在Zuul中加入sidecar的自定义路由

sidecar:
  path: /sidecar/**
  serviceId: sidecar-server

9.3 测试

在这里插入图片描述

10. Config_服务的动态配置

由于配置文件发散到不同的项目中，不方便维护，所以需要对其就行集中管理，因此运用到了Config；

在这里插入图片描述

10.1 环境的搭建

新建一个Maven工程管理SpringCloud（四个）

  • springcloud_eurekaserver
  • springcloud_producer
  • springcloud_consumer
  • springcloud_zuul

创建方式参照前面步骤即可

10.2 第一版_在本服务中

10.2.1 springcloud_producer的yml配置

server:
  port: 9091
spring:
  application:
    name: producer-service-jpa
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db0711?serverTimezone=UTC
    username: root
    password: root
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

10.2.2 springcloud_consumer的yml配置

server:
  port: 9092
spring:
  application:
    name: consumer-server
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka

10.2.3 springcloud_zuul的yml配置

server:
  port: 10008
spring:
  application:
    name: consumer-server-zuul
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka

10.3 第二版_分离对应的端口

10.3.1 springcloud_producer

  1. 将application.yml（初始化服务加载的配置）改为bootstrap.yml（引导文件，运行之初）
  2. 创建application.yml，将数据源端口放入，实现分离；
  3. 可以建立多个application.yml，配置不同的端口号（有的是测试、有的是主干、有的是开发使用的）
application-dev.yml
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db0711?serverTimezone=UTC
    username: root
    password: root
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update
server:
  port: 10001
application-test.yml
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db0711?serverTimezone=UTC
    username: root
    password: root
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update
server:
  port: 10002
application-pro.yml
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db0711?serverTimezone=UTC
    username: root
    password: root
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update
server:
  port: 10003
bootstrap.yml
server:
  port: 9091
spring:
  application:
    name: producer-service-jpa
  profiles:
    active: dev
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

在这里插入图片描述

  • 结果运行的端口是10001

10.3.2 springcloud_consumer

consumer的设置跟producer一致

10.4 第三版_新建config项目实现本地管理配置

           因为每个服务都会有很多配置，不利于管理，因此在建立一个eureka的客户端，并且声明为Config Server，相同的配置与服务名作为区分；

创建SpringBoot项目(springcloud_config)，选择以下依赖；

在这里插入图片描述

10.4.1 配置application.yml

首先要声明为eureka的客户端，然后设置为Config的服务

  • 做以下配置
server:
  port: 8888
spring:
  application:
    name: config-service
  cloud:
    config:
      server:
        native: #配置本地资源位置
          search-locations: classpath:share
  profiles:
    active: native #配置服务资源来自本地
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka

10.4.2 在resources文件夹下创建share文件

将其他服务分离出来的放到该文件夹下，以服务名作为区别；
在这里插入图片描述

10.4.3 修改启动文件

  • @EnableEurekaClient：用于启动Eureka客户端注册功能
  • @EnableConfigServer：用于开启配置中心的服务

10.4.4 在对应的服务上添加config_client依赖

在springcloud_producers和pringcloud_consumer中添加

<!--添加config-client依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-client</artifactId>
</dependency>

10.4.5 修改producer的yml

server:
  port: 9091
spring:
  application:
    name: producer-service-jpa
  cloud:  #个性化配置的来源
    config:
      discovery:
        service-id: config-service 
      profile: dev
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

在这里插入图片描述

10.4.6 运行流程

  1. 服务启动时首先加载bootstrap注册自身，作为eureka的服务
  2. 然后去服务中心抓取（http://localhost:8888）
  3. 执行

10.5 第四版_实现远程服务配置（手动刷新）

10.5.1 配置consumer-server-dev

在share包下

  • 同理配置consumer-server-test
server:
  port: 9093

my:
  name: kak

10.5.2 配置consumer的bootstrap.yml

server:
  port: 9092
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
spring:
  application:
    name: consumer-server
  profiles:
    active: dev
  cloud:
    config:
      discovery:
        service-id: config-service
      profile: dev

10.5.3 在consumer下实现简单的测试

新建controller包，在该包下建立测试文件（ConfigTestController）

/**
 * Created by Kak on 2020/9/27.
 */
@RestController
public class ConfigTestController {
    @Value("${my.name}")
    private String myname;
    @RequestMapping("info")
    public String showInfo(){
        System.out.println(myname);
        return myname+"出来啊";
    }
}

在这里插入图片描述

  • 不重启服务器修改内容无法实现动态更新

10.5.4 上传到github上

创建SpringBoot项目(springcloud_remoteconfigserver)，选择以下依赖；

  • 启动文件中加入

    @EnableConfigServer
@EnableEurekaClient

在这里插入图片描述

10.5.5 配置application.yml

server:
  port: 8888
spring:
  application:
    name: config-service
  cloud:
    config:
      server:
        git:
          uri: https://github.com/XXXXXXXXXX.git  #配置中心，放置配置文件的git资源库
          search-paths: config-pro #在资源库中的搜索路径
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka

10.5.6 将分离出的文件内容放到GitHub上

上个版本的share文件下的东西

在这里插入图片描述

10.5.7 测试

同本地的一样

  • 修改后还是不会动态改变

  • 解决了异地的问题，但是统一的问题还没有解决

在这里插入图片描述

10.5.8 动态配置

解决统一性问题

  1. 修改GitHub上的配置文件
  2. 通过Git发送请求到Config服务
  3. 发送消息到MQ
  4. 指定的服务去获取MQ中得到的消息并且实现自动更新
10.5.8.1导入依赖
<!--导入RabbitMQ依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>
 <!--添加自动感知依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
10.5.8.2 在ConfigTestController中加入注解

@RefreshScope用于自动检测配置中心的消息

10.5.8.3 修改consumer中的bootstrap.yml
server:
  port: 9092
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
spring:
  application:
    name: consumer-server
  cloud:
    config:
      discovery:
        service-id: config-service
      profile: dev
  rabbitmq:
    virtual-host: /
    port: 5672
    username: guest
    password: guest
    host: localhost
# 添加感知
management:
  endpoints:
    web:
      exposure:
        include: "*"
10.5.8.4 修改springcloud_remoteconfigserver中的application.yml
server:
  port: 8888
spring:
  application:
    name: config-service
  cloud:
    config:
      server:
        git:
          uri: https://github.com/kak-willing/springcloud_config.git  #配置中心，放置配置文件的git资源库
          search-paths: config-pro   #在资源库中的搜索路径
  rabbitmq:
    virtual-host: /
    port: 5672
    username: guest
    password: guest
    host: localhost
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka
# 添加感知
management:
  endpoints:
    web:
      exposure:
        include: "*"

10.5.9 测试

在GitHub上修改后，自动拉取配置信息

手动发送http://localhost:9093/actuator/bus-refresh（POST请求），不需要重新启动服务就可以刷新

在这里插入图片描述

在这里插入图片描述

10.6 第五版_实现远程服务配置（自动刷新）

主要是通过内网穿透来实现

10.6.1 内网穿透

NATAPP内网穿透使用教程见：https://blog.csdn.net/weixin_42601136/article/details/108836388

进入隧道修改地址为8888
在这里插入图片描述

10.6.2 运行得到

复制http://9rfwpq.natappfree.cc到GitHub中

在这里插入图片描述

10.6.3 GitHub中配置

在这里插入图片描述

在这里插入图片描述

10.6.4 处理webhook反序列化异常

在这里插入图片描述

处理逆序列化

  • 在远端的remoteconfigserver中加入UrlFilter过滤器（根目录下）
package com.sx.kak;
import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
/**
 * Created by Kak on 2020/9/27.
 */
@Component

public class UrlFilter  implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest)request;
        HttpServletResponse httpServletResponse = (HttpServletResponse)response;
        String url = new String(httpServletRequest.getRequestURI());
        //只过滤/actuator/bus-refresh请求
        if (!url.endsWith("/bus-refresh")) {
            chain.doFilter(request, response);
            return;
        }
        //获取原始的body
        String body = readAsChars(httpServletRequest);
        System.out.println("original body:   "+ body);
        //使用HttpServletRequest包装原始请求达到修改post请求中body内容的目的
        CustometRequestWrapper requestWrapper = new CustometRequestWrapper(httpServletRequest);
        chain.doFilter(requestWrapper, response);
    }

    @Override
    public void destroy() {
    }
    private class CustometRequestWrapper extends HttpServletRequestWrapper {
        public CustometRequestWrapper(HttpServletRequest request) {
            super(request);
        }
        @Override
        public ServletInputStream getInputStream() throws IOException {
            byte[] bytes = new byte[0];
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
            return new ServletInputStream() {
                @Override
                public boolean isFinished() {
                    return byteArrayInputStream.read() == -1 ? true:false;
                }
                @Override
                public boolean isReady() {
                    return false;
                }
                @Override
                public void setReadListener(ReadListener readListener) {
                }
                @Override
                public int read() throws IOException {
                    return byteArrayInputStream.read();
                }
            };
        }
    }
    public static String readAsChars(HttpServletRequest request)
    {
        BufferedReader br = null;
        StringBuilder sb = new StringBuilder("");
        try
        {
            br = request.getReader();
            String str;
            while ((str = br.readLine()) != null)
            {
                sb.append(str);
            }
            br.close();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if (null != br)
            {
                try
                {
                    br.close();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }
        return sb.toString();
    }
}

10.6.5 测试结果

在这里插入图片描述

在这里插入图片描述

Willing卡卡
关注
  • 23
    点赞
  • 踩
  • 72
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 20
    评论
专栏目录
Springcloud_alibaba学习笔记
三明治文鱼的博客
04-21 1856
文章目录0. 简介区别特点组件1. 环境搭建2. Nacosa.作为服务注册中心启动Nacos Client简单上手服务间通信（和之前一样）应用搭建Controller具体实现RestTemplate+Ribbon：OpenFeignb.作为统一配置中心Config Client简单上手ControllerNacos中创建配置Nacos config自动刷新细节1、配置集(Data ID)2、配置分组(Group)3、命名空间(Namespace)4、最佳实践c.配置持久化d. 高可用（集群）nacos高可
超详细的SpringCloud底层原理
青藤的博客
05-24 8957
先来个简单的介绍吧！ SpringCloud框架 针对这个架构图我分层介绍一下： 1、是web服务器的选型，这个我选择的是nginx+keepalived，haproxy也是一个选择，但是haproxy在反向代理处理跨域访问的时候问题很多。所以我们nginx有些地方做了keep-alive模式处理，减少了三次握手的次数，提高了连接效率。keepalived做nginx的负载，虚拟一个vip对外，两个nginx做高可用，nginx本身反向代理zuul集群。 2、api gateway，这里的zuu
Spring Cloud 学习笔记（1 / 3）
热门推荐
KISS
03-03 20万+
Spring Cloud 学习笔记（2 / 3） Spring Cloud 学习笔记（3 / 3） - - - 01_前言闲聊和课程说明 02_零基础微服务架构理论入门 03_第二季Boot和Cloud版本选型 04_Cloud组件停更说明 05_父工程Project空间新建 06_父工程pom文件 07_复习DependencyManagement和Dependencies 08_支付模块构建(上) 09_支付模块构建(中) 10_支付模块构建(下) 11_热部署Devtool
【SpringCloud】学习笔记（全篇超万字整理）
m0_62819117的博客
06-01 1160
在此感谢黑马程序员的SpringCloud课程 所有笔记、生活分享首发于个人博客 【SpringCloud】学习笔记（全篇超万字整理）
SpringCloud 超详细个人笔记
写代码的渣渣苏
05-30 3114
文章目录SpringCloud1、常见面试题2、微服务概述2.1、什么是微服务2.2、微服务和微服务架构2.3、微服务优缺点2.4、微服务技术栈有哪些？2.5、为什么选择SpringCloud 作为微服务架构2.5.1、选型依据2.5.2、当前各大IT公司用的微服务架构有哪些？2.5.3、各微服务框架对比3、SpringCloud 入门概述3.1、SpringCloud是什么3.2、SpringCloud 和 SpringBoot关系3.3、Dubbo 和 SpringCloud技术选型3.3.1、分布式
狂神说-Springcloud笔记
向上的"狼"的博客
07-26 5502
Springcloud
尚硅谷 周阳老师 SpringCloud 学习笔记
shuai_aaaaaaa的博客
01-15 3073
十二、服务配置 Spring Cloud Config 配置中心 1. 概述 1.1 分布式系统面临的配置问题 微服务意味着要将单体应用中的业务拆分成一个个子服务，每个服务的粒度相对较小，因此系统中会出现大量的服务。由于每个服务都需要必要的配置信息才能运行，所以一套集中式的、动态的配置管理设施是必不可少的。 我们每一个微服务自己带着一个application.yml，上百个配置文件的管理就非常痛苦，SpringCloud 提供了ConfigServer来解决这个问题。 1.2 是什么 SpringCloud
SpringCloud学习笔记 - 1、Boot和Cloud版本选型
DarkAndGrey的博客
06-13 1508
本专栏文章的内容均来自于B站up主“尚硅谷”的教程视频。博主的博客，你可以理解为是博主在做笔记，方便复习。希望也可以帮到你们。
【Spring Cloud】【尚硅谷】学习笔记
hupengfei_shenyang的博客
01-06 2870
SpringCloud技术栈
【Springcloud篇】学习笔记一（一至三章）：微服务介绍、构建环境
踢桃的成长之路
01-30 1021
Springcloud微服务学习笔记
尚硅谷SpringCloud第二季笔记
01-22
【尚硅谷SpringCloud第二季笔记】是一份详细记录了SpringCloud组件使用的学习笔记，涵盖了SpringCloud在云原生环境下的核心概念和实践应用。SpringCloud是基于Spring Boot实现的微服务框架，它提供了构建分布式系统...
狂神springcloud笔记+源码+config.zip
05-10
狂神springcloud笔记+源码+config 狂神springcloud笔记+源码+config 狂神springcloud笔记+源码+config 狂神springcloud笔记+源码+config 狂神springcloud笔记+源码+config 狂神springcloud笔记+源码+...
SpringBoot+SpringCloud+SpringData社交平台源码及笔记
04-24
采用目前主流的微服务系统架构 SpringBoot+SpringCloud+SpringData进行开发，前端技术采用Vue.js 。系统整体分为 三大部分：微服务、网站前台、网站管理后台。功能模块包括文章、问答、招聘、活 动、吐槽、交友、...
spring-cloud:springCloud学习笔记
03-07
SpringCloud学习笔记1. maven父子项目父工程配置新项目，maven，父工程名称字符编码，设置，编辑器文件编码注解功效激活java编译选择1.8 文件类型文件过滤删除掉父工程下的src，只保留一个pom.xml父工程的pom.xml...
xmljava系统源码-spring-cloud-kuang:狂神springcloud笔记+源码+config
06-06
SpringCloud笔记 1、前言 1.1、回顾 回顾之前的知识 JavaSE 数据库 前端 Servlet Http Mybatis Spring SpringMVC SpringBoot Dubbo、Zookeeper、分布式基础 Maven、Git Ajax、Json ... 串一下自己会的东西 数据库 ...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1258
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
golang 接口
m0_70982551的博客
07-24 807
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 364
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
"SpringCloud实习笔记总结：微服务理念与技术应用
在这篇笔记总结实习中，作者总结了一年对于springcloud的技术经验，并表示这些记录是相对于自己来说比较重点的。首先，笔记总结了微服务的概念和意义。作者指出，在过去的“远古”年代，一个软件应用往往会将所有...
评论 20
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Willing卡卡

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值