分布式架构#

• 即根据业务功能对系统进行拆分，每个业务模块作为独立项目开发，称为一个服务

  • 优点

    降低耦合度

    利于服务升级拓展

  

• 需要考虑的一些问题

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

• 微服务

  一种经过良好架构设计的分布式架构方案

  • 特征

    • 单一职责

      微服务拆分粒度更小，每个服务都对应唯一业务能力，做到单一职责，避免重复业务开发

    • 面向服务

      微服务需对外暴露业务接口

    • 自治

      团队独立、技术独立、数据独立、部署独立

    • 隔离性强

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

  • 微服务方案需要技术框架落地，国内最知名的就是SpringCloud和阿里巴巴的Dubbo

    • 微服务技术对比

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

SpringCloud#

• SpringCloud将微服务中的技术栈整合进了SpringBoot当中，使其可以进行自动装配，简化开发流程

  SpringCloud和SpringBoot版本需要对应，课程所需SpringBoot版本为2.3.x

• 注意事项

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

• demo

  

  如此一来，order和user两个微服务就完全隔离了，user只能查询用户、order只能查询订单。若想要进行信息的联查则需要微服务向外暴露接口

• 远程调用分析

  

  将用户模块暴露，模块与模块之间互相调用接口以获得信息

  • 实现

    1. 注册RestTemplate（用于发起http请求）

       1
       @Configuration
       2
       public class RestConfig {
       3
       
       4
           /**
       5
            * 注册RestTemplate
       6
            * */
       7
           @Bean
       8
           @LoadBalanced
       9
           public RestTemplate restTemplate(){
       10
               return new RestTemplate();
       11
           }
       12
       
       13
       }

    2. 编写代码跨服务查询

       1
           @Autowired
       2
           private OrderMapper orderMapper;
       3
       
       4
           @Autowired
       5
           private RestTemplate restTemplate;
       6
       
       7
           public Order queryOrderById(Long orderId) {
       8
               // 1.查询订单
       9
               Order order = orderMapper.findById(orderId);
       10
       
       11
               //2.RestTemplate发送请求
       12
               String url = "http://localhost:8081/user/"+order.getUserId();
       13
               User user = restTemplate.getForObject(url, User.class);
       14
       
       15
               //3.赋值
       16
               order.setUser(user);
       17
       
       18
               // 4.返回
       19
               return order;
       20
           }

       展开收起

Eureka#

• 微服务中的提供者和消费者

  • 提供者：一次业务中，提供接口为其他微服务所调用的服务
  • 消费者：一次业务中，调用其他微服务接口的服务

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

Eureka原理#

• 原先的服务调用存在的问题

  1. 硬编码
  2. 集群环境下不好管理到底向哪一台服务器发送请求

• Eureka

  1. Eureka-server注册中心，所有的客户端都会在Eureka处注册信息
  2. 当其他服务想要消费时，会去Eureka中拉取对应的服务
  3. 拉取到服务后会负载均衡，从结果里面挑选一个对其进行远程调用
  4. 每个微服务都会运用心跳机制向Eureka展示健康状态

---

Nacos#

• alibaba产品，现在是SpringCloud中的一个组件，与Eureka相同，也是一个注册中心，但是功能相对更加丰富

快速入门#

• RestTemplate存在的问题

  1. 代码可读性差
  2. 参数复杂的URL难以维护

• Feign

  声明式的http客户端

  1. 引入依赖

     1
             <dependency>
     2
                 <groupId>org.springframework.cloud</groupId>
     3
                 <artifactId>spring-cloud-starter-openfeign</artifactId>
     4
             </dependency>

  2. 在对应微服务的启动类上添加@EnableFeignClients注解开启

     1
     @MapperScan("cn.itcast.order.mapper")
     2
     @SpringBootApplication
     3
     @EnableFeignClients //开启
     4
     public class OrderApplication {
     5
     
     6
         public static void main(String[] args) {
     7
             SpringApplication.run(OrderApplication.class, args);
     8
         }
     9
     
     10
     }

  3. 定义接口编写Feign客户端

     1
     @FeignClient("userservice")//声明向哪个服务发送请求
     2
     public interface UserClient {
     3
     
     4
         @GetMapping("/user/{id}")//声明请求路径
     5
         //利用一个函数声明返回值、传递参数
     6
         User getUserById(@RequestParam("id") long id);
     7
     
     8
     }

  4. 使用Feign远程调用

     1
         @Autowired
     2
         private UserClient userClient;
     3
     
     4
         public Order queryOrderById(Long orderId) {
     5
             // 1.查询订单
     6
             Order order = orderMapper.findById(orderId);
     7
     
     8
     //        //2.RestTemplate发送请求
     9
     //        String url = "http://userservice/user/"+order.getUserId();
     10
     //        User user = restTemplate.getForObject(url, User.class);
     11
     //
     12
     //        //3.赋值
     13
     //        order.setUser(user);
     14
     
     15
             //利用feign进行远程调用
     16
             User user = userClient.getUserById(order.getUserId());
     17
             order.setUser(user);
     18
     
     19
             // 4.返回
     20
             return order;
     21
         }

     展开收起

• Feign一来内置Ribbon，默认支持负载均衡

Feign的自定义配置#

• Feign运行自定义配置来覆盖默认配置，可修改的配置如下

  类型	作用	说明
  feign.Logger.Level	修改日志级别	包含四种不同的级别：NONE、BASIC、HEADERS、FULL
  feign.codec.Decoder	响应结果的解析器	http 远程调用的结果做解析，例如解析 json 字符串为 java 对象
  feign.codec.Encoder	请求参数编码	将请求参数编码，便于通过 http 请求发送
  feign.Contract	支持的注解格式	默认是 SpringMVC 的注解
  feign.Retryer	失败重试机制	请求失败的重试机制，默认是没有，不过会使用 Ribbon 的重试

  一般我们需要配置的是日志

• 自定义日志

  • 方式一：配置文件配置

    1. 全局配置

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

    2. 局部配置

       1
       feign:
       2
         client:
       3
           config:
       4
             userservice: # 这里写服务名称，仅针对该微服务生效
       5
               loggerLevel: FULL # 日志级别

  • 方式二：Java代码

    1. 声明一个配置类（不要加@Configuration注解）

       1
       public class FeignClientConfiguration {
       2
           @Bean
       3
           public Logger.Level feignLogLevel(){
       4
               return Logger.Level.BASIC;
       5
           }
       6
       }

    2. 若是全局配置，则将这个类加到@EnableFeignClients

       1
       @EnableFeignClients(defaultConfiguration = FeignClientConfiguration.class)

    3. 若是局部配置则加到@FeignClient注解中

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

Feign的性能优化#

• Feign的底层实现

  Feign本身只做将声明转成Http请求的工作，发送Http请求还是会用到其他的客户端

  1. URLConnection：默认实现，不支持连接池
  2. Apache HttpClient：支持连接池
  3. OKHttp：支持连接池

• 切换Http客户端方法 （以HttpClient为例）

  1. 引入依赖

     1
             <dependency>
     2
                 <groupId>io.github.openfeign</groupId>
     3
                 <artifactId>feign-httpclient</artifactId>
     4
             </dependency>
     5
     <!-- 此依赖已经被spring管理，无需指定版本 -->

  2. 配置连接池

     1
     feign:
     2
       httpclient:
     3
         enabled: true #开启Feign对HttpClient的支持
     4
         max-connections: 200 #总最大连接数
     5
         max-connections-per-route: 50 #每个路径的最大连接数

Feign的最佳实践#

1. 继承：给消费者的FeignClient和提供者的controller定义统一的父接口作为标准

   原因：发送Http的方法（UserClient中的方法）和接口方法（Controller中的对应方法）的路径、返回值、参数必须都要一模一样，那么定义一个统一的父接口强制其一样就不容易出错

   

   一般情况下不推荐这种方法，原因：1. 耦合太紧 2.声明对SpringMVC不起作用，如：@PathVariable是不能被继承下来的，在Controller里面还要重写方法

2. 抽取：将FeignClient抽取为独立模块，并且把接口有关的Pojo、默认的Feign配置都放在这个模块中，提供给所有消费者使用

   

基本概念#

• 网关功能

  1. 身份认证和权限校验
  2. 服务路由、负载均衡
  3. 请求限流

• SpringCloud中的网关包括两种

  1. getway
  2. zuul

  zuul是基于Servlet实现的，属于阻塞式编程。gateway基于Spring5中的WebFlux，属于响应式编程，具备更好的性能

搭建网关服务#

1. 创建新的模块，引入gateway依赖和nacos服务发现依赖（将网关模块也注册进nacos）

   1
           <dependency>
   2
               <groupId>com.alibaba.cloud</groupId>
   3
               <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
   4
           </dependency>
   5
   
   6
   
   7
           <dependency>
   8
               <groupId>org.springframework.cloud</groupId>
   9
               <artifactId>spring-cloud-starter-gateway</artifactId>
   10
           </dependency>

2. 编写路由及nacos地址

   1
   server:
   2
     port: 10010  # 网关端口
   3
   spring:
   4
     application:
   5
       name: gateway  # 服务名称
   6
     cloud:
   7
       nacos:
   8
         server-addr: localhost:8848  # nacos地址
   9
       gateway:
   10
         routes:  # 网关路由配置
   11
           - id: user-service  # 路由id，自定义，只要唯一即可
   12
             # uri: http://127.0.0.1:8081  # 路由的目标地址 http就是固定地址
   13
             uri: lb://userservice  # 路由的目标地址 lb就是负载均衡，后面跟服务名称
   14
             predicates:  # 路由断言，也就是判断请求是否符合路由规则的条件
   15
               - Path=/user/**  # 这个是按照路径匹配，只要以/user/开头就符合要求
   16
   
   17
           - id: order-service
   18
             uri: lb://orderservice
   19
             predicates:
   20
               - Path=/order/**

   展开收起

3. 配置网关后，需访问网关端口，由网关将请求进行路由

Nginx和GateWay的区别

Nginx也算是一种网关。通常被置于最外层，用来承接一些公网请求。当请求通过Nginx后再由GateWay将请求路由至指定的微服务

浏览器/手机用户 → 【Nginx（外层接入网关）】 → 【SpringCloud Gateway（微服务网关）】 → user服务/order服务

路由断言工厂#

• 我们配置网关时写的断言规则时字符串，这些字符串会被Predicate Factory读取并处理，转变为路由判断的条件

• SpringCloudGateWay有十几个断言工厂

  名称	说明	示例
  After	匹配指定时间点之后发起的请求	- After=2037-01-20T17:42:47.789-07:00[America/Denver]
  Before	匹配指定时间点之前发起的请求	- Before=2031-04-13T15:14:47.433+08:00[Asia/Shanghai]
  Between	匹配两个时间区间内发起的请求	- Between=2037-01-20T17:42:47.789-07:00[America/Denver],2037-01-21T17:42:47.789-07:00[America/Denver]
  Cookie	请求必须携带指定 Cookie（可正则匹配 Cookie 值）	- Cookie=chocolate, ch.p
  Header	请求必须携带指定请求头，可正则匹配头值	- Header=X-Request-Id, \d+
  Host	匹配请求访问的域名 Host，支持通配符	- Host=**.somehost.org,**.anotherhost.org
  Method	限定请求 HTTP 请求方式（GET/POST 等）	- Method=GET,POST
  Path（常用）	匹配请求访问路径，支持通配符、路径占位符	- Path=/red/{segment},/blue/**
  Query	请求必须包含指定 URL 参数，可指定参数值	- Query=name,Jack 或者 - Query=name
  RemoteAddr	匹配客户端请求 IP 地址段	- RemoteAddr=192.168.1.1/24
  Weight	权重路由，用于灰度发布、流量分发	无

网关过滤器#

• 可以对进入网关的请求与微服务返回的响应做处理

  

• 过滤器工厂GateWayFilterFactory

  官方文档

  名称	说明
  AddRequestHeader	给当前请求添加一个请求头
  RemoveRequestHeader	移除请求中的一个请求头
  AddResponseHeader	给响应结果中添加一个响应头
  RemoveResponseHeader	从响应结果中移除一个响应头
  RequestRateLimiter	限制请求的流量
  ……

• 添加方法

  局部生效：在application.yml文件中对应服务下添加

  1
  spring:
  2
    cloud:
  3
      gateway:
  4
        routes:  # 网关路由配置
  5
          - id: user-service
  6
            uri: lb://userservice
  7
            predicates:
  8
              - Path=/user/**
  9
            filters:  # 过滤器
  10
              - AddRequestHeader=Truth, xxxxxx（添加的内容） # 添加请求头

  全局生效：default-filters

  1
  spring:
  2
    cloud:
  3
      gateway:
  4
        routes:  # 网关路由配置
  5
          - id: user-service
  6
            uri: lb://userservice
  7
            predicates:
  8
              - Path=/user/**
  9
        default-filters:  # 全局过滤器  注意：与routes平级！
  10
          - AddRequestHeader=Truth, xxxxxx（添加的内容） # 添加请求头

• 自定义全局过滤器 — GlobalFilter

  类似default-filters，同样可以过滤所有请求，不过与之不同的是，GlobalFilter可以自定义处理逻辑

  • 实现

    定义一个GlobalFliter接口的实现类

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

    1
    @Component
    2
    @Order(value = -1)//指定当前过滤器的优先级  越小优先级越高  范围：-21亿 ~ 21亿
    3
    public class AuthorizeFilter implements GlobalFilter {
    4
        @Override
    5
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    6
    
    7
            //1.获取请求参数
    8
            ServerHttpRequest request = exchange.getRequest();
    9
            MultiValueMap<String, String> queryParams = request.getQueryParams();
    10
    
    11
            //2.获取参数中的 authorization参数
    12
            String auth = queryParams.getFirst("authorization");
    13
    
    14
            //3.判断参数值是否为admin
    15
            if("admin".equals(auth)){
    16
                return chain.filter(exchange);//放行：调用下一个exchange的方法
    17
            }
    18
    
    19
            //4.是则放行，不是则拦截
    20
            //设置状态码并拦截
    21
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
    22
            return exchange.getResponse().setComplete();
    23
        }
    24
    }

    展开收起

• 请求路由后，会将上述三种过滤器合并到一个过滤器链（集合）当中，排序后依次执行每个过滤器

  • 在配置文件中添加的两个filter都为GateFilter类，可以加入同一个集合。而GlobalFilter会先转换为GateFilter再加入集合
  • 排序规则：
    • GlobalFilter可以自定义Order的值，而另外两种Filter由Spring指定Order的值，默认是按照声明顺序从1开始递增
    • 当Order值相同时优先级如下：defaultfilter > 路由过滤器 > GlobalFilter

网关的跨域cors配置#

• 跨域问题：在某一服务的前端界面访问另一服务的接口，会被浏览器拦截

• 解决方法：CORS（跨域资源共享），后端告诉浏览器：允许某个前端域名访问我的接口，浏览器就会放行请求。

  • 实现

    1
    spring:
    2
      cloud:
    3
        gateway:
    4
          globalcors: # 全局的跨域处理
    5
            add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题
    6
            corsConfigurations:
    7
              '[/**]':
    8
                allowedOrigins: # 允许哪些网站的跨域请求
    9
                  - "http://localhost:8090"
    10
                  - "http://www.leyou.com"
    11
                allowedMethods: # 允许的跨域ajax的请求方式
    12
                  - "GET"
    13
                  - "POST"
    14
                  - "DELETE"
    15
                  - "PUT"
    16
                  - "OPTIONS"
    17
                allowedHeaders: "*" # 允许在请求中携带的头信息
    18
                allowCredentials: true # 是否允许携带cookie
    19
                maxAge: 360000 # 这次跨域检测的有效期

    展开收起

Docker简介#

• 微服务项目中大型项目组件较多，运行环境较为复杂，部署时会碰到一些问题

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

  Docker可以将所要的函数库、依赖、配置进行打包，并放到隔离容器中运行，避免互相干扰

• Linux操作系统中，有许多不同的发行版本。不同的发行版本对应不同的系统应用，系统应用封装内核指令为函数，方便调用。不同的系统应用所封装成的函数有差异，所以Ubuntu上的软件无法在Centos上正常运行

  • Docker如何解决上述问题？

    Docker将用户程序和所需调用的系统（如：Ubuntu）一起打包，在运行时调用容器中的系统函数，直接通过打包好的系统与内核进行交互

初始Docker#

• 镜像和容器

  • 镜像（Image）：Docker将应用程序及其所需依赖、函数库、环境、配置等文件打包在一起，称为镜像

    镜像的呈现形式就是磁盘中的文件

  • 容器（Container）：镜像中的应用程序运行后形成的进程就是容器，只是Docker会给容器做隔离，对外不可见

  为了防止镜像产生污染，镜像是只读的，只能用于创建容器和供容器读取数据。若容器想要产生数据，需从镜像拷贝一份文件到自己的独立文件系统中，写到拷贝文件中

  

• Docker Hub

  镜像托管平台，类似GitHub，用于管理镜像，共享镜像资源

• Docker架构

  CS架构，由两部分组成

  1. 服务端（Server）：Docker守护进程，负责处理Docke指令，管理镜像、容器等
  2. 客户端（Client）：通过命令或RestAPI向Docker服务端发送指令。可以在本地或远程向服务端发送指令

Docker的基本操作#

为方便学习，此处在Windows上安装docker，并使用wsl的cli用linux命令对docker进行操作

• 镜像相关命令

  镜像名称一般由两部分组成：[repository]:[tag]

  若tag没有指定，默认为最新版本的镜像

  1. 查看镜像

     1
     docker images

  2. 删除镜像

     1
     docker rmi

  3. 构建镜像

     1
     docker build

  4. 将镜像推送到服务器

     1
     docker push

  5. 从服务器拉取镜像

     1
     docker pull

  6. 保存镜像为压缩包

     1
     docker save

  7. 加载压缩包为镜像

     1
     docker load

  1
  docker help #查看docker中的所有命令
  2
  docker images #查看images命令的详细用法

  

• 容器相关命令

  1. 运行容器

     1
     docker run

  2. 运行到暂停

     1
     docker pause

  3. 暂停到运行

     1
     docker unpause

  4. 运行到停止

     1
     docker stop

  5. 停止到运行

     1
     docker start

  6. 查看容器状态

     1
     docker ps # 默认查看运行中容器 -a查看所有容器

  7. 查看日志

     1
     docker logs

  8. 进入容器执行命令

     1
     docker exec

  9. 删除容器

     1
     docker rm

  

• 案例：在docker上运行Nginx容器

  1
  docker run --name containername -p 80:80 -d nginx

  -p ：将宿主机端口与容器端口映射，冒号左侧是宿主机端口，右侧是容器端口 容器端口一般取决于应用程序的运行端口

  -d ：后台运行

  1
  docker exec -it containername bash

  -it ：给当前进入的容器创建一个标准输入输出的终端，允许我们与容器交互

  bash：进入容器后执行命令的终端

数据卷#

• 上述操作存在一定问题（容器与数据耦合）

  1. 不便于修改，需要使用docker exec进入容器内部进行修改
  2. 数据不可复用，在容器内的修改对外不可见。所有修改对新建的容器是不可复用的
  3. 升级维护困难，删若需要升级容器，则需要删除容器重新部署，这样一来数据就都丢失了

• 数据卷（volume）

  是一个虚拟目录，指向宿主机文件系统中的某个目录

  

  如此一来就实现了容器与数据的解耦，将容器中的数据抽离到宿主机上。

  Linux系统上默认会挂在到宿主机的：/var/lib/docker/volumes/html/_data

  Windows系统上默认会挂在到宿主机的：\\wsl.localhost\docker-desktop\mnt\docker-desktop-disk\data\docker\volumes\html\_data

• 操作数据卷的命令

  1
  docker volume [command]

  [command]有以下几个常用命令

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

• 数据卷的挂载

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

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

  -v后冒号前面的表示volume的名称，后面的是容器中的数据路径

  除此之外，-v还可以直接将容器内目录挂在到宿主机的目录上

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

  两种挂载方式的区别示意图

  

Dockerfile自定义镜像#

• 镜像结构（以MySQL为例）

  

  BaseImage和EntryPoint是必须的，剩余的Layer视具体情况而定

• Dockerfile

  一个文本文件，其中包含各种指令，用指令来说明要执行什么操作来构建镜像，每一层指令都会形成一层layer

  指令	说明	示例
  FROM	指定基础镜像	FROM centos<6>
  ENV	设置环境变量，可在后面指令使用	ENV key value
  COPY	拷贝本地文件到镜像的指定目录	COPY ./mysql-5.7.rpm /tmp
  RUN	执行 Linux 的 shell 命令，一般是安装过程的命令	RUN yum install gcc
  EXPOSE	指定容器运行时监听的端口，是给镜像使用者看的	EXPOSE 8080
  ENTRYPOINT	镜像中应用的启动命令，容器运行时调用	ENTRYPOINT java -jar xx.jar

Docker Compose#

• 简介

  Docker Compose可以基于Compose文件，帮助我们快速部署分布式应用，而无需我们手动一个个创建和运行容器

  Compose：一个文本文件，通过指令定义集群中的每个容器如何运行

  可以说，Compose就是多个docker run指令的集合,或者说Docker Compose就是将镜像启动成容器的脚本

  • 示例

    dockercompose

    1
    version: "3.8"
    2
    
    3
    services:
    4
      mysql:
    5
        image: mysql:5.7.25
    6
        environment:
    7
          MYSQL_ROOT_PASSWORD: 123
    8
        volumes:
    9
          - /tmp/mysql/data:/var/lib/mysql
    10
          - /tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf
    11
      web:
    12
        build: .
    13
        ports:
    14
          - 8090:8090

    对应的docker命令

    1
    # MySQL容器
    2
    docker run \
    3
      --name mysql \
    4
      -e MYSQL_ROOT_PASSWORD=123 \
    5
      -p 3306:3306 \
    6
      -v /tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf \
    7
      -v /tmp/mysql/data:/var/lib/mysql \
    8
      -d \
    9
      mysql:5.7.25
    10
    
    11
    # 构建镜像
    12
    docker build -t web:1.0 .
    13
    
    14
    # 运行容器
    15
    docker run --name web -p 8090:8090 -d web:1.0

    展开收起

    二者对比

    docker run 参数	等价 compose 配置	作用说明
    --name mysql	服务名 mysql:	给容器自定义名称
    -e MYSQL_ROOT_PASSWORD=123	environment:	设置环境变量
    -p 8090:8090	ports: - 8090:8090	端口映射 宿主机：容器
    -v 宿主机路径:容器路径	volumes:	数据卷挂载（配置 + 数据持久化）
    -d	默认后台运行	守护进程，后台启动容器
    末尾 mysql:5.7.25	image: mysql:5.7.25	指定镜像

• 作用

  快速地构建和部署微服务集群

镜像仓库#

• 镜像仓库有公有和私有两种形式

  • 公有

    如Docker官方的Docker Hub。国内如：网易云镜像服务、阿里云镜像服务

  • 私有

    企业内部，个人用户，都可以搭建私有仓库

• 私有仓库的搭建

  可以基于Docker官方提供的DockerRegistry实现

  使用DockerCompose部署带有图形化界面的DockerRegistry

  1. 配置Docker信任地址

     私服采用http协议，默认不被Docker信任，要先做一个配置

     Windows版的Docker可以直接在图形化界面进行修改

     

  2. 运行Compose文件

     1
     version: '3.0'
     2
     services:
     3
       registry:
     4
         image: registry
     5
         volumes:
     6
           - ./registry-data:/var/lib/registry
     7
       ui:
     8
         image: joxit/docker-registry-ui:static
     9
         ports:
     10
           - 8080:80
     11
         environment:
     12
           - REGISTRY_TITLE=仓库名
     13
           - REGISTRY_URL=http://registry:5000
     14
         depends_on:
     15
           - registry

     展开收起

     1
     docker-compose up -d #docker-compose是文件名

     

     

• 镜像的推送和拉取

  1. 重新tag本地镜像，名称前缀为私有仓库地址：127.0.0.1<8080>/

     1
     docker tag nginx:latest 127.0.0.1:8080/nginx:1.0

  2. 推送镜像

     1
     docker push 127.0.0.1:8080/nginx:1.0

  3. 拉取镜像

     1
     docker pull 127.0.0.1:8080/nginx1.0

初识ES#

• 强大的开源搜索引擎，可以从海量数据中搜索出需要的内容

  elasticsearch结合kibana、Logstash、Beats，也就是elastic stack（ELK）。广泛应用在日志数据分析、实时监控等领域 — ELK可以将运行状况可视化

  

• ES底层基于Lucene开发

  • Lucene：Java语言的搜索引擎库，Apache公司的顶级项目

    • 优点

      易扩展

      高性能（基于倒排索引）

    • 缺点

      只限于Java语言

      学习不易

      不支持水平扩展

  • ES优点

    • 支持分布式、可水平扩展
    • 提供Restful接口，可被任何语言调用

• 正向索引和倒排索引

  • 正向索引

    传统数据库采用正向索引，在搜索时若采用模糊搜索只能对数据进行逐条扫描

  • 倒排索引

    • 文档：每条数据就是一个文档
    • 词条：文档按照语意分成的词语

    

  正向索引查找时，先找到数据内容，若数据内容中有匹配的词则将数据加入结果集

  倒排索引查找时，先根据词语找对应词条，再将对应所包含的数据加入结果集

• ES中的概念

  • 文档

    ES是面对文档存储的，文档可以是数据库中的一条商品数据、订单信息等。ES会将数据转为JSON存储

  • 索引（index）：相同类型的文档的集合

    

  • 映射（mapping）

    索引中文档字段约束信息，类似表的结构约束

  MySQL	Elasticsearch	说明
  Table	Index	索引 (index)，就是文档的集合，类似数据库的表 (table)
  Row	Document	文档（Document），就是一条条的数据，类似数据库中的行（Row），文档都是 JSON 格式
  Column	Field	字段（Field），就是 JSON 文档中的字段，类似数据库中的列（Column）
  Schema	Mapping	Mapping（映射）是索引中文档的约束，例如字段类型约束。类似数据库的表结构（Schema）
  SQL	DSL	DSL 是 elasticsearch 提供的 JSON 风格的请求语句，用来操作 elasticsearch，实现 CRUD

• 架构

  

Docker中ES的部署#

1. 创建网络

   因为我们还需要部署kibana容器用于DSL语句的编写，因此需要让ES和kibana容器互联，先创建一个网络

   1
   docker network create es-net

2. 拉取ES镜像和kibana镜像

   采用7.12.1版本镜像

   1
   docker pull docker.elastic.co/elasticsearch/elasticsearch:7.12.1

   1
   docker pull docker.elastic.co/kibana/kibana:7.12.1

3. 运行docker命令，部署单点es

   1
   docker run -d \
   2
     --name es \
   3
     -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
   4
     -e "discovery.type=single-node" \
   5
     -v es-data:/usr/share/elasticsearch/data \
   6
     -v es-plugins:/usr/share/elasticsearch/plugins \
   7
     --privileged \
   8
     --network es-net \
   9
     -p 9200:9200 \
   10
     -p 9300:9300 \
   11
   docker.elastic.co/elasticsearch/elasticsearch:7.12.1

   9200为ES的暴露端口

   9300为ES 集群节点之间内部通信端口

4. 部署kibana并连接上es

   1
   docker run -d \
   2
   --name kibana \
   3
   -e ELASTICSEARCH_HOSTS=http://es:9200 \
   4
   --network=es-net \
   5
   -p 5601:5601 \
   6
   docker.elastic.co/kibana/kibana:7.12.1

5. 部署好后

   ES端口：9200

   kibana端口：5601

IK分词器#

• es创建倒排索引需要进行分词。但默认的分词规则对中文处理不太友好

• docker中安装IK分词器

  1. 下载IK

     1
     https://release.infinilabs.com/analysis-ik/stable/   #去这个网址下载IK7.12.1版本

  2. 查询插件安装位置

     1
     docker volume inspect es-plugins

  3. 将IK插件解压并放入得到的插件安装位置

  4. 重启ES容器

  5. 测试

     回到kibana的devtool界面，选择分词器是选择以下两种中的一种

     ik_smart：最少切分

     

     ik_max_word：最细切分

     

• IK分词器的拓展和停用

  IK分词器支持词库的拓展和某些词的停用，只需修改IK分词器目录中config目录下的IkAnalyzer.cfg.xml文件

  • 拓展

    1
    <?xml version="1.0" encoding="UTF-8"?>
    2
    <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
    3
    <properties>
    4
            <comment>IK Analyzer 扩展配置</comment>
    5
            <!--用户可以在这里配置自己的扩展字典 *** 添加扩展字典-->
    6
            <entry key="ext_dict">ext.dic</entry>
    7
    </properties>

  • 停用某些词

    1
    <entry key="ext_stopwords">stopword.dic</entry>

  加入上述两个配置后，在同目录下创建ext_dic文件和stopword.dic两个对应文件即可进行拓展和停用

  配置完后需重启ES

索引库操作#

ES中的索引类似数据库中的表，mapping映射类似于数据库中的建表语句

• mapping属性

  对索引库中文档的约束，常见的mapping属性包括

  • type：字段数据类型，常见的简单类型有
    • 字符串：text（可分词文本）、keyword（精确值，例如：品牌、国家、ip地址）
    • 数值：long、integer、short、byte、double、float
    • 布尔：boolean
    • 日期：date
    • 对象：object
  • index：是否创建倒排索引，默认为true
  • analyzer：使用哪种分词器
  • properties：该字段的子字段

• 创建索引库

  ES中通过Restful请求操作索引库、文档。请求内容用DSL语句表示。创建索引库和mapping的DSL如下

  1
  PUT /索引库名称
  2
  {
  3
    "mappings": {
  4
      "properties": {
  5
        "字段名":{
  6
          "type": "text",
  7
          "analyzer": "ik_smart"
  8
        },
  9
        "字段名2":{
  10
          "type": "keyword",
  11
          "index": "false"
  12
        },
  13
        "字段名3":{
  14
          "properties": {
  15
            "子字段": {
  16
              "type": "keyword"
  17
            }
  18
          }
  19
        }
  20
        // ...略
  21
      }
  22
    }
  23
  }

  展开收起

• 索引库的删改查

  • 查看索引库

    1
    GET /索引库名

  • 删除索引库

    1
    DELETE /索引库

  • 修改索引库

    索引库一经创建，原有字段是无法修改的。但是可以添加新的字段

    1
    PUT /索引库名/_mapping
    2
    {
    3
      "properties":{
    4
        "新字段名":{
    5
          "type": "integer"
    6
        }
    7
      }
    8
    }

文档操作#

• 增

  文档id需要自己添加，类似于主键

  1
  POST /索引库名/_doc/文档id
  2
  {
  3
    "字段1"："值1"，
  4
    "字段2"："值2"，
  5
    "字段3"：{
  6
      "子属性1"："值3",
  7
      "子属性2":"值4"
  8
    }
  9
    //.....
  10
  }

• 删

  1
  DELETE /索引库名/_doc/文档id

• 改

  • 方式一：全量修改，会删除旧文档，新增新文档

    若索引库中没有这个文档，则会新增

    1
    PUT /索引库名/_doc/文档id
    2
    {
    3
      "字段1"："值1"，
    4
      "字段2"："值2"，
    5
      "字段3"：{
    6
        "子属性1"："值3",
    7
        "子属性2":"值4"
    8
      }
    9
      //.....
    10
    }

  • 方式二：增量修改，修改指定字段值

    1
    POST /索引库名/_doc/文档id
    2
    {
    3
      "doc":{
    4
        "字段名":"新值",
    5
      }
    6
    }

• 查

  1
  GET /索引库名/_doc/文档id

Java中的集成 — RestClient#

• 初始化JavaRestClient

  1. 引入es的RestHighLevelClient依赖

     1
     <dependency>
     2
         <groupId>org.elasticsearch.client</groupId>
     3
         <artifactId>elasticsearch-rest-high-level-client</artifactId>
     4
         <version>7.12.1</version>
     5
     </dependency>

  2. 因为SpringBoot默认的ES不是7.12.1，所以我们需要去SpringBoot的父工程中手动修改

  3. 初始化RestHighLevelClient

     1
         private RestHighLevelClient restHighLevelClient;
     2
     
     3
         @BeforeEach
     4
         public void init(){
     5
             restHighLevelClient = new RestHighLevelClient(RestClient.builder(
     6
                     HttpHost.create("http://localhost:9200")
     7
             ));
     8
         }
     9
     
     10
         @AfterEach
     11
         public void close() throws IOException {
     12
             restHighLevelClient.close();
     13
         }

• 操作索引库

  • 创建索引库

    1
        @Test
    2
        void createIndex() throws IOException {
    3
            //创建Request对象
    4
            CreateIndexRequest createIndexRequest = new CreateIndexRequest("hotel");
    5
    
    6
            //准备请求参数,DSL语句
    7
            createIndexRequest.source("DSL语句", XContentType.JSON);
    8
    
    9
            //发送请求
    10
            restHighLevelClient.indices().create(createIndexRequest, RequestOptions.DEFAULT);
    11
        }

    

  • 删索引库

    1
        @Test
    2
        void deleteIndex() throws IOException {
    3
            //创建Request对象
    4
            DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("hotel");
    5
            //发起请求
    6
            restHighLevelClient.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
    7
        }

  • 判断索引库是否存在

    1
        @Test
    2
        void Indexexists() throws IOException {
    3
            //创建Request对象
    4
            GetIndexRequest getIndexRequest = new GetIndexRequest("hotel");
    5
    
    6
            //发起请求
    7
            restHighLevelClient.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
    8
        }

• RestClient操作文档

  

  • 新增文档

    1
        @Test
    2
        void addDoc() throws IOException {
    3
            //根据id查询酒店数据
    4
            Hotel hotel = hotelService.getById(61083L);
    5
            //转换为文档类型
    6
            HotelDoc hotelDoc = new HotelDoc(hotel);
    7
    
    8
    
    9
            //准备Request对象
    10
            IndexRequest indexRequest = new IndexRequest("hotel").id(hotelDoc.getId().toString());
    11
    
    12
            //将hotelDoc转为JSON并放入Request中
    13
            indexRequest.source(JSONUtil.toJsonStr(hotelDoc), XContentType.JSON);
    14
    
    15
            //发送请求
    16
            restHighLevelClient.index(indexRequest,RequestOptions.DEFAULT);
    17
        }

    展开收起

  • 查询文档

    1
        @Test
    2
        void getDoc() throws IOException {
    3
            //创建Request对象
    4
            GetRequest getRequest = new GetRequest("hotel","61083");
    5
    
    6
            //发送请求，得到结果
    7
            GetResponse res = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
    8
    
    9
            //解析结果
    10
            String json = res.getSourceAsString();
    11
    
    12
            System.out.println(json);
    13
    
    14
        }

  • 修改文档

    • 全量更新：与新增一致

    • 局部更新

      1
          @Test
      2
          void updateDoc() throws IOException {
      3
              //创建Request对象
      4
              UpdateRequest updateRequest = new UpdateRequest("hotel","61083");
      5
      
      6
              //准备参数，每两个参数为一对key value
      7
              updateRequest.doc(
      8
                      "price" ,"970",
      9
                      "starName" ,"四钻"
      10
              );
      11
      
      12
              restHighLevelClient.update(updateRequest,RequestOptions.DEFAULT);
      13
          }

  • 删除文档

    1
        @Test
    2
        void deleteDoc() throws IOException {
    3
            //创建Request对象
    4
            DeleteRequest deleteRequest = new DeleteRequest("hotel","61083");
    5
            //发送请求
    6
            restHighLevelClient.delete(deleteRequest,RequestOptions.DEFAULT);
    7
        }

• 批量导入数据

  1. 用MP查询酒店数据
  2. 将查询到的酒店数据（Hotel）转换为HotelDoc
  3. 利用JavaRestClient中的Bulk批处理，实现新增文档

DSL查询语法#

• 常见查询分类

  • 查询所有：查询出所有数据，一般测试用
  • 全文检索（full text）查询：利用分词器对用户输入内容分词，然后去倒排索引中匹配
  • 精确查询：根据精确词条值查询，一般查找keyword、数值、日期、boolean等类型字段
  • 地理（geo）查询：根据经纬度查询
  • 复合（compound）查询：可以将上述各种查询条件合并起来

• DSL Query基本语法

  1
  GET /索引库名/_search
  2
  {
  3
    "query":{
  4
      "查询类型":{
  5
        "查询条件"："条件值"
  6
      }
  7
    }
  8
  }

  • 查询所有

    1
    GET /索引库名/_search
    2
    {
    3
      "query":{
    4
        "match_all":{
    5
    
    6
        }
    7
      }
    8
    }

  • 全文检索搜索：进行分词，再去倒排索引库检索，常用于网页搜索栏

    1
    GET /索引库名/_search
    2
    {
    3
      "query":{
    4
        "match":{
    5
          "字段名":"字段值"
    6
        }
    7
      }
    8
    }

    1
    GET /索引库名/_search
    2
    {
    3
      "query":{
    4
        "multi_match":{  //与match相似，只不过允许同时查询多个字段
    5
          "query":"字段值",
    6
          "fields":["FIELD1","FIELD2"]
    7
        }
    8
      }
    9
    }

  • 精确查询

    • term：根据词条精确查询

      1
      GET /索引库名/_search
      2
      {
      3
        "query":{
      4
          "term":{
      5
            "字段名":{
      6
              "value":"字段值"
      7
            }
      8
          }
      9
        }
      10
      }

    • range：根据值的范围查询

      1
      GET /索引库名/_search
      2
      {
      3
        "query":{
      4
          "range":{
      5
            "字段名":{
      6
              "gte":最小值,
      7
              "lte":最大值
      8
            }
      9
          }
      10
        }
      11
      }

  • 地理查询

    • geo_bounding_box <查询geo_point值落在某个矩形范围内的数据>

      1
      GET /索引库名/_search
      2
      {
      3
        "query":{
      4
          "geo_bounding_box":{
      5
            "字段名":{
      6
              "top_left":{
      7
                "lat":
      8
                "lon":
      9
              }
      10
              "bottom_right":{
      11
                "lat":
      12
                "lon":
      13
              }
      14
            }
      15
          }
      16
        }
      17
      }

      展开收起

    • geo_distance：查询到指定中心点小于某个距离值的所有数据

      1
      GET /索引库名/_search
      2
      {
      3
        "query":{
      4
          "geo_distance":{
      5
            "distance":半径大小如："15km",
      6
            "字段名": 中心点的坐标如："31.21,121.5"
      7
          }
      8
        }
      9
      }

  • 复合查询

    • 相关性算分

      

    • function score query：可以修改文档的相关性算分，人工影响排序

      1
      GET /索引库名/_search
      2
      {
      3
        "query":{
      4
          "function_score":{
      5
            "query":{"match":{"字段名":"字段值"}},
      6
            "functions":[
      7
              "filter":{"term":{"字段名"："字段值"}},
      8
              "weight":权重值
      9
            ],
      10
            "boost_mode":"multiply"
      11
          }
      12
        }
      13
      }

      

    • boolean query：布尔查询是一个或多个查询子句的组合。子查询组合方式有

      1. must：与
      2. should：或
      3. must_not：非
      4. filter：与，但是不参与算分

      1
      GET /hotel/_search
      2
      {
      3
        "query": {
      4
          "bool": {
      5
            "must": [
      6
              {"term": {"city": "上海"}}
      7
            ],
      8
            "should": [
      9
              {"term": {"brand": "皇冠假日"}},
      10
              {"term": {"brand": "华美达"}}
      11
            ],
      12
            "must_not": [
      13
              {"range": {"price": {"lte": 500}}}
      14
            ],
      15
            "filter": [
      16
              {"range": {"score": {"gte": 45}}}
      17
            ]
      18
          }
      19
        }
      20
      }

      展开收起