SpringCloud

单体架构

单体架构: 将业务的所有功能集中在一个项目中开发,打成一个包部署.

优点:

• 架构简单
• 部署成本低

缺点:

• 耦合度高

分布式架构

分布式架构: 根据业务功能对系统进行拆分,每个业务模块作为独立项目开发,称为一个服务.

优点:

• 降低服务耦合度
• 有利于服务升级拓展

服务治理

分布式架构的要考虑的问题:

• 服务拆分力度如何?
• 服务集群地址如何维护?
• 服务之间如何实现远程调用?
• 服务健康状态如何感知?

微服务

微服务是一种经过良好架构设计的分布式架构方案,微服务结构特征:

• 单一职责: 微服务拆分力度更小,每一个服务都对应唯一的业务能力,做到单一职责,避免重复业务开发
• 面向服务:微服务对外暴露业务接口
• 自制:团队独立,技术独立,数据独立,部署独立
• 隔离性强: 服务调用做好隔离,容错,降级,避免出现级联问题

总结

单体架构特点?

• 检点方便,高度耦合,扩展性差,适合小型项目. 例如: 学生管理系统

分布式架构特点?

• 松耦合,扩展性好,单框架结构复杂,难度大.适合大型互联网项目,例如:京东,淘宝

微服务: 一种良好的分布式架构方案

• 优点:拆分力度更小,服务更独立,耦合度更低
• 缺点:结构非常复杂,运维,监控,部署难度提高

微服务结构

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

微服务技术对比

企业需求

SpringCloud

• SpringCloud是目前国内使用最广泛的微服务框架.官网地址: https://spring.io/projects/spring-cloud.
• SpringCloud集成了各种微服务功能组件,并基于SpringBoot实现了这些组件的自动装配,从而提供了良好的开箱即用体验:

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

服务拆分及远程调用

服务拆分注意事项

1. 不同微服务,不要重复开发相同业务
2. 微服务数据独立,不要访问其他微服务的数据库
3. 微服务可以将自己的业务暴露为接口,供启其他微服务调用

服务拆分及远程调用

导入服务拆分Demo

1. 导入课前资料提供的工程: cloud-demo
2. 项目结构
3. 将课前资料准备的sql导入数据库中:

总结

1. 微服务需要根据业务模块拆分,做到单一职责,不要重复开发相同业务
2. 微服务可以将业务暴露为接口,供其他微服务使用
3. 不同微服务都应该有自己独立的数据库

微服务远程调用

案例: 根据订单id查询订单功能

需求: 根据订单id查询订单的同时,把订单所属的用户信息一起返回

远程调用方式分析

步骤: 1)注册RestTemplate

在order-service的OrderApplication中注册RestTemplate

@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
    /**
     * 创建RestTemplate 并注入容器
     * @return
     */
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

步骤: 2)服务远程调用RestTemplate

修改order-service中的OrderService的queryOrderById方法:

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RestTemplate restTemplate;
    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        //2.利用RestTemplate发起http请求,查询用户
        //2.1.url路径
        String url = "http://localhost:8081/user/"+order.getUserId();
        //2.2.发送http请求,实现远程调用  参数1: url地址 参数2:返回json转换的类型
        User user = restTemplate.getForObject(url, User.class);
        //3.封装user到Order
        order.setUser(user);
        // 4.返回
        return order;
    }
}

总结

1.微服务调用方式

• 基于RestTemplate发起的http请求实现远超调用
• http请求做远程调用是与语言无关的调用,只要知道对方的ip,端口,接口路径,请求参数即可.

提供者与消费者

服务提供者: 一次业务中,被其他微服务调用的服务.(提供接口给其他微服务)

服务消费者: 一次业务中,调用其他微服务的服务.(调用其他微服务提供的接口)

服务A调用服务B,服务B调用服务C,那么服务B是什么角色?

一个服务既可以是消费者,也可以是一个提供者.

1.服务调用关系

• 服务提供者:暴露接口给其他微服务调用
• 服务消费者:调用其他微服务提供的接口
• 提供者与消费者角色其实是相对的

Eureka注册中心

服务调用出现的问题

url路径不能使用硬编码

服务消费者改如何获取服务提供者的地址信息?

如果有多个服务提供者,消费者该如何选择?

Eureka的作用

服务消费者改如何获取服务提供者的地址信息?

• 服务提供者启动时向eureka注册自己的信息
• eureka保存这些信息
• 消费者根据服务名称向eureka拉取提供者信息

如果有多个服务提供者,消费者该如何选择?

• 服务消费者利用负载均衡算法,从服务列表中挑选一个

消费者如何感知服务提供者健康状态?

• 服务提供者会每隔30秒向EurekaServer发送心跳请求,报告健康状态
• erueka会更新记录服务器列表信息,心跳不正常会被剔除
• 消费者就可以拉取到最新的信息

总结

在Eureka架构中,微服务角色有两类:

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

动手实践

搭建EurekaServer *

搭建EurekaServer服务步骤如下:

**Eureka** **server** **服务端**

1. 创建项目,引入spring-cloud-starter-netflix-eureka-server的依赖

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

1. 编写启动列,添加@EnableEurekaServer注解

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

1. 添加application.yaml文件,编写下面的配置

server:
 port: 10086
spring:
 application:
  name: eurekaserver #设置 当前 项目名,服务名
eureka:
 client:
  service-url:
   defaultZone: http://127.0.0.1:10086/eureka/

总结

1,搭建EurekaServer

• 引入eureka-server依赖
• 添加@EnableEurekaServer注解
• 在application.yaml中配置eureka地址

注册user-service *

将user-service服务注册到EurekaServer步骤如下:

**Eureke** **client** **客户端**

1. 在user-server项目引入spring-cloud-starter-netflix-eureka-client的依赖

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

1. 在application,yaml文件,编写下面的配置:

   spring:
   application:
   name: userservice        #设置 当前 项目名,服务名 
   eureka:
   client:
   service-url:
   defaultZone: http://127.0.0.1:10086/eureka/

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

总结

1. 服务注册

• 引入eureka-client依赖
• 在application.yaml中配置eureka地址

2.无论是消费者还是提供者,引入eureka-client依赖,知道eureka地址后,都可以完成服务注册

在order-service完成服务拉取 *

服务拉取是基于服务名称获取服务列表,然后在对服务列表做负载均衡

1. 修改OrderService的代码,修改访问的url路径,用服务名代表ip,端口 修改为application的name:

   String url = "http://userservice/user/"+order.getUserId();

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

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

总结

1. 搭建EurekaServer
   • 引入eureka-server依赖
   • 添加@EnableEurekaServer注解
   • 在application.yaml中配置eureka地址
2. 服务注册
   • 引入eureka-client依赖
   • 在application.yaml中配置eureka地址
3. 服务发现
   • 引入eureka-client依赖
   • 在application.yaml中配置eureka地址
   • 给RestTemplate添加@LoadBalanced注解 负载均衡
   • 用服务提供者的服务名称远程调用

Ribbon负载均衡 *

• 负载均衡原理
• 负载均衡策略
• 懒加载

负载均衡流程

负载均衡策略

Ribbon的负载均衡规则是一个叫做IRule的接口来定义的,每一个子接口都是一种规则:

通过定义IRule实现可以修改负载均衡规则,有两种方式:

1. 代码方式: 在order-service中的OrderApplication类中,定义一个新的IRule:
   全局负载均衡规则

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

1. 配置文件方式: 在order-service的application.yaml文件中,添加新的配置也可以修改规则:

   **先写服务名称 : 指定微服务来做负载均衡规则**

饥饿加载

Ribbon默认是采用懒加载,即第一次访问时才会去创建LoadBalanceClient,请求时间会很长.

而饥饿加载则会在项目启动是创建,降低第一次访问的耗时,通过下面配置开启饥饿加载:

ribbon:
 eager-load:
  enabled: true #开启饥饿加载
  clients: userservice #指定对userservice这个服务饥饿加载

总结

1.Ribbon负载均衡规则

• 规则接口是IRule
• 默认实现是ZoneAvoidanceRule, 根据zone选择服务列表, 然后轮询

2.负载均衡自定义方式

• 代码方式: 配置灵活, 但修改时需要重新打包发布
• 配置方式:直观, 方便, 无需重新打包发布,但是无法做全局配置

3.饥饿加载

• 开启饥饿加载
• 指定饥饿加载的微服务名称

Nacos注册中心

• 认识和安装Nacos
• Nacos快速入门
• Nacos服务分级储存模型
• Nacos环境隔离

认识Nacos

Nacos是阿里巴巴的产品, 现在是SpringCloud中的一个组件.相比Eureka功能更加丰富,在国内受欢迎度较高.

服务注册到Nacos *

本地安装了Nacos

1. 在cloud-demo父工程中添加spring-cloud-alibaba的管理依赖:

   <!-- nacos 的管理依赖 -->
   <dependency>
   <groupId>com.alibaba.cloud</groupId>
   <artifactId>spring-cloud-alibaba-dependencies</artifactId>
   <version>2.2.5.RELEASE</version>
   <type>pom</type>
   <scope>import</scope>
   </dependency>

1. 注解掉order-service和user-service中原有的eureka依赖.
2. 添加nacos的客户端依赖

   <!-- nacos客户端 依赖 -->
   <dependency>
   <groupId>com.alibaba.cloud</groupId>
   <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
   </dependency>

1. 修改user-service&order-service中的application.yaml文件,注释eureka地址,添加nacos地址:

   spring:
   cloud:
   nacos:
   server-addr: localhost:8848 # nacos 服务端地址

1. 启动并测试

总结 * 启动nacos

1. Nacos服务搭建
   1. 下载安装包
   2. 解压
   3. 在bin目录下运行指令: .\startup.cmd -m standalone
2. Nacos服务注册或发现
   1. 引入nacos.discovery依赖
   2. 配置nacos地址spring.cloud.nacos.server-addr

Nacos服务分级储存模型

服务跨集群调用问题

服务调用尽可能选择本地集群的服务, 跨集群调用延迟高

本地集群不可访问时, 再去访问其他集群

服务集群属性

1. 修改application.yaml, 添加如下内容

   spring:
   cloud:
   nacos:
   server-addr: localhost:8848 #nacos 服务端地址
   discovery:
   cluster-name: SD #配置集群名称, 也就是机房位置, 例如: HZ,杭州

1. 在Nacos控制台可以看到集群变化:

总结

1. Nacos服务分级存储模型
   1. 一级是服务, 例如userservice
   2. 二级是集群,例如杭州或上海
   3. 三级是实例,例如杭州机房的某台部署了userservice的服务器
2. 如何设置实例的集群属性
   1. 修改application.yaml文件 , 添加spring,cloud.nacos.discovery.cluster-name属性即可

根据集群负载均衡

**请求只会发送同集群名称 的 服务**

1. 修改order-service中的application.yaml, 设置集群为SD:

spring:
  application:
    name: orderservice    #设置服务名称
  cloud:
    nacos:
      server-addr: 127.0.0.1:8848   #设置nacos服务地址
      discovery:
        cluster-name: SD # 集群名称

1. 然后在order-service中设置负载均衡的IRule为NacosRule, 这个规则优先会寻找与自己同集群的服务:

userservice:
  ribbon:
    NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule #负载均衡规则

1. 注意将user-service的权重都设置为1

总结

1. NacosRule 负载均衡策略
   1. 优先选择同集群服务实例列表
   2. 本地集群找不到提供者, 才去其他集群寻找, 并且会包警告
   3. 确定了可以实例列表后,再采用随机负载均衡挑选实例

根据权重负载均衡

实际部署中会出现这样的场景:

• 服务器设备性能有差异, 部分实例所在机器性能较好, 另一些较差,我们希望性能好的机器承担更多的用户请求

Nacos提供了权重配置来控制访问频率, 权重越大则访问频率越高

1. 在Nacos控制台可以设置实例的权重值, 首先选中实例后面的编辑按钮
2. 将权重设置为0.1,测试可以发现8082被访问到的频率大大降低

总结

1. 实例的权重控制
   1. Nacos控制台可以设置实例的权重值, 0~1之间
   2. 同集群内的多个实例, 权重越高被访问的频率越高
   3. 权重设置为0则完全不会被访问

环境隔离 - namespace

Nacos中服务中储存和数据存储的最外层都是一个名为namespace的东西,用来做最外层隔离

Namespace —> Group —> Service/Data

1. 在Nacos控制台可以创建namespace, 用来隔离不同环境

1. 然后填写一个新的命名空间信息:

1. 保存后会在控制台看到这个命名空间的id:

1. 修改order-service的application.yaml, 添加namespace:

spring:
 application:
  name: orderservice    #设置服务名称
cloud:
 nacos:
  server-addr: localhost:8848 #安装nacos的地址 也就是server
  discovery:
   cluster-name: SD #山东
   namespace: b7933534-5e17-4012-a768-cec51d660abc #命名空间,填ID

1. 重启order-service后, 再来查看控制台:

1. 此时访问order-service, 因为namespace不同, 会导致找不到userservice, 控制台会报错:

总结

1. Nacos环境隔离
   1. namespace用来做环境隔离
   2. 每个namspace都有唯一id
   3. 不同namespace下的服务不可见

nacos注册中心细节分析

临时实例和非临时实例

服务注册到Nacos时, 可以选择注册为临时实例或非临时实例,通过下面的配置来设置:

spring:
 cloud:
  nacos:
   discovery:
    ephemeral: false #设置为非临时实例  #默认为 true临时实例  改为 false非临时实例

总结

1. Nacos与eureka的共同点
   1. 都支持服务注册和服务拉取
   2. 都支持服务提供者心跳方式做健康检测
2. Nacos与Eureka的区别
   1. Nacos支持服务端主动检测提供者状态: 临时实例采用心跳模式, 非临时实例采用主动检测模式
   2. 临时实例心跳不正常会被剔除, 非临时实例则不会被剔除
   3. Nacos支持服务列表变更的消息推送模式, 服务列表更新更及时
   4. Nacos集群默认采用AP方式, 当集群中存在非临时实例时, 采用CP模式; Eureka采用AP方式

Nacos配置管理

统一配置管理

• 配置更改热更新

在Nacos中添加配置信息,

在弹出表单中填写配置信息:

配置获取的步骤如下:

1. 引入Nacos的配置管理客户端依赖:

<!-- Nacos配置管理依赖 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

1. 在userservice中的resource目录添加一个bootstrap.yaml文件, 这个文件是引导文件, 优先级高于application.yaml:

spring:
 application:
  name: userservice #服务名称
 profiles:
  active: dev #开发环境, 这里是dev
 cloud:
  nacos:
   server-addr: localhost:8848 #Nacos地址
   config:
    file-extension: yaml #文件后缀名

我们在user-service中将pattern.dateformat这个属性注入到UserController中做测试:

@RestController
@RequestMapping("/user")
public class UserController {
    @Value("${pattern.dateformat}")
    private String dateformat;
    @GetMapping("now")
    public String now(){
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(dateformat));
    }
}

总结

将配置交给Nacos管理的步骤

1. 在Nacos中添加配置文件
2. 在微服务中引入nacos的config依赖
3. 在微服务中添加bootstrap.yaml, 配置nacos地址, 当前环境, 服务名称, 文件后缀名. 这些决定了程序启动是去nacos读取那个文件.

配置自动刷新

Nacos中的配置文件变更后, 微服务无需重启就可以感知. 不过需要通过下面两种配置实现:

• 方式一: 在@Value注入的变量所在类上添加注解@RefreshScope

• 方式二:使用@ConfigurationProperties注解

@Data
@Component
@ConfigurationProperties(prefix = "pattern")
public class PatternProperties {
    private String dateformat;
}
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private PatternProperties dateformat;
    @GetMapping("now")
    public String now(){
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(dateformat.getDateformat()));
    }
}

总结

Nacos配置更改后, 微服务可以实现热更新,方式:

1. 通过@Value注解注入, 结合@RefreshScope来刷新
2. 通过@ConfigurationProperties注入, 自动刷新

注意事项:

• 不是所有的配置都适合放到配置中心, 维护起来比较麻烦
• 建议将一些关键参数, 需要运行时调整的参数放到nacos配置中心,一般都是自定义配置

多环境配置共享

微服务启动时从nacos读取多个配置文件:

• [spring,application.name]-[spring.profiles.active].yaml, 例如: userservice-dev.yaml
• [spring.application.name].yaml, 例如: userservice.yaml

多种配置的优先级:

• 服务名-profile.yaml >服务名称.yaml > 本地配置
• 
  

微服务会从nacos读取的配置文件:

1. [服务名]-[spring.profile.active].yaml, 环境配置
2. [服务名].yaml, 默认配置, 多环境共享

优先级:

1. [服务名]-[环境].yaml > [服务名].yaml > 本地配置

Nacos集群搭建

Nacos生产环境下一定要部署为集群状态, 部署方式参考课前资料中的文档:

总结

集群搭建步骤:

1. 搭建MySQL集群并初始化数据库表 Nacos的数据存储
2. 下载解压nacos
3. 修改集群配置(节点信息) , 数据库配置
4. 分别启动多个nacos节点
5. nginx反向代理

HTTP客户端Feign

RestTemolate方式调用存在的问题

先来看我们以前利用RestTemplate发起远程调用代码:

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

存在下面的问题:

• 代码可读性差, 编程体验不统一
• 参数复杂URL难以维护

Feign的介绍

Feign是一个声明式的http客户端, 官方地址: https://github.com/OpenFeign/feign

其作用就是帮助我们优雅的实现http请求的发送,解决上面提到的问题.

定义和使用Feign客户端

使用Feign的步骤如下:

1. 引入依赖

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

1. 在order-service的启动类添加注解开启Feign的功能:

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

1. 编写Feign客户端:

@FeignClient("userservice") //指定客户端
public interface UserClient {
    @GetMapping("/user/{id}")  //客户端接口开放接口
    User findById(@PathVariable("id") Long id);   //路径里的参数
}

1. service调用

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private UserClient userClient;
    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        //2.用Feign远程调用
        User user = userClient.findById(order.getUserId());
        //3.封装user到Order
        order.setUser(user);
        // 4.返回
        return order;
    }
}

主要是基于SpringMVC的注解来声明远程调用的信息, 比如:

• 服务名称: userservice
• 请求方式: GET
• 请求路径: /user/{id}
• 请求参数: Long id
• 返回值类型: User

Feign 内部 集成了Ribbon 自动实现了负载均衡

总结

Feign的使用步骤

1. 引入依赖
2. 添加@EnableFeignClients注解
3. 编写FeignClient接口
4. 使用FeignClient中定义的方法代替RestTemplate

自定义Feign的配置

Feign运行自定义配置来覆盖默认配置, 可以修改的配置如下:

一般我们需要配置的就是日志级别.

配置Feign日志有两种方式:

方式一: 配置文件方式

1. 全局生效

feign:
 client:
  config:
   default: #这里用default就是全局配置, 如果写服务名称, 则是针对某个微服务的配置
    loggerLevel: FULL #日志级别

1. 全局生效

feign:
 client:
  config:
   userservice: #这里用default就是全局配置, 如果写服务名称, 则是针对某个微服务的配置
    logerLevel: FULL #日志级别

配置Feign日志的方式二: java 代码方式, 需要先声明一个Bean:

public class FeignClientConfiguration {
    @Bean
    public Logger.Level feignLogLevel(){
        return Logger.Level.BASIC:
    }
}

1. 而后如果是全局配置, 则把它放到@EnableFeignClients这个注解中:

@EnableFeignClients(defultConfiguration = FeignClientConfiguration.class)

1. 如果是局部配置, 则把它放到@FeignClient这个注解中:

@FeignClient(value = "userservice", configuration = FeignClientConfiguration.class)

总结

Feign的日志配置:

1. 方式一是配置文件, feign.client.config.xxx.loggerLevel
   1. 如果是xxx是default则代表全局
   2. 如果xxx是服务名称, 例如userservice则代表某个服务
2. 方式二java代码配置Logger.Level这个Bean
   1. 如果在@EnableFeignClients注解声明则代表全局
   2. 如果在@FeignClient注解中声明则代表某服务

Feign的性能优化

Feign底层的客户端实现:

• URLConnection: 默认实现, 不支持连接池
• Apache HttpClient: 支持连接池
• OKHttp: 支持连接池

因此优化Feign的性能主要包括:

1. 使用连接池代替默认的URLConnection
2. 日志级别,最好用basic或none

Feign的性能优化-连接池配置

Feign添加HttpClient的支持:

引入依赖:

<!-- httpClient的依赖 -->
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-httpclent</artifactId>
</dependency>

配置连接池:

feign:
 client:
  config:
   default: # default 全局的配置
    loggerLevel: BASIC # 日志级别, BASIC 就是基本的请求和响应信息
 httpclient:
  enabled: true #开启feign对HttpClient的支持
  max-connections: 200 #最大线程数
  max-connections-per-route: 50 #每个路径的最大连接数

总结

1. 日志级别尽量用basic
2. 使用HttpClient或OKHttp代替URLConnection
   1. 引入feign-httpClient依赖
   2. 配置文件开启httpClient功能,设置连接池参数

Feign的最佳实践

方式一(继承) : 给消费者的FeignClient和提供者的controller定义统一的父接口作为标准.

• 服务紧耦合
• 父接口参数列表中的映射不会被继承

方式二(抽取) : 将FeignClient抽取为独立模块, 并且把接口有关的POJO, 默认的Feign配置都放到这个模块中, 提供给所有消费者使用

总结

1. 让controller和FeignClient继承同一接口
2. 让FeignClient, POJO, Feign的默认配置都定义到一个项目中, 供消费者使用

抽取FeignClient 实现方法二

实现最佳实践方式二的步骤如下:

1. 首先创建一个module, 命名为feign-api, 然后引入feign的starter依赖
2. 将order-service中编写的UserClient, User, DefaultFeignConfiguration都复制到feign-api项目中
3. 在order-service中引入feign-api的依赖
4. 修改order-service中的所有与上述三个组件有关的import部分, 改成导入feign-api中的包
5. 重启测试

当定义的FeignClient不在SpringBootApplication的扫描包范围时,这些FeignClient无法使用.有两种方式解决:

方式一: 指定FeignClient所在包

@EnableFeignClients(basepackages = "cn.itcast.feign.clients")

方式二:指定FeignClient字节码

EnableFeignClients(clients = {UserClient.class})

总结

不同包的FeignClient的导入有两种方式:

1. 在@EnableFeignClients注解中添加basePackages, 指定FeignClient所在的包
2. 在@EnableFeignClients注解中添加clients, 指定具体FiegnClient的字节码

统一网关Gateway

为什么需要网关

网关功能:

• 身份认证和权限校验
• 服务路由,负载均衡
• 请求限流

网关的技术实现

在SpringCloud中网关的实现包括两种:

• gateway
• zuul

Zuul是基于Servlet的实现, 属于阻塞式编程. 而SpringCloudGateway则是基于Spring5中提供的WebFlux,属于响应是编程的实现,具备更好的性能.

总结

网关的作用:

• 对用户请求做身份认证, 权限校验
• 将用户请求路由到微服务, 并实现服务均衡
• 对用户请求做限流

搭建网关服务

搭建网关服务的步骤:

1. 创建新的module, 引入SpringCloudGateway的依赖和nacos的服务发现依赖:

<!-- 网关依赖 -->
<dependency>
    <gropuId>org.springframework.cloud</gropuId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!-- nacos 服务发现依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

1. 编写路由配置及nacos地址

server:
 port: 10010 #网关端口
spring:
 application:
  name: gateway #服务名称
 cloud:
  nacos:
   server-addr: localhost:8848 # nacos地址
  gateway:
   routes: #网关路由配置
    - id: user-service #路由id, 自定义, 只要唯一即可
     # uri: http://127.0.0.1:8081 #路由的目标地址 http就是固定地址
     uri: lb://userservice #路由的目标地址 lb就是负载均衡, 后面跟服务名称
     predicates: #路由断言, 也就是判断请求是否符合路由规则的条件
      - Path=/user/** # 这个是按照路径匹配, 只要以/user/开头就符合要求

流程图:

总结

网关搭建步骤:

1. 创建项目, 引入nacos服务发现和gateway依赖
2. 配置application.yaml, 包括服务基本信息, nacos地址, 路由

路由配置包括:

1. 路由id: 路由的唯一标识
2. 路由目标(uri) : 路由的目标地址, http代表固定地址,lb代表跟根据服务名负载均衡
3. 路由断言(predicates) : 判断路由的规则
4. 路由过滤器(filters) : 对请求或响应做处理

路由断言工厂Route Predicate Factory

网关路由可以配置的内容包括:

• 路由id: 路由唯一标识
• uri: 路由目的地, 支持lb和http两种
• predicates: 路由断言, 判断请求是否符合要求, 符合则转发到路由目的地
• filters: 路由过滤器, 处理请求或响应
• 我们在配置文件中写的断言只是字符串, 这些字符串会被Predicate Factory读取并处理, 转变为路由判断的条件
• 例如Path=/user/是按照路径匹配, 这个规则是由
  org.springframework.cloud.gateway.handler.predicate.PathRoutePredicateFactory类来处理**
• 像这样的断言工厂在SpringCloudGateway还有十几个

Spring提供了11中基本的Predicate工厂:

总结

PredicateFactory的作用是什么?

读取用户定义的断言条件, 对请求做出判断

Path=/user/是什么含义?

路径是以/user开头的就是符合的

路由过滤器

GatewayFilter 是网关中提供的一种过滤器,可以对进行网关的请求和微服务返回的响应做处理:

过滤器工厂 GatewayFilterFactory

Spring提供了31种不同的路由过滤器工厂.例如:

案例 给所有进入userservice的请求添加一个请求头

给所有进入userservice的请求添加一个请求头: Truth=itcast is freaking awesome!

实现方式: 在gateway中修改application.yaml文件, 给userservice的路由添加过滤器:

spring:
 cloud:
  gateway:
   routes: #网关路由设置
     - id: user-service
      uri: lb://userservice
      predicates: 
       -Path=/user/**
      filters: #过滤器
       - AddRequestHeader=Truth, Itcast is freaking awesome!  #添加请求头

默认过滤器

如果要对所有的路由都生效, 则可以将过滤器工厂写到default下. 格式如下:

spring:
 application:
  name: gateway #服务名称
 cloud:
  nacos:
   server-addr: localhost:8848 # nacos 地址
  gateway:
   routes: #网关路由配置
     - id: user-service
       uri: lb://userservice
       predicates:
        - Path=/user/**
     - id: order-service
       uri: lb://orderservice
       predicates:
         - Path=/order/**
   default-filters: #默认过滤器, 会对所有的路由请求都生
    - AddRequestHeader=Truth,Itcast is freaking awesome! #添加请求头

总结

过滤器的作用是什么?

1. 对路由的请求或响应做加工处理, 比如添加请求头
2. 配置在路由下的过滤器只对当前路由的请求生效

defaultFilters的作用是什么?

1. 对所有路由都生效的过滤器

全局过滤器 GlobalFilter

全局过滤器的作用也是处理一切进入网关的请求和微服务响应, 与Gatewayfilter的作用一样.

区别在于GatewayFilter通过配置定义, 处理逻辑是固定的. 而GlobFilter的逻辑需要自己写代码实现.

定义方式是实现GlobalFilter接口.

public interface GlobalFilter{
    /**
     *
     * 处理当前请求, 有必要的话通过{@link GatewayFilterChain} 将请求交给下一个过滤器处理
     *
     * @param exchange 请求上下文, 里面可以获取Request, Response等信息
     * @param chain 用来把请求委托给下一个过滤器
     * @return {@code Mono<Void>} 返回标示当前过滤器业务结束
     */
    Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);
}

案例 定义全局过滤器, 拦截并判断用户身份

需求: 定义全局过滤器, 拦截请求, 判断请求的参数是否满足下面条件:

• 参数中是否有authorization,
• authorization参数值是否为admin

如果同时满足则放行, 否则拦截

步骤1: 自定义过滤器

自定义类, 实现GlobalFilter接口, 添加@Order注解 或者 实现 Ordered:

//@Order(-1) //顺序 越小优先值越高 Filter执行顺序
@Component
public class AuthorizeFilter implements GlobalFilter, Ordered { //也可以使用Ordered 来实现顺序 
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1.获取请求参数
        ServerHttpRequest request = exchange.getRequest();
        MultiValueMap<String, String> params = request.getQueryParams();
        // 2.获取参数中的 authorization 参数
        String auth = params.getFirst("authorization");
        // 3.判断参数值是否等于 admin
        if("admin".equals(auth)){
            // 4.是, 放行
            return chain.filter(exchange);
        }
        // 5.否, 拦截
        // 5.1.设置状态码
        exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
        // 5.2拦截请求 结束请求
        return exchange.getResponse().setComplete();
    }
    //实现Ordered 顺序
    @Override
    public int getOrder() {
        return -1;
    }
}

总结

• 全局过滤器的作用是什么?
  对所有路由都生效的过滤器,并且可以自定义处理逻辑
• 实现全局过滤器的步骤?
  1. 实现GlobalFiler接口
  2. 添加@Order注解或实现Ordered接口
  3. 编写处理逻辑

过滤器执行顺序

请求进入网关会碰到三类过滤器, DefaultFilter , GlobalFilter

请求路由后, 会将当前路由过滤器和DefaultFilter , GlobalFilter, 合并到一个过滤器链(集合)中, 顺序后依次执行每个过滤器

• 每一个过滤器都必须指定一个int类型的order值, order值越小, 优先级越高, 执行顺序越靠前.
• GlobalFilter通过实现Ordered接口, 或者添加@Order注解来指定order值, 由我们自己指定
• 路由过滤器和defaultFilter的order由Spring指定, 默认是按照声明顺序从1递增.
• 当过滤器的order值一样时, 会按照defaultFilter > 路由过滤器 > GlobalFilter的顺序执行.

可以参考下面几个类的源码来查看:

org.springframework.cloud.gateway.route.RouteDefinitionRouteLocator#getFilters()方法是先加载defaultFilters, 然后在加载某个route的filters, 然后合并.
org.springframework.cloud.gateway.handler.FilteringWebHandler#handle()方法会加载全局过滤器,与前面的过滤器合并后根据order排序, 组织过滤器链

总结

• 路由过滤器, defaultFilter, 全局过滤器的执行顺序?
  1. order值越小, 优先级越高
  2. 当order值一样时, 顺序是defaultFilter最先, 人后是局部的路由过滤器, 最后是全局过滤器

跨域问题处理 ajax

跨域: 域名不一致就是跨域, 主要包括:

• 域名不同: www.taobao.com 和 www.taobao.org 和 www.jd.com 和 miaosha.jd.com
• 域名相同, 端口不同 : localhost:8080和 localhost8081

跨域问题: 浏览器禁止请求的发起者与服务端发生跨域ajax请求, 请求被浏览器拦截的问题

解决方案: CORS

网关处理跨域采用的同样是CORS方案, 并且值需要简单配置即可实现:

spring:
  cloud:
    gateway:
      globalcors: # 全局的跨域处理
        add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题
        corsConfigurations:
          '[/**]':
            allowedOrigi    ns: # 允许哪些网站的跨域请求        所有要发起ajax请求都都要加上 包括本地端口
              - "http://localhost:5500"     #是localhost 就写 地址栏就写localhost 不要127 ***
              - "http://www.leyou.com"
            allowedMethods: # 允许的跨域ajax的请求方式
              - "GET"
              - "POST"
              - "DELETE"
              - "PUT"
              - "OPTIONS"
            allowedHeaders: "*" # 允许在请求中携带的头信息
            allowCredentials: true # 是否允许携带cookie
            maxAge: 360000 # 这次跨域检测的有效期

总结

CORS跨域要配置的参数包括哪几个?

• 允许哪些域名跨域?
• 允许哪些请求头?
• 允许哪些请求方式?
• 是否允许使用cookie?
• 有效期是多久?

Docker

项目部署的问题

大型项目组件较多, 运行环境也较为复杂, 部署时会碰到一些问题:

• 依赖关系复杂, 容易出现兼容性问题
• 开发, 测试, 生产环境有差异

Docker

Docker如何解决依赖的兼容问题的?

• 将应用的Libs(函数库), Deps(依赖), 配置与应用一起打包
• 将每个应用放到一个隔离容器去运行, 避免互相干扰

不同环境的操作系统不同, Docker如何解决? 我们先来了解下操作系统结构

内核与硬件交互, 提供操作硬件的指令

系统应用封装内核指令为函数, 便于程序员调用

用户程序基于系统函数库实现功能

Ubuntu和CentOS都是基于Linux内核, 只是系统应用不同, 提供的函数库有差异

Docker如何解决不同系统环境的问题?

• Docker将用户程序与需要调用的系统(比如Ubuntu)函数库一起打包
• Docker运行到不同操作系统时,直接基于的打包的库函数, 借助于操作系统的Linux内核来运行

Docker如何解决大型项目依赖关系复杂, 不同组件依赖的兼容性问题?

• Docker 允许开发中将应用, 依赖 , 函数库, 配置一起打包, 形成可移植镜像
• Docker 应用运行在容器中, 使用沙箱机制, 互相隔离

Docker如何解决开发, 测试, 生产环境有差异的问题

• Docker镜像中包含完整运行环境, 包括系统函数库, 仅依赖系统的Linux内核,因此可以在任意Linux操作系统上运行

总结

Docker是一个快速交付应用, 运行应用的技术:

1. 可以将程序及其以依赖, 运行环境一起打包为一个镜像,可以迁移到任意LInux操作系统
2. 运行时利用沙箱机制形成隔离容器, 各个引用互不干扰
3. 启动, 移除都可以通过一行命令完成, 方便快捷

Docker与虚拟机

虚拟机(virtual machine)是在操作系统中模拟硬件设备, 然后运行另一个操作系统, 比如在Windows系统里面运行Ubuntu系统, 这样就可以运行任意的Ubuntu应用了.

总结

Docker和虚拟机的差异:

• docker是一个系统进程; 虚拟机是在操作系统中的操作系统
• docker体积小,启动速度快, 性能好; 虚拟机体积打, 启动速度慢, 性能一般

镜像和容器

镜像(Image) : Docker将应用程序及其所需的依赖, 函数库, 环境, 配置等文件打包在一起, 称为镜像.

容器(Container) : 镜像中的应用程序运行后形成的进程就是容器, 只是Docker会给容器做隔离, 对外不可见.

Docker和DockerHub

• DockerHub : DockerHub是一个Docker镜像的托管平台. 这样的平台称为Dockker
• 国内也有类似于DockerHub的公开服务, 比如 网易云镜像服务, 阿里云镜像库等.

docker架构

Docker是一个CS架构的程序, 由两部分组成:

• 服务端(server) : Docker守护进程, 负责处理Docker指令, 管理镜像, 容器等
• 客户端(client) : 通过命令或RestAPI项Docker服务端发送指令. 可以在本地或远程向服务端发送指令.

总结

镜像:

• 将应用程序及其依赖, 环境, 配置打包在一起

容器:

• 镜像运行起来就是容器, 一个镜像可以运行多个容器

Docker结构:

• 服务端 : 接收命令或远程请求, 操作镜像或容器
• 客户端 : 发送命令或者请求到Docker服务端

DockerHub:

• 一个镜像托管的服务器, 类似的还有阿里云镜像服务, 统称为DockerRegistry

安装Docker

企业部署一般都是采用Linux操作系统, 而其中又数CentOS发行版占比最多, 因此我们在CentOS下安装Docker. 参考课前资料中的文档:

Docker基本操作

镜像相关命令

• 镜像名称一般分两部分组成: [reqository]:[tag].
• 在没有指定tag时, 默认是latest, 代表最新版本的镜像

镜像操作命令

Docker --help 查看文档

docker build 构建镜像
docker imagers 查看镜像
docker rmi 删除镜像
docker push 推送镜像到服务
docker pull 从服务拉取镜像
docker save 保存镜像为一个压缩包
docker load 加载压缩包为镜像

案例 从DockerHub中拉取一个nginx镜像查看

1. 首先去镜像仓库搜索nginx镜像, 比如DockerHub:

1. 根据查看到的镜像名称, 拉取自己需要的镜像, 通过命令: docker pull nginx

1. 通过命令: docker images 查看拉取到的镜像

案例 利用docker save 将nginx镜像导出磁盘, 然后在通过load加载回来

步骤一 : 利用docker xx —help命令查看docker save 和 docker load的语法

步骤二 : 使用docker tag 创建新镜像 mynginx1.0

步骤三 : 使用docker save 导出镜像到磁盘

总结

镜像操作有哪些?

• docker images
• docker rmi
• docker pull
• docker push
• docker save
• docker load

Docker基本操作-镜像操作

练习 去DockerHub搜索并拉取一个Redis镜像

1. 去DockerHub搜索Redis镜像
2. 查看Redis镜像的名称和版本
3. 利用docker pull 命令拉取镜像
4. 利用docker save 命令将 redis:latest打包为一个redis.tar包
5. 利用docker rmi删除本地的redis:latest
6. 利用docker load 重新加载redis.tar文件

容器相关命令

创建一个容器(默认开启)

docker run

暂停容器

docker pause

从暂停中开启

docker unpause

停止容器

docker stop

开启容器

docker start

查看所有运行的容器以及状态

docker ps

查看容器运行日志

docker logs

进入容器执行命令

docker exec

删除指定容器

docker rm

Docker基本操作-容器

案例 创建运行一个Nginx容器

步骤一: 去docker hub查看Nginx的容器运行命令

docker run --name containerName -p 80:80 -d nginx

命令解读:

• docker run: 创建并运行一个容器
• —name : 给容器起一个名字,比如叫mn
• -p : 将宿主机端口与容器端口映射, 冒号左侧是宿主机端口, 右侧是容器端口
• -d : 后台运行
• nginx : 镜像名称, 例如nginx

总结

docker run命令 的常见参数有哪些?

• —name : 指定容器名称
• -p : 指定端口映射
• -d : 让容器后台运行

查看容器日志的命令:

• docker logs
• 添加 -f 参数可以持续查看日志

查看容器状态:

• docker ps

案例 进入Nginx容器, 修改HTML文件内容, 添加”爱玩游戏的傲,欢迎您”

步骤一: 进入容器. 进入我们刚刚创建的nginx容器的命令为:

docker exec -it mn bash

命令解读:

• docker exec : 进入容器内部, 执行一个命令
• -it : 给当前进入的容器创建一个标准输入, 输出终端, 允许我们与容器交互
• mn : 要进入的容器的名称
• bash : 进入容器后执行的命令, bash是一个linux终端交互命令

步骤二: 进入nginx的HTML所在目录 /usr/share/nginx/html

cd /usr/share/nginx/html

步骤三: 修改index.html的内容

sed -i 's#Welcome to nginx#爱玩游戏的傲#g' index.html
sed -i 's#<head>#<head><meta charset="utf-8">#g' index.html

总结

查看容器状态:

• docker ps
• 添加-a参数 查看所有状态的容器

删除容器:

• docker rm
• 不能删除运行中的容器, 除非添加-f参数

进入容器:

• 命令是docker exec -it [容器名] [要执行的命令]
• exec命令可以进入容器修改文件, 但是在容器内修改文件是不推荐的

exit 退出

练习 并创建一个redis容器, 并支持数据持久化

步骤一 : 到DockerHub搜索Redis镜像

步骤二 : 查看Redis镜像文档中的帮助信息

步骤三 : 里兜docker run命令运行一个Redis容器

数据卷

容器与数据耦合的问题

数据卷(volume) 是一个虚目录, 指向宿主机文件系统中的某个目录.

操作数据卷

数据卷操作的基本语法如下:

docker volume [COMMAND]

docker volume 命令是数据卷操作, 根据命令后跟随的command来确定下一步的操作:

• create 创建一个volume
• inspect 显示一个或多个volume的信息
• ls 列出所有的volume
• prune 删除未使用的volume
• rm 删除一个或多个指定的volume

案例 创建一个数据卷, 并查看数据卷在宿主机的目录位置

1. 创建数据卷

   docker volume create [name]

1. 查看所有数据

   docker volume ls

1. 查看数据卷详细信息卷

   docker volume inspect

总结

数据卷的作用:

• 将容器与数据分离, 解耦合, 方便操作容器内数据, 保证数据安全

数据卷操作:

• docker volume create
• docker volume ls
• docker volume inspect
• docker volume rm
• docker volume prune

挂载数据卷

-v

我们在创建容器时, 可以通过-v参数来挂在一个数据卷到某个容器目录

举例说明

docker run\                    dockerrun : 就是创建并运行容器
 --name mn\                    --name mn : 给容器起个名字叫mn            
 -v html:/root/html\        -v html:/root/html : 把html数据卷挂在到容器内的/root/html这个目录中
 -p 8080:80                    -p 8080:80 : 把宿主机的8080端口映射到容器内的80端口
 nginx\                        nginx : 镜像名称

案例 创建一个nginx容器, 修改容器内的html目录内的index.html内容

需求说明 : 上个案例中, 我们进入nginx容器内部, 已经知道nginx的html目录所在位置

/usr/share/nginx/html , 我们需要把这个目录挂在到html这个数据卷上, 方便操作其中的内容.

提示 : 运行容器使用-v 参数挂在数据卷

步骤:

1. 创建容器并挂载数据卷到容器内的HTML目录

   docker run --name mn -v html:/usr/share/nginx/html -p 80:80 -d nginx

1. 进入html数据卷所在位置, 并修改HTML内容

# 查看html数据卷的位置
docker volume inspect html
# 进入该目录
cd /var/lib/docker/volumes/html/_data
# 修改文件
vi index.html

总结

数据卷挂在方式:

• -v volumeName:/targetContainerPath
• 如果容器运行时volume不存在, 会自动被创建出来

案例 创建并运行一个MySQL容器, 将宿主机目录直接挂载到容器

提示: 目录挂载与数据卷挂在的语法是类似的:

• -v [宿主机目录]:[容器内目录]
• -v [宿主机文件]:[容器内文件]

实现思路如下:

1. 在将课前资料中的mysql.tar文件上传到虚拟机, 通过load命令加载为镜像
2. ``创建目录/tmp/mysql/data
3. 创建目录/tmp/mysql/conf, 将课前资料提供的hmy.cnf文件上传到/tmp/mysql/conf
4. 去DockerHub查阅资料, 创建并运行MySQL容器, 要求:
   1. 挂载/tmp/mysql/data到mysql容器内数据存储目录
   2. 挂载/tmp/mysql/conf/hmy.cnf到mysql容器的配置文件
   3. 设置MySQL密码

docker run —name mysql \

-e MYSQL_ROOT_PASSWORD=zhang..0902 \

-p 3306:3306 \

-v /tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf \

-v /tmp/mysql/data:/var/lib/mysql \

-d \

mysql:5.7.25 \

数据卷挂载的方式对比

总结

1. docker run的命令通过-v参数挂载文件或目录到容器中:
   1. -v volume名称:容器内目录
   2. -v 宿主机文件:容器内文件
   3. -v 宿主机目录:容器内目录
2. 数据卷挂载与目录直接挂载的
   1. 数据卷挂载解耦合度低, 由docker来管理目录, 但是目录较深,不好找
   2. 目录挂载解耦合度高,需要我们自己管理目录, 不过目录容易寻找查看

Dockerfile自定义镜像

镜像结构

• 镜像是将应用程序及其需要的系统函数库, 环境,配置,依赖打包而成.

总结

镜像是分层结构, 每一层称为一个Layer

• Baselmage层: 包含基本的系统函数库,环境变量,文件系统
• Entrypoint: 入口, 是镜像中应用启动的命令
• 其他: 在Baselmage基础上添加依赖, 安装程序, 完成整个应用的安装和配置

什么是Dockerfile

Dockerfile就是一个文本文件, 其中包含一个个指令(Instruction), 用指令来说明要执行什么操作来构建镜像. 每一个指令都会形成一层Layer.

案例 基于Ubuntu镜像构建一个新镜像, 运行一个java项目

步骤一 : 新建一个空文件夹docker-demo

步骤二 : 拷贝课前资料中的docker-demo.jar文件到docker-demo这个目录

步骤三 : 拷贝课前资料中的jdk8.tar.gz文件到docker-demo这个目录

步骤四 : 拷贝课前资料提供的Dockerfile到docker-demo这个目录

步骤五 : 进入docker-demo

步骤六 : 运行命令

docker bulid -t javaweb:1.0.

案例 基于java:8-alpine镜像, 将一个java项目构建为镜像

实现思路如下:

1. 新建一个空的目录, 然后在目录中新建一个文件, 命名为Dockerfile
2. 拷贝课前资料提供的docker-demo.jar到这个目录中
3. 编写Dockerfile文件:
   1. 基于java:8-alpine作为基础镜像
   2. 将app.jar拷贝到镜像中
   3. 暴露端口
   4. 编写入口ENTRYPOINT
4. 使用docker build命令构建镜像
5. 使用docker run创建容器并运行

#指定基础镜像
FROM ubuntu:16.04
#配置环境变量,JDK的安装目录
ENV JAVA_DIR=/usr/local
#拷贝jdk和java项目的包
COPY ./jdk8.tar.gz $JAVA_DIR
COPY ./docker-demo.jar /tmp/app.jar
#安装JDK
RUN cd $JAVA_DIR \
 && tar -xf ./jdk8.tar.gz \
 && mv ./jdk1.8.0_144 ./java8
#配置环境变量
ENV JAVA_HOME=$JAVA_DIR/java8
ENV PATH=$PATH:$JAVA_HOME/bin
#暴露端口
EXPOSE 8090
#入口, java项目的启动命令
ENTRYPOINT java -jar /tmp/app.jar

总结

1. Dockerfile的本质是一个文件, 通过指令描述镜像的构建过程
2. Dockerfile的第一行必须是FROM,从一个基础镜像来构建
3. 基础镜像可以是基础操作系统, 如Ubuntu. 也可以是其他人制作好的镜像, 例如: java:8-alpine

DockerCompose

什么是DockerCompose

• Docker Compose可以基于Compose文件帮助我们快速的部署分布式应用, 无需手动一个个创建和运行容器!
• Compose文件是一个文本文件, 通过指令定义集群中的每个容器如何运行.

• DockerCompose的详细语法参考官网: https://docs.docker.com/compose/compose-file/

安装DockerCompose

参考课前资料

Centos7安装Dokcer.md

总结

version: “3.2”

services:

nacos:

image: nacos/nacos-server

environment:

MODE: standalone

ports:

• “8848:8848”

mysql:

image: mysql:5.7.25

environment:

MYSQL_ROOT_PASSWORD: 123

volumes:

• “$PWD/mysql/data:/var/lib/mysql”

• “$PWD/mysql/conf:/etc/mysql/conf.d/“

userservice:

build: ./user-service

orderservice:

build: ./order-service

gateway:

build: ./gateway

ports:

• “10010:10010”

DokcerCompose有什么作用?

• 帮助我们快速部署分布式应用, 无需以一个个微服务去构建镜像和部署.

案例 将之前学习的cloud-demo微服务集群利用DockerCompose部署

实现思路如下:

1. 查看课前资料提供的cloud-demo文件夹, 里面已经编写好了, 里面已经编写好了docker-compose文件
2. 修改自己的cloud-demo项目, 将数据库, nacos地址都命名为docker-dompose中的服务名
3. 使用Maven打包工具, 将项目中的每个微服务都打为app.jar
4. 将打包好的app.jar拷贝到cloud-demo中的每一个对应的子目录
5. 将cloud-demo上传至虚拟机, 利用docker-compose up -d 来部署

Docker镜像仓库

常见镜像仓库服务

镜像仓库 (Docker Registry) 有公共的和私有的两种形式:

• 公共仓库 : 例如DOcker官方的Docker Hub, 国内也有一些云服务商提供类似于 Docker Hub 的公开服务, 比如 网易云镜像仓库, DaoCloud镜像服务, 阿里云镜像服务等.
• 除了使用公开仓库外, 用户还可以在本地搭建私有 Docker Registry. 企业自己的镜像最好是采用私有的Docker Registry来实现.

在私有镜像仓库推送或拉取镜像

推送镜像到使用镜像服务必须先tag, 步骤如下:

1. 重新tag本地镜像, 名称前缀为私有仓库的地址: 你配置的ip124.221.236.57:8080/

   docker tag nginx:latest 124.221.236.57:8080/nginx:1.0

1. 推送镜像

   docker push 124.221.236.57:8080/nginx:1.0

1. 拉取镜像

   docker pull 124.221.236.57:8080/nginx:1.0

总结

1. 推送本地镜像到仓库前都必须重命名(docker tag)镜像, 以镜像仓库地址为前缀
2. 镜像仓库推送前需要把仓库地址配置到docker服务的daemon.json文件中,被docker信任
3. 推送使用docker push命令
4. 拉取使用docker pull命令

服务异步通讯 RabbitMQ

初识MQ

同步通讯和异步通讯

同步调用的问题

微服务间基于Feign的调用就属于同步方式, 存在一些问题.

总结

同步调用的有点:

• 时效性较强, 可以立即得到结果

同步调用的问题:

• 耦合度高
• 性能和吞吐能力下降
• 有额外的资源消耗
• 有级联失败问题

异步调用方案

异步调用常见实现就是事件驱动模式

优势一 : 服务解耦

优势二 : 性能提升, 吞吐量提高

优势三 : 服务没有强依赖 , 不担心级联失败问题

优势四 : 流量削峰

总结

异步通信的优点:

• 耦合度低
• 吞吐量提升
• 故障隔离
• 流量削峰

异步通信的缺点:

• 依赖于Broker的可靠性,安全性,吞吐能力
• 架构复杂了,业务没有明显的流程线, 不好追踪管理

什么是MQ

MQ(MessageQueue) , 中文是消息队列, 字面来看就是存放消息的队列. 也就是事件驱动架构中的Broker.

RabbitMQ快速入门

RabbitMQ概述

RabbitMQ是基于Erlang语言开发的开源消息通信中间件, 官网地址:https://www.rabbitmq.com/

安装RabbitMQ, 参考课前资料:

RabbitMQ部署指南

RabbitMQ的结构和概念

总结

RabbitMQ中的几个概念:

• channel : 操作MQ的工具
• exchange : 路由消息到队列中
• queue : 缓存消息
• virtual host : 虚拟主机, 是对queue, exchange等资源的逻辑分组

常规消息模型

MQ的官方文档中给出了5个MQ的Demo示例, 对应了几种不同的用法:

• 基本消息队列(BasicQueue)
• 工作消息队列(WorkQueue)
• 发布订阅(Publish , Subscribe) , 又根据交换机类型不同分为三种:
  • Fanout Exchange : 广播
  • Direct Exchange : 路由
  • Topic Exchange : 主题

HelloWorld案例

官方的HelloWorld是基于最基础的消息队列模型来实现的, 只包括三个角色:

• publisher : 消息发布者 , 将消息发送到队列queue
• queue : 消息队列 , 负责接受并缓存消息
• consumer : 订阅队列 , 处理队列中的消息

案例 完成官方Demo中的hello world案例

实现步骤:

• 导入课前资料中的demo工程 (mq-demo) 去看 去看代码
• 运行publisher服务中的测试类PublisherTest中的测试方法testSendMessage()
• 查看RabbitMQ控制太的消息
• 启动consumer服务 , 查看是否能接收消息

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

总结

基本消息队列的消息发送流程:

1. 建立connection
2. 创建channel
3. 利用channel声明队列
4. 利用channel向队列发送消息

基本消息队列的消息接收流程:

1. 建立connection
2. 创建channel
3. 利用channel声明队列
4. 定义consumer的消费行为handleDelivery()
5. 利用channel将消费者与队伍绑定

SpringAMQP

什么是SpringAMQP

SpringAmqp的官方地址 : https://spring.io/projects/spring-amqp

案例 利用springAMQP实现HelloWorld中的基础消息队列功能

流程如下:

1. 在父工程中引入spring-amqp的依赖
2. 在publisher服务中利用RabbitTemplate发送消息到simple.queue这个队列
3. 在consumer服务中别写消费逻辑, 绑定simple.queue这个队列

步骤 步骤一:引入AMQP依赖

因为publisher和consumer服务都需要amqp依赖, 因此这里把依赖直接放到父工程mq-demo中:

<!-- AMQP依赖 , 包含RabbitMQ -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

步骤 步骤二:在publisher中编写测试方法, 向simple.queue发送消息

1. 在publisher服务中编写application.yaml, 添加mq连接信息:

spring:
 rabbitmq:
  host: 124.221.236.57 #主机名
  port: 5672 #端口
  virtual-host: / #虚拟主机
  username: itcast #用户名
  password: 123321 #密码

1. 在publisher服务中新建一个测试类, 编写测试方法:

@RumWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest{
    @Autowired
    private RabbitTemplate rabbitTemplatep;
    @Test
    public void testSimpleQueue(){
        String queueName = "simple.queue";
        String message = "hello , Spring amqp!";
        rabbitTemplatep.convertAndSend(queueName,message);
    }
}

总结

什么是AMQP?

• 应用间消息通信的一种协议, 与语言和平台无关.

SpringAMQP如何发送消息?

• 引入amqp的starter依赖
• 配置RabbitMQ地址
• 利用RabbitTemplate的convertAndSend方法

案例 步骤三: 在consumer中编写消费逻辑, 监听simple.queue

1. 在consumer服务中编写application.yaml , 添加mq连接信息:

spring:
 rabbitmq:
  host: 124.221.236.57 #主机名
  port: 5672 #端口
  virtual-host: / #虚拟主机
  username: itcast #用户名
  password: 123321 #密码

1. 在consumer服务中新建一个类, 编写消费逻辑:

@Component
public class SpringRabbitListener(){
    //指定监控那个对应的消息
    @RabbitListener(queue = "simple.queue")            //参数 获取到的数据
    public void listenSimpleQueueMessage(String msg) throws InterruptedExcption {
        System.out.println("spring 消费者接受到消息 : [" + msg + "]");
    }
}

总结

SpringAMQP如何接收消息?

• 引入amqp的starter依赖
• 配置RabbitMQ地址
• 定义类, 添加@Component注解
• 类中声明方法, 添加@RabbitListener注解 , 方法参数就是消息

注意: 消息一旦消费就会从队列删除, RabbitMQ没有消息回溯功能

Work Queue 工作队列

Work queue, 工作队列, 可以提高消息处理速度, 避免队列消息堆积

案例 模拟WorkQueue , 实现一个队列绑定多个消费者

基本思路如下:

1. 在publisher服务中定义测试方法 , 每秒产生50条消息 , 发送到simple.queue
2. 在consumer服务中定义两个消息监听者 , 都监听simple.queue队列
3. 消费者1每秒处理50条消息 , 消费者2每秒处理10条消息

步骤 步骤一 : 生产者循环发送消息到simple.queue

在publisher服务中添加一个测试方法 , 循环发送50条消息到simple.queue队列

@Test
public void testWorkQueue() throws InterruptedException{
    //队列名称
    String queuename = "simple.queue";
    //消息
    String message = "hello, message__";
    for (int i = 0; i < 50;i++){
        //发送消息
        rabbitTemplate.converAndSend(queuename, message + i);
        //避免发送太快
        Thread.sleep(20);
    }
}

步骤 步骤二 : 编写两个消费者 , 都监听simple.queue

在consumer服务中添加一个消费者 , 也监听simple.queue:

@RabbitListener(queues = "simple.queue")
public void listenSimpleQueueMessage1(String msg) throws InterruptedException{
    System.out.println("spring 消费者1接收到消息:["+msg+"]");
    Thread.sleep(25);
}
@RabbitListener(queues = "simple.queue")
public void listenSimpleQueueMessage2(String msg) throws InterruptedException{
    System.err.println("spring 消费者2接收到消息:["+msg+"]");
    Thread.sleep(100);
}

消费预取限制

修改application.yaml文件, 设置preFetch这个值, 可以控制预取消息的上限:

spring:
 rabbitmq:
  host: 124.221.236.57 #主机名
  port: 5672 #端口
  virtual-host: / #虚拟主机
  username: itcast #用户名
  password: 123321 #密码
  listener:
   simple:
    prefetch: 1 #每次只能获取一条消息, 处理完成才获取下一个消息

总结

Work模型的使用:

• 多个消费者绑定到一个队列, 同一条消息只会被一个消费者处理
• 通过设置prefetch来控制消费者预取的消息数量

发布(Publish) , 订阅(Subscribe)

发布订阅模式与之前案例的区别就是允许将同一消息发送给多个消费者. 实现方式是加入了exchange(交换机).

常见exchange类型包括:

• Fanout : 广播
• Direct : 路由
• Topic : 话题

注意 : exchange负责消息路由, 而不是存储, 路由失效则消息丢失

发布订阅-Fanout Exchange

Fanout Exchange 会将接收到的消息路由到每一个跟其绑定的queue

案例 利用SpringAMQP演示FanoutExchange的使用

实现思路如下:

1. 在consumer服务中, 利用代码声明队列, 交换机, 并将两者绑定
2. 在consumer服务中, 编写两个消费者方法, 分别监听fanout.queue1 和 fanout.queue2
3. 在publisher中编写测试方法, 向itcast.fanout发送消息

步骤 步骤一 : 在consumer服务声明Exchange, Queue, Binding

SpringAMQP提供了声明交换机, 队列, 绑定关系的API,例如:

步骤 步骤一: 在consumer服务声明Exchange, Queue, Binding

在consumer服务常见一个类, 添加@Configuration注解, 并声明FanoutExchange, Queue和绑定关系对象Binding,代码如下:

@Configuration
public class FanoutConfig{
    //声明FanoutExchange交换机
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("itcast.fanout");
    }
    //声明第一个队列
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }
    //绑定队列1和交换机
    @Bean
    public Binding bindingQueue1(Queue fanoutQueue1,FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }
    // ... 略, 以相同方式声明第2个队列, 并完成绑定
}

步骤 步骤二 : 在consumer服务声明两个消费者

在consumer服务的SpringRabbitListener类中, 添加两个方法, 分别监听fanout.queue1 和 fanout.queue2:

@RabbitListener(queues = "fanout.queue1")
public void listenFangoutQueue1(String msg){
    System.out.println("消费者1接收到Fanout消息:["+msg+"]");
}
@RabbitListener(queues = "fanout.queue2")
public void listFanoutQueue2(String msg){
    System.out.println("消费者2接收到Fanout消息:["+msg+"]");
}

步骤 步骤三 : 在publisher服务发送消息到FanoutExchange

在pulisher服务的SpringAMQPTest类中添加测试方法:

@Test
public void testFanoutExchange(){
    //队列名称
    String exchangeName = "itcast.fanout";
    //消息
    String message = "hello, everyone!";
    //发送消息,参数分别是 : 交互机名称, RoutingKey(暂时为空),消息
    rabbitTemplate.convertAndSend(exchangeName, "" ,message);
}

总结

交换机的作用是什么?

• 接收publisher发送的消息
• 将消息按照规则路由到与之绑定的队列
• 不能缓存消息,路由失败,消息丢失
• FanoutExchange的会将消息路由到每个绑定的队列

声明队列,交换机,绑定关系的Bean是什么?

• Queue
• FanoutExchange
• Binding

发布订阅-DirectExchange

Direct Exchange 会将接收到的消息根据规则路由到指定的Queue, 因此称为路由模式(routes).

• 每一个Queue都与Exchange设置一个BindingKey
• 发布者发送消息时, 指定消息的RoutingKey
• Exchange将消息路由到Bindingkey与消息RoutingKey一致的队列

案例 利用SpringAMQP演示DirectExchange的使用

实现思路如下:

1. 利用@RabbitListener声明Exchange,Queue,RoutingKey
2. 在consumer服务中, 编写两个消费者方法, 分别监听direct.queue1和direct.queue2
3. 在publsher中编写测试方法,向itcast.direct发送消息

步骤 步骤一 : 在consumer服务声明Exchange,Queue

1. 在consumer服务中, 编写两个消费者方法, 分别监听direct.queue1和direct.queue2
2. 并利用@RabbitListener声明Exchange,Queue,Routingkey

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1"),        //设置 接收direct.queue1队列 
            //设置路由itcast.direct   type: 设置获取类型 DIRECT
            exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
            key = {"red","blue"}        //设置接收指定的ID   **可以设置多个,可以同ID
            //如果绑定同个key 那么将会被多个队列收到
    ))
    public void listenDirectQueue1(String msg){
        System.out.println("消费者接收到direct.queue1的消息:["+msg+"]");
    }
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue2"),
            exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
            key = {"red","yellow"}
    ))
    public void listenDirectQueue2(String msg){
        System.out.println("消费者接收到direct.queue2的消息:["+msg+"]");
    }

步骤 步骤二 : 在publisher服务发送消息到DirectExchange

在publish服务的SpringAmqpTest类中添加测试方法:

@Test
public void testDirectExchange(){
    //路由名称
    String exchangeName = "itcast.direct";
    //消息
    Stirng message = "红色警报! 日本乱排核废水, 导致海洋生物变异, 惊现哥斯拉! "
    //发送消息,参数一次为: 交换机名称, Routingkey, 消息
    rabbitTemplate.convertAndSend(exchangeName,"red",message);
}

总结

描述下Direct交换机与Fanout交换机的差异?

• Fanout交换机将消息路由给每一个与之绑定的队列
• Direct交换机根据RoutingKey判断路由给那个队列
• 如果多个队列具有相投的RoutingKey, 则与Fanout功能类似

基于@RabbitListener注解声明队列和交换机有哪些常见注解?

• @Queue
• @Exchange

发布订阅-TopicExchange

TopicExchange与DirectExchange类似, 区别在于routingKey必须是多个单词的列表,并且以 . 分割.

实例:

• china.news 代表有中国的新闻消息;
• china.weather 代表中国的天气消息;
• japan.news 则带代表日本新闻;
• japan.weather 代表日本的天气消息;

Queue与Exchange指定BindingKey时可以使用通配符:

#: 代指0个或多个单词

**: 代指一个单词

案例 利用SpringAMQP演示TopicExchange的使用

实现思路如下:

1. 并利用@RabbitListener声明Exchange,Queue,RoutingKey
2. 在consumer服务中, 编写两个消费者方法, 分别监听topic.queue1和topic.queue2
3. 在publisher中编写测试方法, 向itcast.topic发送消息

步骤 步骤一 : 在consumer服务声明Exchange,Queue

1. 在consumer服务中, 编写两个消费者方法, 分别监听topic.queue1 和 topic.queue2
2. 并利用@RabbitListener声明Exchange,Queue,RoutingKey

    @RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "topic.queue1"),
        exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
        key = "china.#"
    ))
    public void listTopicQueue1(String msg){
        System.out.println("消费者接收到topic.queue1的消息:["+msg+"]");
    }
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
            key = "#.news"
    ))
    public void listTopicQueue2(String msg){
        System.out.println("消费者接收到topic.queue2的消息:["+msg+"]");
    }

步骤 步骤二 : 在publisher服务发送消息到TopicExchange

在publisher服务的SpringAmqpTest类中添加测试方法:

    @Test
    public void testSendTopicExchange1(){
        //交换机名称
        String exchangeName = "itcast.topic";
        //消息
        String message = "hello , china! . I like Xiao";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName,"china.weather",message);
    }