通常对于高保密要求的参数都会有加密要求，这时候，如果你之前不了解加密算法，就很容易被公钥、私钥的使用给绕迷糊了。有时候虽然接口都调通了，但是还是一头雾水，这就通了?

那接下来我们就来解开这团迷雾。咱们只讲逻辑和一部分逻辑，不讲数学算法，因为数学这块儿我也不是很懂。

加密算法在大类上分为对称机密和非对称加密，都用来加密，只不过使用场景、性能、安全性方面有些不同。

首先说什么是加密呢?

加密就是通过一种方式将一个显而易见的东西变成难以理解的东西。

比如这儿有个字符串“我真棒”，这三个字儿要摆在你面前不是一眼就知道我很棒了吗。

但是我要给你看这样一串东西呢？你还能一下子知道是什么意思吗？

232 10 5,33 50 12,109 45 1

其实这还是那三个字，只不过是经过加密的密文，只有知道了加密的方法才能还原出来，也就是解密。

加密的过程可能是这样的：

1. 首先买一本叫做《人间清醒》的书；
2. 然后按照逗号分隔，每一个逗号分隔开的表示一个字；
3. 然后每一组是三个数字，第一个数字表示所在页，第二个数字表示所在行，第三个数字表示所在列（第几个字），所以 232 10 5，表示第 232 页，第 10 行，第 5 个字。

还有，比如我之前有个温州的同事，他打电话的时候对于我们来说就是语音加密了，能听见他的声音，但是说的是什么内容一个字也听不出来。这也可以理解为一种加密，把普通话的发音转换成温州方言的发音。

对称加密

对称加密中所说的对称是对加密和解密而言的，也就是加密和解密的过程使用相同的密钥。

我们经常用到的落库加密、文件加密都可以使用对称加密的方式。

目前最常用也是最安全的对称加密算法是 AES，AES 还分为 AES-128、AES-192 和 AES256，后面的数字代表加密密钥的位数，位数越高呢，加密效果也就越好，更加不容易被破解。同时，位数越高，加密和解密过程中的计算量也会越大，内存占用也就更大，消耗的资源更多，需要的时间也就更长。

有利有弊，看你的需求而定。基本上，一般场景下 128 位就足够安全了。AES 到目前为止，可以说没有漏洞，而且 128 位就可以保证不会被暴力破解。而更高位数的可能会用到国家级的保密数据上。

AES 是分组加密算法，除此之外，大部分的加密算法都是分组加密算法。

块加密算法就是将需要加密的数据分成一个个的固定长度的分组，比如 128 位一组，然后分别用算法对每一组进行加密，如果最后一组不足 128 位的话，还要用填充算法进行填充，保证达到 128 位。

常用的分组算法有 CTR 和 GCM，CTR 和 GCM 有并行计算的能力，并且, GCM 还能额外提供对消息完整性、真实性的验证能力。

所以我们在某些地方可能看到 AES-128-GCM、AES-256-CTR 这样的写法，前面表示加密算法，后面代表分组算法。

不足之处

对称加密本身从算法层面来说已经足够安全了，但是在密钥分发方面有些不太容易管理。

因为加解密的密钥相同。我加密的数据想要被别人使用，我就要把密钥告诉要使用的人。知道密钥的人、保存密钥的服务器越多，风险就越大。约束自己容易，约束别人难啊。但凡有一方不小心把密钥泄露就完。一个木桶能装多少水是由最低的一块木板决定的。

非对称加密

由于对称加密的密钥分发问题，非对称加密算法可以完美的解决。

刚毕业不就的时候，和第三方服务做集成，有关于接口参数加密的指引文档，虽然按照人家提供的 demo 可以正常集成，但是文档上说的公钥、私钥还是搞的很迷糊。

现在就来捋一捋啊，就以第三方服务角度来说。假设我是一个支付服务商，为大家提供支付接口的。

公钥

公钥是开放的，谁都可以获取。我作为一个支付服务商，任何到我平台上注册的用户都可以获取到公钥，公钥可以是相同的。

私钥

私钥是绝密的，我作为一个支付服务商，必须将私钥妥善保存，无论是保存在数据库中还是保存在服务器，都必须保证私钥不对外，只有我自己可以使用。

1. 使用我服务的用户获取公钥；
2. 调用方（客户）用公钥对接口参数进行加密，然后调用接口；
3. 我方（支付服务商）用私钥对参数进行解密，然后使用参数进行业务处理；

以上是公钥、私钥的使用过程，这样一看就很明确了。

之所以说是非对称加密，是因为私钥只是用来解密的，用公钥加密过的数据，只有用对应的私钥才能解密出来。所以说，即使有那么多人得到了相同的公钥，也无法获取别人加密过的数据。

最常用的非对称加密算法是 RSA ，RSA 有 1024、2048、3072、4096、8129、16384 甚至更多位。目前 3072 位及以上的密钥长度被认为是安全的，曾经大量使用的 2048 位 RSA 现在被破解的风险在不断提升，已经不推荐使用了

RSA 算法的性能要比对称加密 AES 算法差 1000 倍左右，虽然数学原理上不太明白，但是有数学常识就可以知道，使用不同的密钥进行加密和解密，必然要比使用相同密钥的算法复杂很多，由此肯定会带来性能上的开销。

非对称加密适合用于那些对安全性要求更高的场景，例如支付场景、数字证书、数据加密传输等等。

提到 Java 就不得不说多线程了，就算你不想说，面试官也得让你说呀，对不对。那说到多线程，就不得提线程了（这不废话吗）。那说到线程，就不得不说Runnable和Callable这两个家伙了。

说熟悉也是真熟悉，在刚学习多线程的时候，第一个例子大概就是下面这样子的。

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("执行线程" + Thread.currentThread().getName());
    }
}).start();

看到了 Runnable的身影，有时候还会看到Callable的。

但是说很熟悉吧，印象也不是很大，好像就用了一下这两位的名号，然后剩下的部分就跟他俩没啥关系了。

今天，我们就来看看这两位到底是什么，有什么区别，什时候应该用 Runnable，什么时候又应该用 Callable。

Runnable

自从 Java 诞生，Runnable就存在了，元老中的元老了，在 1.5 之前，如果你想使用线程，那必须要实现自 Runnable。因为到了 JDK1.5，JDK 才加入了Callable。

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

是不是接口非常简单，就一个抽象方法。

其实还可以再简化一下， @FunctionalInterface标明这个接口是一个函数式接口。函数式接口是在 JDK8 才加入的，为的就是实现函数式编程，就那种 Lambada 表达式。

所以在 JDK1.7 中，是没有@FunctionalInterface修饰的，简简单单。我们找到 JDK1.7 的 Ruunable实现，是下面这样子

public interface Runnable {
    public abstract void run();
}

想了解更多函数式编程的话，可以看这篇文章：Lambda、函数式接口、Stream 一次性全给你

如果一个线程类要实现 Runnable 接口，则这个类必须定义一个名为 run 的无参数方法。

实现了 Runnable 接口的类可以通过实例化一个 Thread 实例，并将自身作为目标传递来运行。

举个例子

首先定义一个RunnableThread类，并实现自（implements）Runnable接口，然后重写 run方法。

public class RunnableThread implements Runnable{
    @Override
    public void run() {
        System.out.println("当前线程名称"+ Thread.currentThread().getName());
    }
}

使用RunnableThread作为线程类（Thread）实例化的参数，然后调用run方法。

RunnableThread runnableThread = new RunnableThread();
Thread thread = new Thread(runnableThread);
thread.start();

注意，是调用新 new 出来的 Thread 实例的start() 方法，不要调用run方法，虽然我们是重写Runnable的 run方法的。调用 run方法并没有创建线程的效果，而是直接在当前线程执行，就和执行一个普通类的普通方法一模一样。

为什么要调用 start()方法呢，我们看看 Thread的 start()方法实现中，其实是调用了一个名称为 start0()的 native 方法，native 方法就不是用 Java 实现的了，而是在 JVM 层面的实现。

这个start0方法的主要逻辑就是启动一个操作系统线程，并和 JVM 线程绑定，开辟一些空间来存储线程状态和上下文的数据，然后执行绑定的 JVM 线程（也就是我们实现了 Runnable 的类）的 run方法的代码块，从而执行我们自定义的逻辑。

还可以用线程池的方式调用

ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
        .setNameFormat("thread-pool-%d").build();
ExecutorService singleThreadPool = new ThreadPoolExecutor(1, 1,
        0L, TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

singleThreadPool.execute(runnableThread);
singleThreadPool.shutdown();

如果 Runnable那么完美的话，就没必要在 JDK1.5 中加入和它超级相似的 Callable了。

Runnable有什么不完美的地方吗？就是它的 run方法是没有返回值的。

如果你想在主线程中拿到新开启线程的返回值的话，Runnable就不太方便了。必须要借助共享变量来完成。

所以，如果你的场景是要有返回值的话， 就要 Callable出手了。

Callable

Callable是在 JDK1.5 才加入的，为的就是弥补 Runnable没有返回值的缺陷，虽然绝大多数场景都可以用 Runnable来实现。

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

和 Runnable类似的，@FunctionalInterface也是后来加入的，可以不考虑，只是为了函数式写法。

Callable接口只有一个 call方法，并且有一个泛型返回值，可以返回任何类型。

举个例子

首先声明一个类，实现自 Callable接口，返回值为字符串类型

public class CallableThread implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "线程名称：" + Thread.currentThread().getName();
    }
}

在代码中通过下面的方式调用

CallableThread callableThread = new CallableThread();
FutureTask<String> futureTask = new FutureTask<>(callableThread);
Thread thread = new Thread(futureTask);
thread.start();
String result = futureTask.get();
System.out.println("执行结果= " + result);

看上去就比 Runnable要复杂一点，要借助FutureTask了，因为 Thread类没有接受Callable的构造函数。

使用 FutureTask.get()方法获取执行结果。

在日常的开发中，不建议直接这样用，除非你明确的知道这样做没有问题，否则的话，推荐使用线程池的方式来使用。

CallableThread callableThread = new CallableThread();
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(callableThread);
String result = future.get();
System.out.println("任务执行结果: " + result);
executor.shutdown();

如何选择用哪一个

取舍的基本原则就是需不需要返回值，如果不需要返回值，那直接就选 Runnable，不用犹豫。如果有返回值的话，那更不用犹豫，不要想着借助共享变量的方式。

另外还有一点就是是否需要抛出异常， Runnable是不接受抛出异常的，Callable可以抛出异常。

Runnable适合那种纯异步的处理逻辑。比如每天定时计算报表，将报表存储到数据库或者其他地方，只是要计算，不需要马上展示，展示内容是在其他的方法中单独获取的。

比如那些非核心的功能，当核心流程执行完毕后，非核心功能就自己去执行吧，至于成不成功的，不是特别重要。例如一个购物下单流程，下单、减库存、加到用户的订单列表、扣款是核心功能，之后的发送 APP 通知、短信通知这些就启动新线程去干去吧。

最后

Runnable 在 java.lang这个包下，而当 JDK1.5 发布的时候，新加入的 Callable被安置在了 java.util.concurrent这个包下，这是 Java 里有名的并发编程相关包，各种锁啊、多线程工具类啊，都被放在这个包下。按道理，Runnable 也应该在这里才对。

可见再厉害的项目也是随着项目的扩大而慢慢的规划，而前期的一些看似不太合理的地方，只能做兼容和妥协。

有些时候我们需要在本地搭开发环境，比如平时学习新技术的时候。或者有时候公司的项目需要在本地建一套类似的，方便调试修改。

开发环境可能包括 MySQL、Redis、Nginx、MQ 、Elasticsearch 等等，今天用的是 MySQL，明天又用 PostgreSQL 了，如果用啥都在本机装一下的话，倒也不是不可以，但是就非常麻烦了，而且有时候安装会遇到各种各样的问题，很是不爽。

有什么快速有优雅的方式没有？

就是我们今天要说的 Docker 了，Docker 到现在为止，早就不是什么新技术了，甚至可以说是很普遍很大众的技术方案了。

我记得我最早开始用 Docker 已经是 2015 年了，到现在已经快 8 年了。只能感叹，时间过得是真快呀！

那段时间也把 Docker 安利给了不少同学、同事，我只是这样告诉他们：“这玩意儿在本地搭一套开发环境真的很方便”，至于它后来发展成现在的规模，我也是没想到的。

如果你是个开发老手儿，相信你早就用起来了。而如果你是个新手，那也要尽快用起来了，不仅能节省搭建环境的时间，还能学习学习，毕竟现在容器化部署方式很普遍了，多了解了解还是非常有必要的。

Docker 原理和基础命令

基本原理

用任何一种技术首先都要先了解它的技术原理，做到心中有数。

Docker 使用 Google 公司推出的 Go 语言进行开发实现，基于 Linux 内核的 cgroup，namespace，以及 OverlayFS 类的 Union FS 等技术，对进程进行封装隔离，属于操作系统层面的虚拟化技术。由于隔离的进程独立于宿主和其它的隔离的进程，因此也称其为容器。

Docker 经常拿来和虚拟机来比较，因为它们两个的用处和用法都很相似，就是在一台实体机上启动多个虚拟系统（暂且这么说）。如果基于使用的层面来讲，你完全可以把 Docker 当做虚拟机来用，然而实际的底层技术原理是完全不一样的。

假设你现在变身了，站在了 Docker 和 虚拟机的内部，从里面向外看，发现虚拟机有自己的 CPU(虚拟 CPU)、内存、硬盘，再往外才是宿主机的 CPU、硬盘、内存等。而如果是在 Docker 内部向外看，发现你无论站在当前实体机的哪个容器里，看到的都是宿主机的 CPU、硬盘、内存等。说明 Dokcer 容器是直接拿宿主机的资源当自己的用，所以每个容器的硬件配置都是一样的，而虚拟机是完全虚拟出来一套。

基础命令

Dokcer 的命令有一大堆，但是常用的就那几个。

镜像相关

获取镜像

docker pull 镜像名称

查看镜像列表

docker image ls

容器相关

查看容器

docker ps -a

新建并启动容器

sudo docker run -t -i ubuntu:12.04  /bin/bash

进入容器

docker exec -it 容器id bash

因为本文不是 Docker 的教程，所以只是抛砖引玉，具体的教程和文档网上到处都是。

安装 Docker Desktop

接下来开始本地实践了，用 Docker 快速搭一套本地环境。

有一些 Docker 的可视化客户端可以安装，帮我们更方便更直观的管理镜像、容器，当然如果你很厉害的话，完全用命令行也不是不行。

我就没这么厉害了，那些参数根本记不住，所以必须要装客户端。我安装的是 Docker Desktop，官方客户端，支持 Mac、Linux、Windows，我大部分时候用 Mac，有时候也要用 Windows，所以 Docker Desktop 是不二选择。

如果你只用 Mac 的话，也可以安装 OrbStack（https://orbstack.dev/），据说比 Docker Desktop 要流畅一些。

下载安装

访问 Docker Desktop 官网 https://www.docker.com/products/docker-desktop/，根据你的系统下载对应的版本。

下载完一键安装就可以了，Docker 环境直接帮你装好了，省心省事儿。下面是它的控制台界面。左侧导航可以查看镜像列表、容器列表、映射的 Volumes。

我们在命令行输入 docker -v，如果出现正确的版本号，说明 docker 服务已经安装正常了。

Docker version 24.0.2, build cb74dfc

接下来有一件事儿是必须要做的，那就是设置国内镜像源，道理大家都懂，你要是用国外的镜像源，一天都不一定能搞下来一个。

点击「设置」按钮，在左侧选择「Docker Engine」

,然后在右侧的配置框中添加如下配置，加到最下面即可：

"registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "https://cr.console.aliyun.com/"
  ]

加完后，点击「Apply & restart」，这时候会重启 Docker 服务。

安装一个服务

MySQL、Nginx、Redis、Zookeeper 这些都是服务，每一个都可以按照这种方式安装，不管你的项目需要多少个服务，一个个安装就好了，很快的呦。

正好我最进要学一下 PostgreSQL，我就直接启动一个 docker 容器了，不在本地安装了。当然了，像数据库这种 I/O 型的应用是不建议容器化的，但是本地开发测试无所谓。

在这个搜索框输入关键词，查找对应的镜像，我在这里输入关键词 PostgreSQL。如果安装 Nginx 那就是输入 Nginx，以此类推。

看，出来了一大堆，我一般都是找第一个，也就是下载量最大的这个。

可以 pull 或者 run，pull 是拉取镜像，run 是拉取镜像+启动容器。

我一般都是直接 run，点一下 run，等一会儿，因为前面已经设置了国内镜像源，所以速度很快，十几秒钟。（根据网速快慢不同，因为要下载镜像文件，有的应用有上百 M）

下载完之后，因为选的是 run，所以直接弹出了启动参数。

设置镜像名称

容器名称（Container name）就是为了我们一看到它就知道是干什么的，用来方便管理的，我就直接命名为 PostgreSQL了。

设置端口映射（Ports）

服务本身有自己的端口，例如 MySQL 是 3306，这是服务本身在容器内的启动端口，但最终我们要通过宿主机去访问服务，所以要将这个容器内的端口绑定到一个宿主机端口，这叫做端口映射，这样一来，我们就可以通过宿主机的端口访问到容器内的端口了。比如我将 MySQL 容器的 3306 端口映射到宿主机的 13306 端口，之后我在设置数据库连接的时候，就用本机 IP:13306 就能访问 MySQL 容器了。

在我这个 PostgreSQL 容器上，我将本机的 15432和容器的 5432端口绑定，之后就可以用 15432做连接端口了。

目录映射（Volumes）

很多服务都会用到存储目录，但是容器本身就在宿主机上，所以需要将服务在容器内的目录映射到宿主机的目录上，这叫目录映射。例如将 Nginx 容器的 /etc/nginx目录映射到宿主机的 /apps/nginx/目录上，那之后我在宿主机访问 /apps/nginx目录时，就能看到 Nginx 容器的配置文件了。

在我这个 PostgreSQL 容器上，我将 /etc/postgresql/postgresql.conf配置文件映射到了我本地的一个目录上。

环境变量

一个服务启动可能会用到启动变量，这些变量可以通过环境变量的方式进行配置。例如，我们启动一个 Java jar 包，要配置 JVM 相关的参数，这些参数就可以放到环境变量中，供启动的时候使用。

因为 PostgreSQL 需要密码，所以这里就设置一个密码的环境变量 POSTGRES_PASSWORD。

都设置好之后，点击run按钮，启动容器。

然后我们看到容器已经启动了，有相应的日志打印出来。

然后点击左侧的Containers，可以看到已经启动的容器和一些基本配置。

然后就可以通过客户端进行连接了。

另外，还可以在容器详情中查看容器的内部文件、状态、配置信息、日志等，以及进入命令行。

最后

第一次可能比较慢，熟悉了之后就非常快了，比你在本地直接安装配置要快的多，而且一些软件安装配置起来非常繁琐，会浪费很多不必要的时间。

还有很多开源的框架、应用提供 docker 版本，掌握了这个方法后，可以很快的安装这些框架、应用来验证和使用，用户体验直接上升一个数量级。

我们总会在各种地方看到零拷贝，那零拷贝到底是个什么东西。

接下来，让我们来理一理啊。

拷贝说的是计算机里的 I/O 操作，也就是数据的读写操作。计算机可是一个复杂的家伙，包括软件和硬件两大部分，软件主要指操作系统、驱动程序和应用程序。硬件那就多了，CPU、内存、硬盘等等一大堆东西。

这么复杂的设备要进行读写操作，其中繁琐和复杂程度可想而知。

传统 I/O 的读写过程

如果要了解零拷贝，那就必须要知道一般情况下，计算机是如何读写数据的，我把这种情况称为传统 I/O。

数据读写的发起者是计算机中的应用程序，比如我们常用的浏览器、办公软件、音视频软件等。

而数据的来源呢，一般是硬盘、外部存储设备或者是网络套接字（也就是网络上的数据通过网口+网卡的处理）。

过程本来是很复杂的，所以大学课程里要通过《操作系统》、《计算机组成原理》来专门讲计算机的软硬件。

简化版读操作流程

那么细的没办法讲来，所以，我们把这个读写过程简化一下，忽略大多数细节，只讲流程。

上图是应用程序进行一次读操作的过程。

1. 应用程序先发起读操作，准备读取数据了；
2. 内核将数据从硬盘或外部存储读取到内核缓冲区；
3. 内核将数据从内核缓冲区拷贝到用户缓冲区；
4. 应用程序读取用户缓冲区的数据进行处理加工；

详细的读写操作流程

下面是一个更详细的 I/O 读写过程。这个图可好用极了，我会借助这个图来厘清 I/O 操作的一些基础但非常重要的概念。

先看一下这个图，上面红粉色部分是读操作，下面蓝色部分是写操作。

如果一下子看着有点儿迷糊的话，没关系，看看下面几个概念就清楚了。

应用程序

就是安装在操作系统上的各种应用。

系统内核

系统内核是一些列计算机的核心资源的集合，不仅包括 CPU、总线这些硬件设备，也包括进程管理、文件管理、内存管理、设备驱动、系统调用等一些列功能。

外部存储

外部存储就是指硬盘、U 盘等外部存储介质。

内核态

• 内核态是操作系统内核运行的模式，当操作系统内核执行特权指令时，处于内核态。
• 在内核态下，操作系统内核拥有最高权限，可以访问计算机的所有硬件资源和敏感数据，执行特权指令，控制系统的整体运行。
• 内核态提供了操作系统管理和控制计算机硬件的能力，它负责处理系统调用、中断、硬件异常等核心任务。

用户态

这里的用户可以理解为应用程序，这个用户是对于计算机的内核而言的，对于内核来说，系统上的各种应用程序会发出指令来调用内核的资源，这时候，应用程序就是内核的用户。

• 用户态是应用程序运行的模式，当应用程序执行普通的指令时，处于用户态。
• 在用户态下，应用程序只能访问自己的内存空间和受限的硬件资源，无法直接访问操作系统的敏感数据或控制计算机的硬件设备。
• 用户态提供了一种安全的运行环境，确保应用程序之间相互隔离，防止恶意程序对系统造成影响。

模式切换

计算机为了安全性考虑，区分了内核态和用户态，应用程序不能直接调用内核资源，必须要切换到内核态之后，让内核来调用，内核调用完资源，再返回给应用程序，这个时候，系统在切换会用户态，应用程序在用户态下才能处理数据。

上述过程其实一次读和一次写都分别发生了两次模式切换。

内核缓冲区

内核缓冲区指内存中专门用来给内核直接使用的内存空间。可以把它理解为应用程序和外部存储进行数据交互的一个中间介质。

应用程序想要读外部数据，要从这里读。应用程序想要写入外部存储，要通过内核缓冲区。

用户缓冲区

用户缓冲区可以理解为应用程序可以直接读写的内存空间。因为应用程序没法直接到内核读写数据， 所以应用程序想要处理数据，必须先通过用户缓冲区。

磁盘缓冲区

磁盘缓冲区是计算机内存中用于暂存从磁盘读取的数据或将数据写入磁盘之前的临时存储区域。它是一种优化磁盘 I/O 操作的机制，通过利用内存的快速访问速度，减少对慢速磁盘的频繁访问，提高数据读取和写入的性能和效率。

PageCache

• PageCache 是 Linux 内核对文件系统进行缓存的一种机制。它使用空闲内存来缓存从文件系统读取的数据块，加速文件的读取和写入操作。
• 当应用程序或进程读取文件时，数据会首先从文件系统读取到 PageCache 中。如果之后再次读取相同的数据，就可以直接从 PageCache 中获取，避免了再次访问文件系统。
• 同样，当应用程序或进程将数据写入文件时，数据会先暂存到 PageCache 中，然后由 Linux 内核异步地将数据写入磁盘，从而提高写入操作的效率。

再说数据读写操作流程

上面弄明白了这几个概念后，再回过头看一下那个流程图，是不是就清楚多了。

读操作

1. 首先应用程序向内核发起读请求，这时候进行一次模式切换了，从用户态切换到内核态；
2. 内核向外部存储或网络套接字发起读操作；
3. 将数据写入磁盘缓冲区；
4. 系统内核将数据从磁盘缓冲区拷贝到内核缓冲区，顺便再将一份（或者一部分）拷贝到 PageCache；
5. 内核将数据拷贝到用户缓冲区，供应用程序处理。此时又进行一次模态切换，从内核态切换回用户态；

写操作

1. 应用程序向内核发起写请求，这时候进行一次模式切换了，从用户态切换到内核态；
2. 内核将要写入的数据从用户缓冲区拷贝到 PageCache，同时将数据拷贝到内核缓冲区；
3. 然后内核将数据写入到磁盘缓冲区，从而写入磁盘，或者直接写入网络套接字。

瓶颈在哪里

但是传统 I/O 有它的瓶颈，这才是零拷贝技术出现的缘由。瓶颈是啥呢，当然是性能问题，太慢了。尤其是在高并发场景下，I/O 性能经常会卡脖子。

那是什么地方耗时了呢？

数据拷贝

在传统 I/O 中，数据的传输通常涉及多次数据拷贝。数据需要从应用程序的用户缓冲区复制到内核缓冲区，然后再从内核缓冲区复制到设备或网络缓冲区。这些数据拷贝过程导致了多次内存访问和数据复制，消耗了大量的 CPU 时间和内存带宽。

用户态和内核态的切换

由于数据要经过内核缓冲区，导致数据在用户态和内核态之间来回切换，切换过程中会有上下文的切换，如此一来，大大增加了处理数据的复杂性和时间开销。

每一次操作耗费的时间虽然很小，但是当并发量高了以后，积少成多，也是不小的开销。所以要提高性能、减少开销就要从以上两个问题下手了。

这时候，零拷贝技术就出来解决问题了。

什么是零拷贝

问题出来数据拷贝和模态切换上。

但既然是 I/O 操作，不可能没有数据拷贝的，只能减少拷贝的次数，还有就是尽量将数据存储在离应用程序（用户缓冲区）更近的地方。

而区分用户态和内核态有其他更重要的原因，不可能单纯为了 I/O 效率就改变这种设计吧。那也只能尽量减少切换的次数。

零拷贝的理想状态就是操作数据不用拷贝，但是显示情况下并不一定真的就是一次复制操作都没有，而是尽量减少拷贝操作的次数。

要实现零拷贝，应该从下面这三个方面入手：

1. 尽量减少数据在各个存储区域的复制操作，例如从磁盘缓冲区到内核缓冲区等；
2. 尽量减少用户态和内核态的切换次数及上下文切换；
3. 使用一些优化手段，例如对需要操作的数据先缓存起来，内核中的 PageCache 就是这个作用；

实现零拷贝方案

直接内存访问（DMA）

DMA 是一种硬件特性，允许外设（如网络适配器、磁盘控制器等）直接访问系统内存，而无需通过 CPU 的介入。在数据传输时，DMA 可以直接将数据从内存传输到外设，或者从外设传输数据到内存，避免了数据在用户态和内核态之间的多次拷贝。

如上图所示，内核将数据读取的大部分数据读取操作都交个了 DMA 控制器，而空出来的资源就可以去处理其他的任务了。

sendfile

一些操作系统（例如 Linux）提供了特殊的系统调用，如 sendfile，在网络传输文件时实现零拷贝。通过 sendfile，应用程序可以直接将文件数据从文件系统传输到网络套接字或者目标文件，而无需经过用户缓冲区和内核缓冲区。

如果不用 sendfile，如果将 A 文件写入 B 文件。

1. 需要先将 A 文件的数据拷贝到内核缓冲区，再从内核缓冲区拷贝到用户缓冲区；
2. 然后内核再将用户缓冲区的数据拷贝到内核缓冲区，之后才能写入到 B 文件；

而用了 sendfile，用户缓冲区和内核缓冲区的拷贝都不用了，节省了一大部分的开销。

共享内存

使用共享内存技术，应用程序和内核可以共享同一块内存区域，避免在用户态和内核态之间进行数据拷贝。应用程序可以直接将数据写入共享内存，然后内核可以直接从共享内存中读取数据进行传输，或者反之。

通过共享一块儿内存区域，实现数据的共享。就像程序中的引用对象一样，实际上就是一个指针、一个地址。

内存映射文件（Memory-mapped Files）

内存映射文件直接将磁盘文件映射到应用程序的地址空间，使得应用程序可以直接在内存中读取和写入文件数据，这样一来，对映射内容的修改就是直接的反应到实际的文件中。

当文件数据需要传输时，内核可以直接从内存映射区域读取数据进行传输，避免了数据在用户态和内核态之间的额外拷贝。

虽然看上去感觉和共享内存没什么差别，但是两者的实现方式完全不同，一个是共享地址，一个是映射文件内容。

Java 实现零拷贝的方式

Java 标准的 IO 库是没有零拷贝方式的实现的，标准 IO 就相当于上面所说的传统模式。只是在 Java 推出的 NIO 中，才包含了一套新的 I/O 类，如 ByteBuffer 和 Channel，它们可以在一定程度上实现零拷贝。

ByteBuffer：可以直接操作字节数据，避免了数据在用户态和内核态之间的复制。

Channel：支持直接将数据从文件通道或网络通道传输到另一个通道，实现文件和网络的零拷贝传输。

借助这两种对象，结合 NIO 中的 API，我们就能在 Java 中实现零拷贝了。

首先我们先用传统 IO 写一个方法，用来和后面的 NIO 作对比，这个程序的目的很简单，就是将一个 100M 左右的 PDF 文件从一个目录拷贝到另一个目录。

public static void ioCopy() {
  try {
    File sourceFile = new File(SOURCE_FILE_PATH);
    File targetFile = new File(TARGET_FILE_PATH);
    try (FileInputStream fis = new FileInputStream(sourceFile);
         FileOutputStream fos = new FileOutputStream(targetFile)) {
      byte[] buffer = new byte[1024];
      int bytesRead;
      while ((bytesRead = fis.read(buffer)) != -1) {
        fos.write(buffer, 0, bytesRead);
      }
    }
    System.out.println("传输 " + formatFileSize(sourceFile.length()) + " 字节到目标文件");
  } catch (IOException e) {
    e.printStackTrace();
  }
}

下面是这个拷贝程序的执行结果，109.92M，耗时 1.29 秒。

传输 109.92 M 字节到目标文件 耗时: 1.290 秒

FileChannel.transferTo() 和 transferFrom()

FileChannel 是一个用于文件读写、映射和操作的通道，同时它在并发环境下是线程安全的，基于 FileInputStream、FileOutputStream 或者 RandomAccessFile 的 getChannel() 方法可以创建并打开一个文件通道。FileChannel 定义了 transferFrom() 和 transferTo() 两个抽象方法，它通过在通道和通道之间建立连接实现数据传输的。

这两个方法首选用 sendfile 方式，只要当前操作系统支持，就用 sendfile，例如 Linux 或 MacOS。如果系统不支持，例如 windows，则采用内存映射文件的方式实现。

transferTo()

下面是一个 transferTo 的例子，仍然是拷贝那个 100M 左右的 PDF，我的系统是 MacOS。

public static void nioTransferTo() {
  try {
    File sourceFile = new File(SOURCE_FILE_PATH);
    File targetFile = new File(TARGET_FILE_PATH);
    try (FileChannel sourceChannel = new RandomAccessFile(sourceFile, "r").getChannel();
         FileChannel targetChannel = new RandomAccessFile(targetFile, "rw").getChannel()) {
      long transferredBytes = sourceChannel.transferTo(0, sourceChannel.size(), targetChannel);

      System.out.println("传输 " + formatFileSize(transferredBytes) + " 字节到目标文件");
    }
  } catch (IOException e) {
    e.printStackTrace();
  }
}

只耗时 0.536 秒，快了一倍。

传输 109.92 M 字节到目标文件 耗时: 0.536 秒

transferFrom()

下面是一个 transferFrom 的例子，仍然是拷贝那个 100M 左右的 PDF，我的系统是 MacOS。

public static void nioTransferFrom() {
  try {
    File sourceFile = new File(SOURCE_FILE_PATH);
    File targetFile = new File(TARGET_FILE_PATH);

    try (FileChannel sourceChannel = new RandomAccessFile(sourceFile, "r").getChannel();
         FileChannel targetChannel = new RandomAccessFile(targetFile, "rw").getChannel()) {
      long transferredBytes = targetChannel.transferFrom(sourceChannel, 0, sourceChannel.size());
      System.out.println("传输 " + formatFileSize(transferredBytes) + " 字节到目标文件");
    }
  } catch (IOException e) {
    e.printStackTrace();
  }
}

执行时间：

传输 109.92 M 字节到目标文件 耗时: 0.603 秒

Memory-Mapped Files

Java 的 NIO 也支持内存映射文件（Memory-mapped Files），通过 FileChannel.map() 实现。

下面是一个 FileChannel.map()的例子，仍然是拷贝那个 100M 左右的 PDF，我的系统是 MacOS。

    public static void nioMap(){
        try {
            File sourceFile = new File(SOURCE_FILE_PATH);
            File targetFile = new File(TARGET_FILE_PATH);

            try (FileChannel sourceChannel = new RandomAccessFile(sourceFile, "r").getChannel();
                 FileChannel targetChannel = new RandomAccessFile(targetFile, "rw").getChannel()) {
                long fileSize = sourceChannel.size();
                MappedByteBuffer buffer = sourceChannel.map(FileChannel.MapMode.READ_ONLY, 0, fileSize);
                targetChannel.write(buffer);
                System.out.println("传输 " + formatFileSize(fileSize) + " 字节到目标文件");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

执行时间：

传输 109.92 M 字节到目标文件 耗时: 0.663 秒

浏览器是再熟悉不过的东西了，几乎每个人用过，比如 Chrome、FireFox、Safari，尤其是我们程序员，可谓开发最强辅助，摸鱼最好的伴侣。

浏览器能干的事儿，无头浏览器都能干，而且很多时候比标准浏览器还要更好用，而且能实现一些很好玩儿的功能，我们能借助无头浏览器比肩标准浏览器强大的功能，而且又能灵活的用程序控制的特性，做出一些很有意思的产品功能来，稍后我们细说。

什么是浏览器

关于浏览器还有一个很好玩儿的梗，对于一些对计算机、对互联网不太了解的同学，你跟他说浏览器，他/她就默认是百度了，因为好多小白的浏览器都设置了百度为默认页面。所以很多小白将浏览器和搜索引擎（99%是百度）划等号了。

浏览器里我百分之99的时间都是用 Chrome，不过有一说一，这玩意是真耗内存，我基本上是十几、二十几个的 tab 开着，再加上几个 IDEA 进程，16G 的内存根本就不够耗的。

以 Chrome 浏览器为例，Chrome 由以下几部分组成：

1. 渲染引擎（Rendering Engine）：Chromium使用的渲染引擎主要有两个选项：WebKit和Blink。WebKit是最初由苹果开发的渲染引擎，后来被Google采用并继续开发。Blink则是Google从WebKit分支出来并进行独立开发的渲染引擎，目前Chromium主要使用Blink作为其默认的渲染引擎。
2. JavaScript引擎（JavaScript Engine）：Chromium使用V8引擎作为其JavaScript引擎。V8是由Google开发的高性能JavaScript引擎，它负责解析和执行网页中的JavaScript代码。
3. 网络栈（Network Stack）：Chromium的网络栈负责处理网络通信。它支持各种网络协议，包括HTTP、HTTPS、WebSocket等，并提供了网络请求、响应处理和数据传输等功能。
4. 布局引擎（Layout Engine）：Chromium使用布局引擎来计算网页中元素的位置和大小，并确定它们在屏幕上的布局。布局引擎将CSS样式应用于DOM元素，并计算它们的几何属性。
5. 绘制引擎（Painting Engine）：绘制引擎负责将网页内容绘制到屏幕上，生成最终的图像。它使用图形库和硬件加速技术来高效地进行绘制操作。
6. 用户界面（User Interface）：Chromium提供了用户界面的支持，包括地址栏、标签页、书签管理、设置等功能。它还提供了扩展和插件系统，允许用户根据自己的需求进行个性化定制。
7. 其他组件：除了上述主要组件外，Chromium还包括其他一些辅助组件，如存储系统、安全模块、媒体处理、数据库支持等，以提供更全面的浏览器功能。

Chrome 浏览器光源码就有十几个G，2000多万行代码，可见，要实现一个功能完善的浏览器是一项浩大的工程。

什么是无头浏览器

无头浏览器（Headless Browser）是一种浏览器程序，没有图形用户界面（GUI），但能够执行与普通浏览器相似的功能。无头浏览器能够加载和解析网页，执行JavaScript代码，处理网页事件，并提供对DOM（文档对象模型）的访问和操作能力。

与传统浏览器相比，无头浏览器的主要区别在于其没有可见的窗口或用户界面。这使得它在后台运行时，不会显示实际的浏览器窗口，从而节省了系统资源，并且可以更高效地执行自动化任务。

常见的无头浏览器包括Headless Chrome（Chrome的无头模式）、PhantomJS、Puppeteer（基于Chrome的无头浏览器库）等。它们提供了编程接口，使开发者能够通过代码自动化控制和操作浏览器行为。

无头浏览器其实就是看不见的浏览器，所有的操作都要通过代码调用 API 来控制，所以浏览器能干的事儿，无头浏览器都能干，而且很多事儿做起来比标准的浏览器更简单。

我举几个常用的功能来说明一下无头浏览器的主要使用场景

1. 自动化测试： 无头浏览器可以模拟用户行为，执行自动化测试任务，例如对网页进行加载、表单填写、点击按钮、检查页面元素等。
2. 数据抓取： 无头浏览器可用于爬取网页数据，自动访问网站并提取所需的信息，用于数据分析、搜索引擎优化等。
3. 屏幕截图： 无头浏览器可以加载网页并生成网页的截图，用于生成快照、生成预览图像等。
4. 服务器端渲染： 无头浏览器可以用于服务器端渲染（Server-side Rendering），将动态生成的页面渲染为静态HTML，提供更好的性能和搜索引擎优化效果。
5. 生成 PDF 文件：使用浏览器自带的生成 PDF 功能，将目标页面转换成 PDF 。

使用无头浏览器做一些好玩的功能

开篇就说了使用无头浏览器可以实现一些好玩儿的功能，这些功能别看不大，但是使用场景还是很多的，有些开发者就是抓住这些小功能，开发出好用的产品，运气好的话还能赚到钱，尤其是在国外市场。（在国内做收费的产品确实不容易赚到钱）

下面我们就来介绍两个好玩儿而且有用的功能。

前面的自动化测试、服务端渲染就不说了。

自动化测试太专业了，一般用户用不到，只有开发者或者测试工程师用。

服务端渲染使用无头浏览器确实没必要，因为有太多成熟的方案了，连 React 都有服务端渲染的能力(RSC)。

网页截图功能

我们可能见过一些网站提供下载文字卡片或者图文卡片的功能。比如读到一段想要分享的内容，选中之后将文本端所在的区域生成一张图片。

其实就是通过调用浏览器自身的 API page.screenshot，可以对整个页面或者选定的区域生成图片。

通过这个方法，我们可以做一个浏览器插件，用户选定某个区域后，直接生成对应的图片。这类功能在手机APP上很常见，在浏览器上一搬的网站都不提供。

说到这儿好像和无头浏览器都没什么关系吧，这都是标准浏览器中做的事儿，用户已经打开了页面，在浏览器上操作自己看到的内容，顺理成章。

但是如果这个操作是批量的呢，或者是在后台静默完成的情况呢？

那就需要无头浏览器来出手了，无头浏览器虽然没有操作界面，但是也具备绘制引擎的完整功能，仍然可以生成图像，利用这个功能，就可以批量的、静默生成图像了，并且可以截取完整的网页或者部分区域。

Puppeteer 是无头浏览器中的佼佼者，提供了简单好用的 API ，不过是 nodejs 版的。

如果是用 Java 开发的话，有一个替代品，叫做 Jvppeteer，提供了和 Puppeteer 几乎一模一样的 API。

下面这段代码就展示了如何用 Jvppeteer 来实现网页的截图。

下面这个方法是对整个网页进行截图，只需要给定网页 url 和 最终的图片路径就可以了。

public static boolean screenShotWx(String url, String path) throws IOException, ExecutionException, InterruptedException {
  BrowserFetcher.downloadIfNotExist(null);
  ArrayList<String> arrayList = new ArrayList<>();
  // MacOS 要这样写，指定Chrome的位置
  String executablePath = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
  LaunchOptions options = new LaunchOptionsBuilder().withExecutablePath(executablePath).withArgs(arrayList).withHeadless(true).withIgnoreHTTPSErrors(true).build();
  // Windows 和 Linux 这样就可以，不用指定 Chrome 的安装位置
  //LaunchOptions options = new LaunchOptionsBuilder().withArgs(arrayList).withHeadless(true).withIgnoreHTTPSErrors(true).build();
  arrayList.add("--no-sandbox");
  arrayList.add("--disable-setuid-sandbox");
  arrayList.add("--ignore-certificate-errors");
  arrayList.add("--disable-gpu");
  arrayList.add("--disable-web-security");
  arrayList.add("--disable-infobars");
  arrayList.add("--disable-extensions");
  arrayList.add("--disable-bundled-ppapi-flash");
  arrayList.add("--allow-running-insecure-content");
  arrayList.add("--mute-audio");
  Browser browser = Puppeteer.launch(options);
  Page page = browser.newPage();
  page.setJavaScriptEnabled(true);
  page.setUserAgent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36 Edg/83.0.478.37");
  page.setCacheEnabled(true);
  page.onConsole((msg) -> {
    log.info("==> {}", msg.text());
  });


  PageNavigateOptions pageNavigateOptions = new PageNavigateOptions();
  pageNavigateOptions.setTimeout(1000000);
  //dom加载完毕就算导航完成
  pageNavigateOptions.setWaitUntil(Collections.singletonList("domcontentloaded"));
  page.goTo(url, pageNavigateOptions, true);

  autoScroll(page);
  ElementHandle body = page.$("body");
  double width = body.boundingBox().getWidth();
  double height = body.boundingBox().getHeight();
  Viewport viewport = new Viewport();

  viewport.setWidth((int) width); // 设置视口宽度
  viewport.setHeight((int) height + 100); // 设置视口高度
  page.setViewport(viewport);
  ScreenshotOptions screenshotOptions = new ScreenshotOptions();
  screenshotOptions.setType("jpeg");
  screenshotOptions.setFullPage(Boolean.FALSE);
  //screenshotOptions.setClip(clip);
  screenshotOptions.setPath(path);
  screenshotOptions.setQuality(100);
  // 或者转换为 base64
  //String base64Str = page.screenshot(screenshotOptions);
  //System.out.println(base64Str);

  browser.close();
  return true;
}

一个自动滚屏的方法。

虽然可以监听页面上的事件通知，比如 domcontentloaded，文档加载完成的通知，但是很多时候并不能监听到网页上的所有元素都加载完成了。对于那些滚动加载的页面，可以用这种方式模拟完全加载，加载完成之后再进行操作就可以了。

使用自动滚屏的操作，可以模拟我们人为的在界面上下拉滚动条的操作，随着滚动条的下拉，页面上的元素会自然的加载，不管是同步的还有延迟异步的，比如图片、图表等。

private static void autoScroll(Page page) {
  if (page != null) {
    try {
      page.evaluate("() => {\n" +
                    "   return new Promise((resolve, reject) => {\n" +
                    "            //滚动的总高度\n" +
                    "            let totalHeight = 0;\n" +
                    "            //每次向下滚动的高度 500 px\n" +
                    "            let distance = 500;\n" +
                    "            let k = 0;\n" +
                    "            let timeout = 1000;\n" +
                    "            let url = window.location.href;\n" +
                    "            let timer = setInterval(() => {\n" +
                    "                //滚动条向下滚动 distance\n" +
                    "                window.scrollBy(0, distance);\n" +
                    "                totalHeight += distance;\n" +
                    "                k++;\n" +
                    "                console.log(`当前第${k}次滚动，页面高度: ${totalHeight}`);\n" +
                    "                //页面的高度 包含滚动高度\n" +
                    "                let scrollHeight = document.body.scrollHeight;\n" +
                    "                //当滚动的总高度 大于 页面高度 说明滚到底了。也就是说到滚动条滚到底时，以上还会继续累加，直到超过页面高度\n" +
                    "                if (totalHeight >= scrollHeight || k >= 200) {\n" +
                    "                    clearInterval(timer);\n" +
                    "                    resolve();\n" +
                    "                    window.scrollTo(0, 0);\n" +
                    "                }\n" +
                    "            }, timeout);\n" +
                    "        })\n" +
                    "  }");
    } catch (Exception e) {

    }
  }
}

调用截图方法截图，这里是对一篇公众号文章进行整个网页的截图。

public static void main(String[] args) throws Exception {
  screenShotWx("https://mp.weixin.qq.com/s/MzCyWqcH1TCytpnHI8dVjA", "/Users/fengzheng/Desktop/PICTURE/wx.jpeg");
}

或者也可以截取页面中的部分区域，比如某篇文章的正文部分，下面这个方法是截图一个博客文章的正文部分。

public static boolean screenShotJueJin(String url, String path) throws IOException, ExecutionException, InterruptedException {
  BrowserFetcher.downloadIfNotExist(null);
  ArrayList<String> arrayList = new ArrayList<>();
  String executablePath = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
  LaunchOptions options = new LaunchOptionsBuilder().withExecutablePath(executablePath).withArgs(arrayList).withHeadless(true).withIgnoreHTTPSErrors(true).build();

  //LaunchOptions options = new LaunchOptionsBuilder().withArgs(arrayList).withHeadless(true).withIgnoreHTTPSErrors(true).build();
  arrayList.add("--no-sandbox");
  arrayList.add("--disable-setuid-sandbox");
  Browser browser = Puppeteer.launch(options);
  Page page = browser.newPage();

  PageNavigateOptions pageNavigateOptions = new PageNavigateOptions();
  pageNavigateOptions.setTimeout(1000000);
  //dom加载完毕就算导航完成
  pageNavigateOptions.setWaitUntil(Collections.singletonList("domcontentloaded"));
  page.goTo(url, pageNavigateOptions, true);

  WaitForSelectorOptions waitForSelectorOptions = new WaitForSelectorOptions();
  waitForSelectorOptions.setTimeout(1000 * 15);
  waitForSelectorOptions.setVisible(Boolean.TRUE);
  // 指定截图的区域
  ElementHandle elementHandle = page.waitForSelector("article.article", waitForSelectorOptions);
  Clip clip = elementHandle.boundingBox();
  Viewport viewport = new Viewport();
  ElementHandle body = page.$("body");
  double width = body.boundingBox().getWidth();
  viewport.setWidth((int) width); // 设置视口宽度
  viewport.setHeight((int) clip.getHeight() + 100); // 设置视口高度
  page.setViewport(viewport);
  ScreenshotOptions screenshotOptions = new ScreenshotOptions();
  screenshotOptions.setType("jpeg");
  screenshotOptions.setFullPage(Boolean.FALSE);
  screenshotOptions.setClip(clip);
  screenshotOptions.setPath(path);
  screenshotOptions.setQuality(100);
  // 或者生成图片的 base64编码
  String base64Str = page.screenshot(screenshotOptions);
  System.out.println(base64Str);
  return true;
}

调用方式：

public static void main(String[] args) throws Exception {
  screenShotJueJin("https://juejin.cn/post/7239715628172902437", "/Users/fengzheng/Desktop/PICTURE/juejin.jpeg");
}

最后的效果是这样的，可以达到很清晰的效果。

网页生成 PDF 功能

这个功能可太有用了，可以把一些网页转成离线版的文档。有人说直接保存网页不就行了，除了程序员，大部分人还是更能直接读 PDF ，而不会用离线存储的网页。

我们可以在浏览器上使用浏览器的「打印」功能，用来将网页转换成 PDF 格式。

但这是直接在页面上操作，如果是批量操作呢，比如想把一个专栏的所有文章都生成 PDF呢，就可以用无头浏览器来做了。

有的同学说，用其他的库也可以呀，Java 里面有很多生成 PDF 的开源库，可以把 HTML 转成 PDF，比如Apache PDFBox、IText 等，但是这些库应对一般的场景还行，对于那种页面上有延迟加载的图表啊、图片啊、脚本之类的就束手无策了。

而无头浏览器就可以，你可以监听页面加载完成的事件，可以模拟操作，主动触发页面加载，甚至还可以在页面中添加自定义的样式、脚本等，让生成的 PDF 更加完整、美观。

下面这个方法演示了如何将一个网页转成 PDF 。

public static boolean pdf(String url, String savePath) throws Exception {
  Browser browser = null;
  Page page = null;
  try {
    //自动下载，第一次下载后不会再下载
    BrowserFetcher.downloadIfNotExist(null);
    ArrayList<String> arrayList = new ArrayList<>();
    // MacOS
    String executablePath = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
    LaunchOptions options = new LaunchOptionsBuilder().withExecutablePath(executablePath).withArgs(arrayList).withHeadless(true).withIgnoreHTTPSErrors(true).build();
		// windows 或 linux
    //LaunchOptions options = new LaunchOptionsBuilder().withArgs(arrayList).withHeadless(true).withIgnoreHTTPSErrors(true).build();

    arrayList.add("--no-sandbox");
    arrayList.add("--disable-setuid-sandbox");
    arrayList.add("--ignore-certificate-errors");
    arrayList.add("--disable-gpu");
    arrayList.add("--disable-web-security");
    arrayList.add("--disable-infobars");
    arrayList.add("--disable-extensions");
    arrayList.add("--disable-bundled-ppapi-flash");
    arrayList.add("--allow-running-insecure-content");
    arrayList.add("--mute-audio");

    browser = Puppeteer.launch(options);
    page = browser.newPage();

    page.onConsole((msg) -> {
      log.info("==> {}", msg.text());
    });

    page.setViewport(viewport);
    page.setJavaScriptEnabled(true);
    page.setUserAgent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36 Edg/83.0.478.37");
    page.setCacheEnabled(true);

    //设置参数防止检测
    page.evaluateOnNewDocument("() =>{ Object.defineProperties(navigator,{ webdriver:{ get: () => undefined } }) }");
    page.evaluateOnNewDocument("() =>{ window.navigator.chrome = { runtime: {},  }; }");
    page.evaluateOnNewDocument("() =>{ Object.defineProperty(navigator, 'languages', { get: () => ['en-US', 'en'] }); }");
    page.evaluateOnNewDocument("() =>{ Object.defineProperty(navigator, 'plugins', { get: () => [1, 2, 3, 4, 5,6], }); }");

    PageNavigateOptions pageNavigateOptions = new PageNavigateOptions();
    pageNavigateOptions.setTimeout(1000000);
    //dom加载完毕就算导航完成
 pageNavigateOptions.setWaitUntil(Collections.singletonList("domcontentloaded"));

    page.goTo(url, pageNavigateOptions, true);
    // 添加自定义演示
    StyleTagOptions styleTagOptions1 = new StyleTagOptions();
    styleTagOptions1.setContent("html {-webkit-print-color-adjust: exact} .table > table > tr:nth-child(1),.table > table > tr:nth-child(2) {background: #4074b0;} #tableB td:nth-child(2) {width:60%;}");
    page.addStyleTag(styleTagOptions1);

    //滚屏
    autoScroll(page);
    Thread.sleep(1000);

    PDFOptions pdfOptions = new PDFOptions();
    //            pdfOptions.setHeight("5200");
    pdfOptions.setPath(savePath);
    page.pdf(pdfOptions);

  } catch (Exception e) {
    log.error("生成pdf异常：{}", e.getMessage());
    e.printStackTrace();
  } finally {
    if (page != null) {
      page.close();
    }
    if (browser != null) {
      browser.close();
    }
  }
  return true;
}

调用生成 PDF 的方法，将一个微信公众号文章转成 PDF。

    public static void main(String[] args) throws Exception {
        String pdfPath = "/Users/fengzheng/Desktop/PDF";
        String filePath = pdfPath + "/hello.pdf";
			 JvppeteerUtils.pdf("https://mp.weixin.qq.com/s/MzCyWqcH1TCytpnHI8dVjA", filePath);
    }

最终的效果，很清晰，样式都在，基本和页面一模一样。

最近 ChatGPT 以及类似的 AI 产品大火，不仅带火了英伟达的 GPU 芯片，也带火了向量数据库。

其实向量数据库吧，很早就之前就有了，而且很多公司也在用，只不过最近借着AI的东风，被推到了台前，比如 Pinecone 这家向量数据库公司，估值约为 10 亿美元，刚刚融资 1 亿美元。

再比如，这个……

什么是向量和向量化

向量数据库，顾名思义，存储的内容是向量。

那什么又是向量呢？

我们最早接触向量应该是在数学里面，例如一个二维的向量用(x,y)表示在x轴和y轴的值，用(x,y,z)表是在x轴、y轴和z轴的三维向量。还可以有更多的维度表示多维向量。

向量数据库应用最多的场景就是相似度搜索，就是根据用户的一个输入匹配出几个相似度最高的结果。有点儿像模糊查询或者全文检索的意思，但是原理又不一样，全文检索的核心技术应该是分词+索引 ，而向量数据库是向量化（Embedding）+索引。

索引就不用多说了，只要涉及到存储的，一定会用到索引。

向量化（Embedding）

在 OpenAI 官网上专门有 Embedding 的介绍，并且提供了相关的模型API，叫做 ada，专门将数据 Embedding。

Embedding 是用一个低维稠密向量来表示一个对象，使得这个向量能够表达相应对象的某些特征，同时向量之间的距离能反应对象之间的相似性。

Embedding 是一个多维向量数组，由一系列数字组成，通过相关的算法可以将文本、音频、视频等内容转换为多维向量数组，并最终存储到向量数据库中。

假设 man的向量数组可表示为 [0.1,0.2,0.1]，woman的向量数组可表示为[0.3,0.1,0.1]。

下图中可以看到这些多维向量在向量空间中的关系，man和woman之间、king和queen之间，China和Beijing之间。

各种各样的内容进行向量化之后，最终在向量空间会形成或近或疏的关系。比如下面这幅图中可以看出，如果你搜索一个动物相关的内容，肯定（大概率）不会匹配到运动员的那一堆数据中。

向量化的过程是一个复杂的过程，通常会用到经过大量训练和优化的大模型以及神经网络等厉害的技术，所以，个人或普通公司只能用大厂提供的付费服务，例如OpenAI 的 Ada 模型。

为什么这么复杂呢，比如基于自然语言处理的方式向量化，不仅要分析文本本身的意思，还会包括情感分析、翻译等工作要处理，例如你搜索英文的 apple,也要能匹配上中文的苹果或其他的语种。还有如果你搜索苹果太难吃了，要不能匹配出苹果太棒了这种结果吧。

目前主流的Embedding 方法主要有如下这三类：

矩阵分解法

矩阵分解法是一种常见的 Embedding 方法，它可以将高维的矩阵映射成两个低维矩阵的乘积，很好地解决了数据稀疏的问题。

基于自然语言处理的方法

自然语言处理（NLP）是一种人工智能技术，它涉及计算机对人类语言的理解和生成。NLP 包括许多任务，如文本分类、情感分析、命名实体识别、机器翻译和自动摘要等。NLP 技术可以帮助计算机处理和分析大量的文本数据，从而使计算机能够更好地理解人类语言并作出更准确的预测和决策。而基于 NLP 的 Embedding 方法的主要思想是将每个单词或短语映射到一个低维向量空间中，使得在这个向量空间中，相似的单词或短语在距离上更加接近，以便于支持语义查找与分析工作。常见的方法包括：

1. Word2vec
2. GloVe（Global Vectors for Word Representation）
3. FastText

基于图的方法

上述方法都是针对序列文本而设计的，而对于诸如社交网络分析、推荐系统、知识图谱等领域中的问题，如下图所示，数据对象之间更多呈现出图结构：

基于图的 Embedding 技术是一种将图数据（通常为高维稠密的矩阵）映射为低微稠密向量的过程，能够很好地解决图数据难以高效输入机器学习算法的问题。Graph Embedding 技术将图中的节点以低维稠密向量的形式进行表达，要求在原始图中相似 (不同的方法对相似的定义不同) 的节点其在低维表达空间也接近。常见的方法包括：

1. DeepWalk
2. Node2vec
3. Metapath2vec

向量数据库的特点

向量数据库的应用场景决定了其大概率需要存储海量的数据，而不是想关系型数据库那样存储确定的多少条数据。

• 向量数据库要具具有高可用、高扩展性的架构；
• 向量数据库是计算密集型应用，需要良好的硬件设备加速；
• 高并发、低延迟

应用场景

向量数据库的核心功能就是相似性匹配，所以，它的应用场景也是围绕着这个功能来的。

• 文本搜索（包含语义的那种），最常见的功能；
• 图片、语音、视频搜索，例如那种以图搜图的功能，当然，与之匹配的向量化的过程也比文字更复杂，例如语音的向量化要包括对语音进行特征化的提取，比如声纹等等。歌曲识别（非歌词的那种）就可以用向量化和向量数据库；
• 推荐系统，根据系统给用户打的标签，给用户推荐相似度最高的商品、服务等；
• 异常检测，相似度过低可以判断为异常，例如人脸识别功能，如果相似度过低，那可能就是非本人；

最近的AI热潮掀起了不少新技术，感觉快要学不过来，不过大多数的内容想学也学不会了，只能学学周边技术，用用人家的API了。

毕竟像OpenAI这种，里面的员工的职位都是xxx科学家，不是xxx工程师了。

但是，该关注还是要关注一下，说不好哪天就用到自己的产品里了。

首先思考这样一个问题，假设你不知道任何框架，现在有两台机器，每台机器上有一个服务，让你在其中的一个服务中调用另一个服务中的接口，怎么样才能做到呢？

RPC 全称为远程过程调用（Remote Procedure Call Protocol），通俗点来说，就是从一台机器通过网络调用到另一台机器的某个方法。

那这样说来的话，通过 Socket 调用另一台机器的 Sokcet 服务也是RPC，通过一些 HTTP 请求工具包调用一个远程 HTTP 接口也是 RPC 了。

最开始的 RPC 定义还有可能是这样的，但是这种方式太底层、太繁琐了。

现在的 RPC 除了要有明显的网络通信特征外，还要具备下面几个特点：

1、良好的封装：让我们感觉调用远程接口就好像是调用本地方法一样方便，封装底层网络通信的细节，让我们更专注于业务逻辑。

2、良好的协议设计：数据在调用方和提供方传输，数据组织要遵循约定好的协议格式，比如 HTTP 协议、TCP 协议这种。

3、高效的序列化和反序列化：远程调用，所以很大一部分开销来自于数据传输，所以原则上数据量越小越好，这就依赖于序列化的算法了。

封装的艺术（如何隐藏底层逻辑）

如果每次调用提供方提供的方法时都像下面这样繁琐，指明 URL、自己构造 JSON 序列化字符串等等，会不会不太方便。

public static final MediaType JSON
    = MediaType.get("application/json; charset=utf-8");

OkHttpClient client = new OkHttpClient();

String post(String url, String json) throws IOException {
  RequestBody body = RequestBody.create(json, JSON);
  Request request = new Request.Builder()
      .url(url)
      .post(body)
      .build();
  try (Response response = client.newCall(request).execute()) {
    return response.body().string();
  }
}

而像 Dubbo 这样调用，如果没有接触过 RPC 的人，刚看到这段代码会感觉到好像就是在调用本地的一个方法。隐藏了很多的细节。

@DubboReference
private DemoService demoService;

String result = demoService.sayHello("world");
System.out.println("Receive result ======> " + result);

这就是现代 RPC 里一个很重要的特性，就是封装，尽量隐藏网络上的细节，让使用者感觉就是在调用本地的方法。

那在一般的 RPC 框架中，例如 Dubbo、GRPC等，是如何进行封装的呢。

我们看上面的图，其中调用方和服务提供方都有一个部分叫做存根（Stub），就是靠的它。听上去感觉这词不太容易理解啊，啥叫存根呢，其实说简单点儿就是一个代理方案。

举个例子，当我们调用本地的一个服务类的某个方法时，实际上这个服务类已经是一个代理类了，调用这个类的某个方法，实际上代理方法中可以加入很多额外的逻辑，比如构造 HTTP 请求、构造TCP 请求等等，最终穿过网络调用到真正的服务提供方的同名方法。

说到 Java 中的代理技术，相信大家都不陌生，有动态代理、静态代理，不了解的同学可以参考 Spring AOP 和 动态代理技术 这篇文章。

协议的实现

这里说的协议就是网络通信协议。远程过程调用嘛，那必须得通过网络传输才行，而通过网络传输那就得有遵行规定的协议。

这个协议是用来规范传输的数据的，所以它是一个应用层协议，比如 HTTP ，而不是传输层的协议，比如 TCP 、UDP 。

比如 GRPC 框架中用的协议是 HTTP2，Dubbo中可以选择多种协议，比如Hession、HTTP等。

下图是 HTTP 1.0 协议的格式，包括首部和请求内容，首部可以指定请求方式、URI、版本、内容类型和长度等，内容部分就是真正要传输的数据， 如果是一个 RPC 调用的话，那就是调用方法的参数和一些额外的信息（比如调用的方法名、类名等），首部和内容由一个空行分隔。

接收端可以根据空行了解哪些是头部，哪些是内容。

可以通过首部的内容长度字段来进行分配内存或其他操作。

其他的协议都有自己的格式，我们也可以自定义一个协议。如下是一个简单的协议格式：

通过魔术位可以直接判断是不是本协议数据，如果是的话，再进行处理。

通过整体长度和首部长度可以确定数据内容的长度，用来解析首部和数据。

通过序列化方式字段可以确定数据序列化采用的什么方式，用来实现反序列化。

一个 RPC 框架使用哪种协议是有权衡取舍的，如果考虑通用性那就可能使用 HTTP或者 HTTP2这种协议，比如 GRPC ，这样一来，可以在各种语言框架中通用，但是性能就稍微差一点了。

而如果从性能方面考虑呢，那就要牺牲掉一部分通用性了，比如Hession、Dubbo2协议，只有框架开发者提供了对应语言的版本，才能在相应的语言中使用。

序列化和反序列化（编解码）

上面说的协议主要指的是数据通信协议，而序列化和反序列化其实也要遵循一定的协议。

说到序列化和反序列化，其实我们并不陌生。在Java开发中，经常会遇到。最常用的就是把 Java Bean 序列化为 JSON，将 JSON 反序列化为 Java Bean。

JSON 就是最常见的一种序列化和发序列化协议，其他的序列化方式还有 XML、GRPC 中用到的 Protocol Buffers。 Hessian 也有它自己的序列化算法。

为什么要有序列化呢，数据要想在网络中传输，那必须是二进制的形式。在远程调用里，我们像调用本地方法那样调用，使用的参数都是和当前项目语言一致的参数类型，比如Java中的 String、List、Map等等，那要把这些类型转换成二进制，靠的就是序列化算法。

JSON 和 XML 这种文本序列化方式比较简单，使用场景非常广泛，通用性强，但是序列化后产生的二进制体积也比较大，这样在传输的时候就会比较耗时、占用带宽。

而像 Protocol Buffers 这种序列化方式，它使用结构化的消息定义语言（IDL）来定义数据结构和服务接口，支持多种编程语言，而且序列化后的二进制也会最大程度的压缩，少占用带宽，有很高的传输效率。

总结

下图是整个 RPC 调用过程的简化版。

序列化和反序列化功能会在代理中进行，在很多框架中也称这部分为编解码。

封装的网络请求既有可能是 HTTP 请求，也有可能是 Sockets 请求，比如有很多 RPC 功能都使用 Netty 作为通讯层。

除了主要的功能外，一个成熟的 RPC 框架还有考虑诸多其他因素，比如性能、安全性、兼容性等等。

答：由于本人才疏学浅，学点东西就爱做个笔记，也不奢望多少人看到，主要是怕自己日后忘记，当然如果有人看到并且学到点东西，我也是非常高兴的。

Spring Cloud 有众多模块，一旦项目搭起来，有些模块可能就不怎么动了，例如网关、服务注册中心等，知识点就是这样，一旦长时间不用，慢慢印象也就模糊了。

那么多的 Spring Cloud 的文章，我写的有啥不同吗？

答：没有不同。无论是什么框架，说白了也就是个工具，工具的使用都是一样的，所以使用手册也是大同小异。当然，使用姿势正确得当，系统也就更稳定，性能更好。我这个系列也是介绍 Spring Cloud 各模块的使用。所以说，看其他的文章和看我写的也都差不多。

以上。

以下，正文开始

说到 Spring Cloud，那肯定要少不了提一下微服务框架，所谓的微服务框架就是把负责的功能拆分成比较小、功能比较单一的服务独立处理，例如单点登录服务、支付服务、订单服务等，当然如果订单功能比较复杂还可以独立出更具体的服务。

我在之前的文章中（https://www.cnblogs.com/fengzheng/p/5847441.html）也提到过微服务的几个主要特点，个人感觉：

1、微服务在架构设计方面：可以帮助我们理清业务，更加清晰的设计系统架构。

2、微服务在开发方面：可以降低项目结构的复杂度，降低代码内部的耦合度。

3、在运维方面：可以清晰快速的定位排查问题。

微服务框架里 Dubbo 和 Spring Cloud 这两个用的最多。随着 docker 和 容器编排技术的成熟，最近用 Docker、Kubernetes 构建微服务架构的也越来越多了。

公司之前的项目中有一部分采用 Spring MVC 方式开发，所以一直在用 Dubbo。新的系统全部采用 Spring Boot，顺便也就使用了 Spring Cloud 技术栈。我倒不觉得两者有什么高下之分，只要能够满足业务需求，使用哪种技术倒无所谓，况且 Dubbo 用下来也没什么问题。

今天就是说一下 Spring Cloud，Spring Cloud 就是一个大集合，包括了配置中心、注册中心、负责均衡、熔断处理等等一些成熟的框架，并用 Spring boot 的形式包装好，方便开发者使用。Spring boot 相信大家肯定都不陌生，应该做 Java 开发的几乎或多或少都使用过。它比起 Spring MVC 来，省去了繁杂的配置文件，可谓是开发微服务项目的不二选择。

Spring Cloud 包括众多的子项目，可谓是微服务行业一条龙服务。只有你想不到，没有你找不到的。

Spring Cloud Config

配置中心，将系统中用到的一些配置信息存储到配置中心，方便维护，不用每次修改配置都重启服务。用的比较多的配置中心还有etcd、携程的 Apollo、Disconf 。

Spring Cloud Netflix

Netflix OSS 是一组开源的框架和组件库，是Netflix公司开发出来解决分布式系统的一些有趣的可扩展类库。Spring Cloud 把他们都放到 Spring Cloud Netflix 下，这是一个框架集合，它包括 Eureka 、Ribbon、Zuul、Hystrix 等。

Eureka

服务中心，这可以说是微服务架构的核心功能了，微服务部署之后，一定要有服务注册和发现的能力，Eureka 就是担任这个角色的。如果你用过 dubbo 的话，那一定知道 dubbo 中服务注册和发现的功能是用 zookeeper 来实现的。

目前官方已停止升级，如果你的项目中还没有使用并且打算使用注册中心的话，可以直接使用 Spring Cloud Consul。

Ribbon

提供客户端负责均衡功能，例如一个服务提供者部署了 3 个实例，那么使用 Ribbon 可以指定负载均衡算法请求其中一个实例，Ribbon 如果配合 Eureka ，使用起来非常简单。

Hystrix

熔断器，假设有 3 个服务提供实例，其中有一个实例由于某中原因挂掉了，那么当再有请求进来的时候，如果还是向这个实例上发请求，那将会导致请求积压阻塞，这个时候，熔断器就要发挥它的作用，将这个有问题的实例下线，这样一来，再有新的请求进来，就不会再发到这个有问题的实例上了。

Zuul

服务网关。主要实现了路由转发和过滤器功能，对于处理一些数据聚合、鉴权、监控、统计类的功能非常好用。

Gateway

也是服务网关，可以认为它是 Zuul 的下一代，无论从易用性和性能方便都有所提高，如果你的系统中还没有使用 Zuul ，并且准备上网关，可以直接选择 Gateway 。

Spring Cloud Consul

Consul 让服务注册和服务发现（通过 DNS 和 HTTP 接口）更加简单，甚至对于外部服务（例如SaaS）注册也一样。Spring Cloud Consul 可替代已有的 Spring Cloud Eureka。Eureka 2.x 版本也已经停止开发，并且 Spring Cloud 官方也建议用 Spring Cloud Consul 来替代，当然如果已经用了 Eureka 在项目中也没有关系，Eureka 已经足够稳定，正常使用没有任何问题。

Spring Cloud Consul 可替代已有的 Spring Cloud Config ，当做配置中心使用。

Spring Cloud Stream

Spring Cloud Stream 是消息中间件组件，它集成了 kafka 和 rabbitmq 。如果你的系统中打算集成 kafka 或 rabbitmq，可以考虑使用 Stream 。

Spring Cloud Bus

消息总线，用于在集群（例如，配置变化事件）中传播状态变化，可与Spring Cloud Config联合实现热部署。集成了 Rabbitmq 和 kafka 。刚刚上面说到的 Stream 好像也是这个功能。没错，我们可以认为 Bus 是 Stream 的进一步封装，使用更简单。而 Stream 的灵活性更高。

Spring Cloud Feign

Feign是一种声明式、模板化的HTTP客户端。它可以用注解的方式简化 HTTP 请求，可以快速简单的请求服务提供接口。如果你还在使用 restTemplate 或者其他方式，不妨考虑一下 Feign。

Spring Cloud Sleuth

服务日志收集和链路追踪模块，封装了 Dapper 和 log-based 追踪以及 Zipkin 和 HTrace 操作。与之功能相同的框架还有 skywalking、Pinpoint，另外国内还有美团开源的 CAT，只不过 CAT 属于代码侵入的，需要开发人员在系统中做代码埋点，不过也更加灵活，更加精细。

Spring Cloud Security

可用做授权服务、单点登录等。如果服务需要做权限控制，那除非你自己实现。不然用到最多的就是 shiro 和 Spring Security 。Spring Boot 中用的比较多的就是 Security，众多授权机制中属于 OAuth2 最为流行。Spring Cloud Security 就是将 Security、OAuth2 做了集成，方便使用。

除了以上的这些常用功能外，Spring Cloud 还提供了一些其他的模块，具体的可以到 Spring Cloud 官网一看。官网上介绍的更加详细。官网地址:https://spring.io/projects/spring-cloud

Eureka 是 Netflix 开源的服务注册发现组件，服务发现可以说是微服务架构的核心功能了，微服务部署之后，一定要有服务注册和发现的能力，Eureka 就是担任这个角色的。如果你用过 dubbo 的话，那一定知道 dubbo 中服务注册和发现的功能是用 zookeeper 来实现的。

Eureka 目前是 2.x 版本，并且官方已经宣布不再维护更新。不过其实 Eureka 已经很稳定了，当做注册中心完全没有问题。Spring Cloud 集成了 Eureka ，并做了完善的封装。方便我们使用 Spring boot 开发的时候简单配置就可以使用。

微服务框架中有三类角色，分别是注册中心、服务提供者、服务消费者，注册中心就是今天要说的主角 Eureka，这篇文章简单说明 Spring Cloud Eureka 的使用，模拟实现单点和高可用注册中心，并简单介绍服务提供者和服务消费者如何使用 Eureka 提供的服务注册和发现功能。

版本说明 Java : 1.8

Spring Boot : 2.1.3.RELEASE

Spring Cloud: Finchley.SR2

之说以要说一下版本，因为 Finchley.SR2 版本较之前的版本包名有变化，所以在引用 maven 包的时候要注意。

单点注册中心

创建 Eureka 注册中心

1、引用 maven 包，其中

<dependencyManagement> 
  <dependencies> 
    <dependency> 
      <groupId>org.springframework.cloud</groupId>  
      <artifactId>spring-cloud-dependencies</artifactId>  
      <version>Finchley.SR2</version>  
      <type>pom</type>  
      <scope>import</scope> 
    </dependency> 
  </dependencies> 
</dependencyManagement>

<!-- 最新版的 eureka 服务端包 -->
<dependency> 
  <groupId>org.springframework.cloud</groupId>  
  <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId> 
</dependency>

<!-- 监控管理 -->
<dependency> 
  <groupId>org.springframework.boot</groupId>  
  <artifactId>spring-boot-starter-actuator</artifactId> 
</dependency>

2、新建 bootstrap.yml，并配置 Spring cloud 参数

spring:
  application:
    name: kite-eureka-center
  cloud:
    inetutils: ## 网卡设置
      ignoredInterfaces:  ## 忽略的网卡
        - docker0
        - veth.*
        - VM.*
      preferredNetworks:  ## 优先的网段
        - 192.168

3、新建 application.yml ，并配置参数

server:
  port: 3000
eureka:
  instance:
    hostname: eureka-center
    appname: 注册中心
  client:
    registerWithEureka: false # 单点的时候设置为 false 禁止注册自身
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://localhost:3000/eureka
  server:
    enableSelfPreservation: false
    evictionIntervalTimerInMs: 4000

bootstrap.yml 和 application.yml 的区别：

• bootstrap.yml 在 application.yml 之前启动；

• bootstrap.yml 配置 application 的 name、spring.cloud.config.server.git.uri、一些encryption/decryption（加密/解密）信息；

• application.yml 的信息会覆盖 bootstrap.yml 中的内容，当遇到相同的配置的时候；

4、新建 Application.java 启动文件

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

@EnableEurekaServer 表示使用 Eureka Server 端功能，也就是启动为一个注册中心节点。

5、运行 Application.java ，访问 http://localhost:3000 即可看到 Eureka 提供的 ui 控制台。

创建一个服务提供者

接下来创建一个服务提供者，并注册到上面创建的 Eureka 注册中心。

1、添加 maven 依赖包

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

2、配置 application.yml

server:
  port: 3001

eureka:
  instance:
    preferIpAddress: true
  client:
    serviceUrl:
      defaultZone: http://localhost:3000/eureka  ## 注册到 eureka 
spring:
  application:
    name: single-provider  ## 应用程序名称，后面会在消费者中用到

3、创建一个简单的 RESTful 接口 controller

@Slf4j
@RestController
public class ProviderController {

    @Autowired
    private DiscoveryClient discoveryClient;

    @RequestMapping(value = "/hello")
    public String hello(){
        List<String> services = discoveryClient.getServices();
        for(String s : services){
            log.info(s);
        }
        return "hello spring cloud!";
    }

    @RequestMapping(value = "/nice")
    public String nice(){
        List<String> services = discoveryClient.getServices();
        for(String s : services){
            log.info("gogogo" + s);
        }
        return "nice to meet you!";
    }

}

4、创建 spring boot 启动类

@EnableEurekaClient
@SpringBootApplication
public class SingleProviderApplication {

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

@EnableEurekaClient 修饰，表示要注册到注册中心。

5、启动项目，正常情况下就注册到了 Eureka 注册中心，打开 Eureka 控制台，会看到已经出现了这个服务

创建一个服务消费者

有了服务提供者，接下来创建一个消费者来消费一下

1、引用 maven 包

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

2、配置 application.yml

server:
  port: 3002
eureka:
  client:
    serviceUrl:
      defaultZone: http://127.0.0.1:3000/eureka  ## 注册到 eureka
  instance:
    preferIpAddress: true
spring:
  application:
    name: single-customer  

3、开始消费提供者提供的服务接口，这里演示了两种消费方法，一种是用 RestTemplate ，另外一种是用 FeignClient，Feign 同样是 Netflix 开源，并被 Spring Cloud 封装到 spring-cloud-starter-openfeign 包中。

创建启动类，并添加相关注解

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
public class SingleCustomerApplication {

    /**
     * 注入 RestTemplate 
     * 并用 @LoadBalanced 注解，用负载均衡策略请求服务提供者
     * 这是 Spring Ribbon 的提供的能力
     * @return
     */
    @LoadBalanced
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

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

@EnableEurekaClient 声明此项目为一个 eureka 客户端，@EnableFeignClients 声明此项目可以使用 Feign。

4、创建一个服务接口类，这是 Feign 的使用方式，详细的用法可以查一下 Spring Cloud Feign 相关文档

/**
 * IHelloService
 * 配置服务提供者：single-provider 是服务提供者的 application.name
 */
@FeignClient("single-provider")
public interface IHelloService {

    @RequestMapping(value = "/hello")
    String hello();

    @RequestMapping(value = "nice")
    String nice();
}

@FeignClient 注解的 value 为服务提供者的 appplication.name 。

5、创建一个 Controller 用于调用服务

@RestController
public class ConsumerController {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private IHelloService helloService;

    private static final String applicationName = "single-provider";

    @RequestMapping(value = "feignRequest")
    public Object feignRequest(){
        String s = helloService.nice();
        return s;
    }

    @RequestMapping(value = "commonRequest")
    public Object commonRequest(){
        String url = "http://"+ applicationName +"/hello";
        String s = restTemplate.getForObject(url,String.class);
        return s;
    }

}

其中 feignRequest 方法是使用了 Feign 的方式调用服务接口；

commonRequest 方法是用 RestTemplate 提供的方法调用服务接口；

6、最后，启动服务，访问地址：http://localhost:3002/commonRequest 和 http://localhost:3002/feignRequest

Eureka 如果不加安全控制，会存在下列问题：

1. Eureka 控制台可以看到各服务的状态和参数等信息，如果不加控制，只要知道注册中心的地址，就可以登录上去看到各服务信息；
2. 只要知道注册中心地址，服务提供者就可以注册上来，对外提供服务；
3. 只要知道注册中心地址，服务消费者就可以发现注册中心的服务，并调用服务；

为了安全起见，我们还是为 Eureka 增加安全控制，这里用 Spring Security 实现最基础的用户名、密码控制。

一个小知识点而已，几个配置就可以完成。

1. maven 包引用

在服务注册中心项目的 pom.xml 文件中引入 Spring Security 包。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

2.增加应用配置

在应用配置文件中增加关于 security 的配置，一般是放在 application.yml ，但是本项目中分了 application.yml 和 bootstrap.yml 两个配置文件，所以我这里是放在了 application.yml 中。

spring:
  application:
    name: kite-eureka-center
  security:
      user:
        name: test  			 # 用户名
        password: 123456   # 密码

此时，启动并访问 Eureka 管理控制台，会提示输入用户名和密码，输入上面的 name 和 password 即可。

3.服务提供者注册服务

在服务提供者的应用配置文件中做以下修改即可

eureka:
  instance:
    statusPageUrlPath: /actuator/info
    healthCheckUrlPath: /actuator/health
    prefer-ip-address: true
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://test:123456@localhost:3000/eureka/

上述配置与没有安全控制的时候唯一的差别就是在 defaultZone 指定的 eureka 地址。在地址中增加了用户名和密码。 没有安全控制之前的地址为：

http://localhost:3000/eureka/

加了安全控制之后的地址为：

http://test:123456@localhost:3000/eureka/

4.服务消费者

服务消费者和服务提供者配置方式一致。

具体的代码已经放到 github。源码地址

本篇来实现一个高可用版的服务注册中心。在线上环境中，使用高可用是最基本的要求，如果有单点故障的时候，不至于整个服务都无响应。

这里的高可用包括注册中心的高可用，服务提供者注册到服务中心集群上，这样服务消费者发现服务的时候就通过集群来实现，不会出现注册中心不可用，造成整个系统崩溃。

还包括服务提供者的高可用，一个服务提供者注册多个实例到注册中心，这样，即时有其中某个实例 down 掉，其他实例依然可以提供服务。

高可用服务注册发现中心

下图是 Eureka 官方提供的高可用架构图。

1、创建注册中心，重点在于配置文件

bootstrap.yml 配置如下：

spring:
  application:
    name: eureka-ha-center  ## 设置应用的名称
  cloud:
    inetutils:
      ignoredInterfaces:
        - docker0
        - veth.*
        - VM.*
      preferredNetworks:
        - 192.168

application.yml 配置如下：

spring:
  profiles: eureka-center1
server:
  port: 1989
eureka:
  instance:
    hostname: ha-eureak-center1
    appname: 注册中心
  client:
    registerWithEureka: true
    fetchRegistry: true
    serviceUrl:
      defaultZone: http://localhost:1988/eureka ## 注册到 eureka-center2 上，端口1988


---
spring:
  profiles: eureka-center2
server:
  port: 1988
eureka:
  instance:
    hostname: ha-eureak-center2
    appname: 注册中心
  client:
    registerWithEureka: true  
    fetchRegistry: true
    serviceUrl:
      defaultZone: http://localhost:1989/eureka  ## 注册到 eureka-center1 上，端口1989

通过 profiles 参数，稍后在启动的时候根据 vm 参数决定启用配置。

client.registerWithEureka 和 client.registerWithEureka 设置为 true，表示要注册到 eureka 。单点模式中设置为 false。高可用版本要允许注册到 eureka 。注意：eureka-center1 和 eureka-center2 的 serviceUrl.defaultZone 是互相注册的。

2、启动应用。

*-*通过设置 vm 参数 -Dspring.profiles.active=eureka-center1 在 1989 端口启动注册中心1

*-*通过设置 vm 参数 -Dspring.profiles.active=eureka-center2 在 1988 端口启动注册中心2。

之后访问 http://localhost:1988 或 http://localhost:1989 都能进入 eureka ui 界面，并且能看到注册到自身的eureka 服务。

2、创建高可用的服务提供者，并注册到上面的两个注册中心

application.yml 配置如下：

spring:
  profiles: ha-provider1
  application:
    name: ha-provider
  security:
    user:
      name: root
      password: root
server:
  port: 1990
eureka:
  instance:
    preferIpAddress: true
  client:
    serviceUrl:
      defaultZone: http://localhost:1989/eureka,http://localhost:1988/eureka


---
spring:
  profiles: ha-provider2
  application:
    name: ha-provider
  security:
    user:
      name: root
      password: root
server:
  port: 1991
eureka:
  instance:
    preferIpAddress: true
  client:
    serviceUrl:
      defaultZone: http://localhost:1989/eureka,http://localhost:1988/eureka

同样利用 profiles 区分两个服务提供者。

注意，defaultZone 设置了上面启动的两个注册中心服务，中间用逗号隔开。

之后设置 vm 参数 -Dspring.profiles.active=ha-provider1 启动第一个服务提供者，设置 vm 参数 -Dspring.profiles.active=ha-provider2 启动第二个服务提供者。

之后打开 eureka ui 界面，看到已经注册到注册中心

3、创建服务消费者

application.yml 配置：

spring:
  application:
    name: ha-customer
server:
  port: 1992
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1989/eureka,http://localhost:1988/eureka
  instance:
    preferIpAddress: true

启动服务消费者

通过访问 http 接口，查看服务是否可用，通过日志可以看出每次调用有可能负载到不同的服务提供者实例上。

4、停掉一个服务提供者。

访问 http 接口，不影响服务，会自动负载到正常的服务提供者实例上。

5、停掉一个注册中心实例。

访问 http 接口，仍然不受影响。

Spring Cloud Config 是 Spring Cloud 家族中最早的配置中心，虽然后来又发布了 Consul 可以代替配置中心功能，但是 Config 依然适用于 Spring Cloud 项目，通过简单的配置即可实现功能。

配置文件是我们再熟悉不过的了，尤其是 Spring Boot 项目，除了引入相应的 maven 包之外，剩下的工作就是完善配置文件了，例如 mysql、redis 、security 相关的配置。除了项目运行的基础配置之外，还有一些配置是与我们业务有关系的，比如说七牛存储、短信相关、邮件相关，或者一些业务上的开关。

对于一些简单的项目来说，我们一般都是直接把相关配置放在单独的配置文件中，以 properties 或者 yml 的格式出现，更省事儿的方式是直接放到 application.properties 或 application.yml 中。但是这样的方式有个明显的问题，那就是，当修改了配置之后，必须重启服务，否则配置无法生效。

目前有一些用的比较多的开源的配置中心，比如携程的 Apollo、蚂蚁金服的 disconf 等，对比 Spring Cloud Config，这些配置中心功能更加强大。有兴趣的可以拿来试一试。

接下来，我们开始在 Spring Boot 项目中集成 Spring Cloud Config，并以 github 作为配置存储。除了 git 外，还可以用数据库、svn、本地文件等作为存储。主要从以下三块来说一下 Config 的使用。

*1.*基础版的配置中心（不集成 Eureka）;

*2.*结合 Eureka 版的配置中心;

*3.*实现配置的自动刷新；

实现最简单的配置中心

最简单的配置中心，就是启动一个服务作为服务方，之后各个需要获取配置的服务作为客户端来这个服务方获取配置。

先在 github 中建立配置文件

我创建的仓库地址为：配置中心仓库

目录结构如下：

配置文件的内容大致如下，用于区分，略有不同。

data:
  env: config-eureka-dev
  user:
    username: eureka-client-user
    password: 1291029102

注意文件的名称不是乱起的，例如上面的 config-single-client-dev.yml 和 config-single-client-prod.yml 这两个是同一个项目的不同版本，项目名称为 config-single-client， 一个对应开发版，一个对应正式版。config-eureka-client-dev.yml 和 config-eureka-client-prod.yml 则是另外一个项目的，项目的名称就是 config-eureka-client 。

创建配置中心服务端

1、新建 Spring Boot 项目，引入 config-server 和 starter-web

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- spring cloud config 服务端包 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>

2、配置 config 相关的配置项

bootstrap.yml 文件

spring:
  application:
    name: config-single-server  # 应用名称
  cloud:
     config:
        server:
          git:
            uri: https://github.com/huzhicheng/config-only-a-demo #配置文件所在仓库
            username: github 登录账号
            password: github 登录密码
            default-label: master #配置文件分支
            search-paths: config  #配置文件所在根目录

application.yml

server:
  port: 3301

3、在 Application 启动类上增加相关注解 @EnableConfigServer

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

启动服务，接下来测试一下。

Spring Cloud Config 有它的一套访问规则，我们通过这套规则在浏览器上直接访问就可以。

/{application}/{profile}[/{label}]
/{application}-{profile}.yml
/{label}/{application}-{profile}.yml
/{application}-{profile}.properties
/{label}/{application}-{profile}.properties

{application} 就是应用名称，对应到配置文件上来，就是配置文件的名称部分，例如我上面创建的配置文件。

{profile} 就是配置文件的版本，我们的项目有开发版本、测试环境版本、生产环境版本，对应到配置文件上来就是以 application-{profile}.yml 加以区分，例如application-dev.yml、application-sit.yml、application-prod.yml。

{label} 表示 git 分支，默认是 master 分支，如果项目是以分支做区分也是可以的，那就可以通过不同的 label 来控制访问不同的配置文件了。

上面的 5 条规则中，我们只看前三条，因为我这里的配置文件都是 yml 格式的。根据这三条规则，我们可以通过以下地址查看配置文件内容:

http://localhost:3301/config-single-client/dev/master

http://localhost:3301/config-single-client/prod

http://localhost:3301/config-single-client-dev.yml

http://localhost:3301/config-single-client-prod.yml

http://localhost:3301/master/config-single-client-prod.yml

通过访问以上地址，如果可以正常返回数据，则说明配置中心服务端一切正常。

创建配置中心客户端，使用配置

配置中心服务端好了，配置数据准备好了，接下来，就要在我们的项目中使用它了。

1、引用相关的 maven 包。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- spring cloud config 客户端包 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

2、初始化配置文件

bootstrap.yml

spring:
  profiles:
    active: dev

---
spring:
  profiles: prod
  application:
    name: config-single-client
  cloud:
     config:
       uri: http://localhost:3301
       label: master
       profile: prod


---
spring:
  profiles: dev
  application:
    name: config-single-client
  cloud:
     config:
       uri: http://localhost:3301
       label: master
       profile: dev

配置了两个版本的配置，并通过 spring.profiles.active 设置当前使用的版本，例如本例中使用的 dev 版本。

application.yml

server:
  port: 3302
management:
  endpoint:
    shutdown:
      enabled: false
  endpoints:
    web:
      exposure:
        include: "*"

data:
  env: NaN
  user:
    username: NaN
    password: NaN

其中 management 是关于 actuator 相关的，接下来自动刷新配置的时候需要使用。

data 部分是当无法读取配置中心的配置时，使用此配置，以免项目无法启动。

3、要读取配置中心的内容，需要增加相关的配置类，Spring Cloud Config 读取配置中心内容的方式和读取本地配置文件中的配置是一模一样的。可以通过 @Value 或 @ConfigurationProperties 来获取。

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

4、要读取配置中心的内容，需要增加相关的配置类，Spring Cloud Config 读取配置中心内容的方式和读取本地配置文件中的配置是一模一样的。可以通过 @Value 或 @ConfigurationProperties 来获取。

使用 @Value 的方式：

@Data
@Component
public class GitConfig {

    @Value("${data.env}")
    private String env;

    @Value("${data.user.username}")
    private String username;

    @Value("${data.user.password}")
    private String password;

}

使用 @ConfigurationProperties 的方式：

@Component
@Data
@ConfigurationProperties(prefix = "data")
public class GitAutoRefreshConfig {

    public static class UserInfo {
        private String username;

        private String password;

        public String getUsername() {
            return username;
        }

        public void setUsername(String username) {
            this.username = username;
        }

        public String getPassword() {
            return password;
        }

        public void setPassword(String password) {
            this.password = password;
        }

        @Override
        public String toString() {
            return "UserInfo{" +
                    "username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    '}';
        }
    }

    private String env;

    private UserInfo user;
}

4、增加一个 RESTController 来测试使用配置

@RestController
public class GitController {

    @Autowired
    private GitConfig gitConfig;

    @Autowired
    private GitAutoRefreshConfig gitAutoRefreshConfig;

    @GetMapping(value = "show")
    public Object show(){
        return gitConfig;
    }

    @GetMapping(value = "autoShow")
    public Object autoShow(){
        return gitAutoRefreshConfig;
    }
}