算法-数据结构基础2

学习了这么长时间的数据结构与算法，通过博客记录下个人的理解与总结，学习过程中多加思考，结合Java集合体系中的结构，思考换做自己要如何实现

数据结构是算法的基石，只有掌握了数据结构，才能实现各种奇思妙想的算法

**基本概念**

数据结构整体分为线性结构、非线性结构的、散列表等，从物理存储的角度上来说，数据结构又分为物理结构和逻辑结构，物理结构只有数组、链表两种方式，逻辑结构基于数组、链表衍生出来的结构

![image.png](https://blog.liushigong.cn/static/img/7ccb49ea04934450db65bb7738b0b7bc.image.webp)

重点掌握

将上图牢记于心，在脑海中形成自己对数据结构概念理解的轮廓，所有的数据结构都可以基于**物理结构**（也就是数组、链表）进行实现，无非就是逻辑结构上贴合顺序存储方式或者是链式存储方式。

# 线性结构

线性结构是最简单的结构，其中的数据元素之间存在一种线性的关系，可以理解为是一种一维结构。
线性结构可以分为以下几种

## 数组

数组（array），是Java最基础常用的结构，数组中存储的称为元素。

**特点：**

* 数组创建以后，大小固定，是不可变的。
* 数组中的元素在内存中是连续存储的，天然有序。
* 每个元素对应着一个下标，可通过下标索引值快速定位到元素。

相关信息

在java中，最经典的莫过于ArrayList的实现，底层使用数组结构，查询、修改效率高，对于插入数据超过数组长度时进行动态扩容，删除中间元素时对元素进行迁移，有兴趣可以阅读下源码

## 链表

链表（Linked list）是一种链式结构，链表中的数据称为节点，每个节点数据中包含下一个节点的数据指针，一个链表由多个节点组成。

**特点：**

* 链表的长度可以动态改变，长度没有限制。
* 链表中的节点可以在内存中的任意位置，非连续存储。
* 通过指针来导航和访问链表中的元素。

![image.png](https://blog.liushigong.cn/static/img/9dc99e421f99e5bfaa25c6bbbdc2b40d.image.webp)

根据以上特点，实现一个单向链表

```
java

public class ListNode {
    Object val;
    ListNode next;

    ListNode() {
    }

    ListNode(Object val) {
        this.val = val;
    }

    ListNode(Object val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}
```

相关信息

链表的实现分为多种，以上只是单向链表的实现，还存在双向链表，还有单向/双向循环链表，本质就是节点中存在一个指向下一节点的引用与上一节点的引用，即为双向，循环链表的本质就是尾节点的下一个节点从指向null，变成指向头节点，而头节点的上一节点引用从null，变成了指向尾节点

**数组与链表对比**

数组与链表本身既是物理结构，同时也是逻辑结构，他们的优势各不相同  
数组适用于读多写少的场景  
链表适用于频繁插入与删除的场景  
**在Java中，经常把集合ArrayList 与 LinkedList 进行对比，本质对比的就是底层上不同结构的实现**

![image.png](https://blog.liushigong.cn/static/img/484d6211c50d74384e415810979fa998.image.webp)

## 栈

栈是一种特殊的线性数据结构，支持两种主要操作：压栈（push）和弹栈（pop），遵循先进后出（LIFO, Last In First Out）的原则。

**实现方式：**

数组：使用数组的一端作为栈顶，当需要压栈或出栈时，只需更新栈顶指针。

![image.png](https://blog.liushigong.cn/static/img/6ceb0411f017b24fe7fe6135b00fa926.image.webp)

```
java

public class ArrayStack<T> {
    private static final int DEFAULT_CAPACITY = 10;
    private Object[] elements;
    private int top; // 栈顶指针

    public ArrayStack() {
        elements = new Object[DEFAULT_CAPACITY];
        top = -1; // 初始化为空栈
    }

    // 入栈操作
    public void push(T item) {
        if (top == elements.length - 1) {
            resize(); // 动态扩容
        }
        elements[++top] = item;
    }

    // 出栈操作
    public T pop() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        T item = (T) elements[top];
        elements[top--] = null; // 帮助垃圾回收
        return item;
    }

    // 查看栈顶元素
    public T peek() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        return (T) elements[top];
    }

    // 判断栈是否为空
    public boolean isEmpty() {
        return top == -1;
    }

    // 获取栈大小
    public int size() {
        return top + 1;
    }

    // 动态扩容方法
    private void resize() {
        int newSize = elements.length * 2;
        Object[] newArray = new Object[newSize];
        System.arraycopy(elements, 0, newArray, 0, elements.length);
        elements = newArray;
    }
}
```

链表：使用单向链表的头部作为栈顶，新元素总是添加到头部，出栈也是从头节点开始。

![image.png](https://blog.liushigong.cn/static/img/a259904c2ca8301cd587fbda5f387b42.image.webp)

```
java

public class LinkedListStack<T> {
    // 链表节点定义
    private static class Node<T> {
        T data;
        Node<T> next;

        Node(T data) {
            this.data = data;
            this.next = null;
        }
    }

    private Node<T> top; // 栈顶节点
    private int size;    // 栈大小

    public LinkedListStack() {
        top = null;
        size = 0;
    }

    // 入栈操作
    public void push(T item) {
        Node<T> newNode = new Node<>(item);
        newNode.next = top; // 新节点指向旧栈顶
        top = newNode;     // 更新栈顶指针
        size++;
    }

    // 出栈操作
    public T pop() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        T item = top.data;
        top = top.next; // 栈顶指针下移
        size--;
        return item;
    }

    // 查看栈顶元素
    public T peek() {
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        return top.data;
    }

    // 判断栈是否为空
    public boolean isEmpty() {
        return top == null;
    }

    // 获取栈大小
    public int size() {
        return size;
    }
}
```

相关信息

栈结构更多的体现在历史的回溯上，在Java中，栈结构是我们接触的数据结构中最多的一种，我们常说的异常堆栈信息，就是使用栈，方法之间的调用都是通过栈来进行存储的。

## 队列

队列是一种只允许在一端进行插入操作，在另一端进行删除操作的线性数据结构，遵循先进先出（FIFO, First In First Out）的原则。

**实现方式：**

数组：使用数组实现 **循环队列**，通过调整指针来模拟循环，从而提高空间利用率。

![image.png](https://blog.liushigong.cn/static/img/ad51c27bf9413a1192c3dc3f29acce14.image.webp)

```
java

public class ArrayQueue<E> extends AbstractQueue<E> {
    private static final int DEFAULT_CAPACITY = 10;
    private Object[] elements;
    private int head;  // 队列头指针
    private int tail;  // 队列尾指针
    private int size;  // 当前元素数量

    public ArrayQueue() {
        elements = new Object[DEFAULT_CAPACITY];
        head = 0;
        tail = 0;
        size = 0;
    }

    // 入队操作 (队列满时自动扩容)
    @Override
    public boolean offer(E e) {
        if (size == elements.length) {
            resize();
        }
        elements[tail] = e;
        tail = (tail + 1) % elements.length;
        size++;
        return true;
    }

    // 出队操作
    @Override
    public E poll() {
        if (size == 0) return null;
        E element = (E) elements[head];
        elements[head] = null; // 帮助垃圾回收
        head = (head + 1) % elements.length;
        size--;
        return element;
    }

    // 查看队首元素
    @Override
    public E peek() {
        return size == 0 ? null : (E) elements[head];
    }

    // 队列大小
    @Override
    public int size() {
        return size;
    }

    // 动态扩容方法
    private void resize() {
        int newCapacity = elements.length * 2;
        Object[] newArray = new Object[newCapacity];
        // 将元素复制到新数组的连续位置
        if (head < tail) {
            System.arraycopy(elements, head, newArray, 0, size);
        } else {
            System.arraycopy(elements, head, newArray, 0, elements.length - head);
            System.arraycopy(elements, 0, newArray, elements.length - head, tail);
        }
        elements = newArray;
        head = 0;
        tail = size;
    }

    // 迭代器实现（简化版）
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            private int cursor = 0;

            @Override
            public boolean hasNext() {
                return cursor < size;
            }

            @Override
            public E next() {
                if (!hasNext()) throw new NoSuchElementException();
                return (E) elements[(head + cursor++) % elements.length];
            }
        };
    }

    // 清空队列
    @Override
    public void clear() {
        Arrays.fill(elements, null);
        head = 0;
        tail = 0;
        size = 0;
    }
}
```

链表：使用单向链表的头部和尾部作为队列的两端

![image.png](https://blog.liushigong.cn/static/img/4269f5739478e3b897f8f7ef3343f485.image.webp)

```
java

public class LinkedQueue<E> extends AbstractQueue<E> {
    // 链表节点定义
    private static class Node<E> {
        E data;
        Node<E> next;

        Node(E data) {
            this.data = data;
            this.next = null;
        }
    }

    private Node<E> head;  // 队列头指针
    private Node<E> tail;  // 队列尾指针
    private int size;      // 队列大小

    public LinkedQueue() {
        head = null;
        tail = null;
        size = 0;
    }

    // 入队操作
    @Override
    public boolean offer(E e) {
        Node<E> newNode = new Node<>(e);
        if (tail == null) {
            head = tail = newNode;
        } else {
            tail.next = newNode;
            tail = newNode;
        }
        size++;
        return true;
    }

    // 出队操作
    @Override
    public E poll() {
        if (size == 0) return null;
        E element = head.data;
        head = head.next;
        if (head == null) {
            tail = null;
        }
        size--;
        return element;
    }

    // 查看队首元素
    @Override
    public E peek() {
        return size == 0 ? null : head.data;
    }

    // 队列大小
    @Override
    public int size() {
        return size;
    }

    // 迭代器实现
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            private Node<E> current = head;

            @Override
            public boolean hasNext() {
                return current != null;
            }

            @Override
            public E next() {
                if (!hasNext()) throw new NoSuchElementException();
                E data = current.data;
                current = current.next;
                return data;
            }
        };
    }

    // 清空队列
    @Override
    public void clear() {
        head = null;
        tail = null;
        size = 0;
    }
}
```

相关信息

队列还有一些其他类型：优先队列、双端队列

优先队列：根据优先级进行出队，谁的优先级高谁先出队，其本质是在二叉堆的基础上进行实现。

![image.png](https://blog.liushigong.cn/static/img/18e628a6bbcfece03603e62816a9da0c.image.webp)

双端队列：采用双向链表结构，可以从头部入队出队，也可以从尾部入队出队

![image.png](https://blog.liushigong.cn/static/img/c9e459d8597e37a191c3c5121e19a7d4.image.webp)

## 哈希表

哈希表（hash table）也叫做散列表，这种数据结构提供了键（Key）与值（Value）的映射关系。只要给出一个Key，就可以高效查找到它所匹配的Value，时间复杂度接近于O(1).

### 实现原理

哈希表本质就是一个数组，Value就是数组中的数据，而Key一般是字符串，通过哈希函数算法将Key转换成数组的索引

### 哈希冲突

由于数组的长度是有限的，如果插入的Value值越来越多时，不同的Key通过哈希函数计算出来的索引下标可能会相同，这就是哈希冲突也叫做哈希碰撞

哈希冲突时无可避免的，解决的方式有很多种，最常用的是开放寻址法、链表法。

**开放寻址法**

开放寻址法的思路很简单，就是当Key通过哈希函数计算出来的索引下标位置存在数据时，就往后移一位看是否存在数据，直到找到为空的下标位置进行存储。

**链表法**

哈希表中的数组不仅是一个Enrty，还是链表的头节点。每个Enrty对象都通过next指针指向下一个Entry节点，当新来的Entry的索引下标存在数据冲突时，则将当前Entry插入到链表的尾部即可。

![image.png](https://blog.liushigong.cn/static/img/7c34b840b5139c3e90dcbba773b7082b.image.webp)

当读取数据的时，根据当前哈希函数计算的索引位置，找到链表的头节点，然后从链表中找到Key对应的Enrty。

思考？当链表过长时，读取效率下降如何处理

在极端情况下，如果很多键都映射到同一个桶（bucket），链表会变得很长，导致查询效率从O(1)退化为O(n)，性能下降明显。

回想下 `HashMap` 的源码实现，看下 `HashMap` 在 JDK1.8 中是如何优化链表过长问题的。

**HashMap 的优化：**

到了Java 8，HashMap 引入了红黑树来优化这个问题。当链表的长度超过一定阈值时，链表会被转换成红黑树，这样查询的时间复杂度可以维持在O(log n)，比链表的O(n)要好很多。

当链表长度超过默认阈值8，且数组长度大于等于64时，才会将链表转换为红黑树。如果数组长度小于64，即使链表长度超过8，HashMap会选择先进行数组扩容，而不是立即转换结构。这是因为扩容可以减少哈希碰撞的概率，可能比转换为树更有效。

另外，红黑树的结构相比链表，虽然查询效率高，但插入和删除操作更复杂，需要维护树的平衡，所以在节点较少时，链表的性能可能更好。因此，HashMap在节点减少到6时会转换回链表，这样可以避免在频繁插入和删除时反复转换带来的性能损耗。

总结一下，HashMap解决链表过长的问题主要通过两个方法：一是当链表长度超过阈值且数组容量足够大时，将链表转为红黑树；二是通过扩容数组来减少哈希碰撞，从而间接减少链表长度。这两种方法结合起来，保证了HashMap在大多数情况下的高效性能。

算法-数据结构基础1

一直想做一些自己的产品，记录下对前端知识的学习

Vue 是用于构建用户界面的 JavaScript 框架。

它基于标准 HTML、CSS 和 JavaScript 构建，并提供了一套声明式的、组件化的编程模型，帮助你高效地开发用户界面。

## 创建Vue项目

在创建 Vue 项目以前，我们需要先安装 [Node.js](https://nodejs.org/zh-cn)。

### 基于 Vite 创建

Vue 官网推荐使用 Vite 创建项目

```
shell

## 1.创建命令
npm create vue@latest

## 2.具体配置
## 配置项目名称
√ Project name: vue3_test
## 是否添加TypeScript支持
√ Add TypeScript?  Yes
## 是否添加JSX支持
√ Add JSX Support?  No
## 是否添加路由环境
√ Add Vue Router for Single Page Application development?  No
## 是否添加pinia环境
√ Add Pinia for state management?  No
## 是否添加单元测试
√ Add Vitest for Unit Testing?  No
## 是否添加端到端测试方案
√ Add an End-to-End Testing Solution? » No
## 是否添加ESLint语法检查
√ Add ESLint for code quality?  Yes
## 是否添加Prettiert代码格式化
√ Add Prettier for code formatting?  No
```

启动项目

```
shell

cd <your-project-name>
npm install
npm run dev
```

构建项目（当你准备将应用发布到生产环境时，运行）

```
shell

npm run build
```

### 基于 CLI 创建

> 备注：目前`vue-cli`已处于维护模式，官方推荐基于 `Vite` 创建项目。

```
shell

## 查看@vue/cli版本，确保@vue/cli版本在4.5.0以上
vue --version

## 安装或者升级你的@vue/cli 
npm install -g @vue/cli

## 执行创建命令
vue create vue_test

##  随后选择3.x
##  Choose a version of Vue.js that you want to start the project with (Use arrow keys)
##  > 3.x
##    2.x

## 启动
cd vue_test
npm run serve
```

## API

Vue 的组件可以按两种不同的风格书写：**选项式 API** 和 **组合式 API**。

### 选项式 API (Options API)

使用选项式 API，我们可以用包含多个选项的对象来描述组件的逻辑，例如 data、methods 和 mounted。选项所定义的属性都会暴露在函数内部的 this 上，它会指向当前的组件实例。

```
html

<script>
export default {
  // data() 返回的属性将会成为响应式的状态
  // 并且暴露在 `this` 上
  data() {
    return {
      count: 0
    }
  },

  // methods 是一些用来更改状态与触发更新的函数
  // 它们可以在模板中作为事件处理器绑定
  methods: {
    increment() {
      this.count++
    }
  },

  // 生命周期钩子会在组件生命周期的各个不同阶段被调用
  // 例如这个函数就会在组件挂载完成后被调用
  mounted() {
    console.log(`The initial count is ${this.count}.`)
  }
}
</script>

<template>
  <button @click="increment">Count is: {{ count }}</button>
</template>
```

### 组合式 API (Composition API)

通过组合式 API，我们可以使用导入的 API 函数来描述组件逻辑。在单文件组件中，组合式 API 通常会与

下面是使用了组合式 API 与

```
html

<script setup>
import { ref, onMounted } from 'vue'

// 响应式状态
const count = ref(0)

// 用来修改状态、触发更新的函数
function increment() {
  count.value++
}

// 生命周期钩子
onMounted(() => {
  console.log(`The initial count is ${count.value}.`)
})
</script>

<template>
  <button @click="increment">Count is: {{ count }}</button>
</template>
```

## 响应式基础

### ref 创建：基本类型的响应式数据

* \*\*作用：\*\*定义响应式变量。
* **语法：**`let xxx = ref(初始值)`。
* \*\*返回值：\*\*一个`RefImpl`的实例对象，简称`ref对象`或`ref`，`ref`对象的`value`**属性是响应式的**。
* **注意点：**
  + `JS`中操作数据需要：`xxx.value`，但模板中不需要`.value`，直接使用即可。
  + 对于`let name = ref('张三')`来说，`name`不是响应式的，`name.value`是响应式的。

```
html

<template>
  <div class="person">
    <h2>姓名：{{name}}</h2>
    <h2>年龄：{{age}}</h2>
    <button @click="changeName">修改名字</button>
    <button @click="changeAge">年龄+1</button>
    <button @click="showTel">点我查看联系方式</button>
  </div>
</template>

<script setup lang="ts" name="Person">
  import {ref} from 'vue'
  // name和age是一个RefImpl的实例对象，简称ref对象，它们的value属性是响应式的。
  let name = ref('张三')
  let age = ref(18)
  // tel就是一个普通的字符串，不是响应式的
  let tel = '13888888888'

  function changeName(){
    // JS中操作ref对象时候需要.value
    name.value = '李四'
    console.log(name.value)

    // 注意：name不是响应式的，name.value是响应式的，所以如下代码并不会引起页面的更新。
    // name = ref('zhang-san')
  }
  function changeAge(){
    // JS中操作ref对象时候需要.value
    age.value += 1 
    console.log(age.value)
  }
  function showTel(){
    alert(tel)
  }
</script>
```

### reactive 创建：对象类型的响应式数据

* **作用：**定义一个**响应式对象**（基本类型不要用它，要用`ref`，否则报错）
* **语法：**`let 响应式对象= reactive(源对象)`。
* \*\*返回值：\*\*一个`Proxy`的实例对象，简称：响应式对象。
* **注意点：**`reactive`定义的响应式数据是“深层次”的。

```
html

<template>
  <div class="person">
    <h2>汽车信息：一台{{ car.brand }}汽车，价值{{ car.price }}万</h2>
    <h2>游戏列表：</h2>
    <ul>
      <li v-for="g in games" :key="g.id">{{ g.name }}</li>
    </ul>
    <h2>测试：{{obj.a.b.c.d}}</h2>
    <button @click="changeCarPrice">修改汽车价格</button>
    <button @click="changeFirstGame">修改第一游戏</button>
    <button @click="test">测试</button>
  </div>
</template>

<script lang="ts" setup name="Person">
import { reactive } from 'vue'

// 数据
let car = reactive({ brand: '奔驰', price: 100 })
let games = reactive([
  { id: 'ahsgdyfa01', name: '英雄联盟' },
  { id: 'ahsgdyfa02', name: '王者荣耀' },
  { id: 'ahsgdyfa03', name: '原神' }
])
let obj = reactive({
  a:{
    b:{
      c:{
        d:666
      }
    }
  }
})

function changeCarPrice() {
  car.price += 10
}
function changeFirstGame() {
  games[0].name = '流星蝴蝶剑'
}
function test(){
  obj.a.b.c.d = 999
}
</script>
```

### ref 创建：对象类型的响应式数据

* 其实`ref`接收的数据可以是：**基本类型**、**对象类型**。
* 若`ref`接收的是对象类型，内部其实也是调用了`reactive`函数。

```
html

<template>
  <div class="person">
    <h2>汽车信息：一台{{ car.brand }}汽车，价值{{ car.price }}万</h2>
    <h2>游戏列表：</h2>
    <ul>
      <li v-for="g in games" :key="g.id">{{ g.name }}</li>
    </ul>
    <h2>测试：{{obj.a.b.c.d}}</h2>
    <button @click="changeCarPrice">修改汽车价格</button>
    <button @click="changeFirstGame">修改第一游戏</button>
    <button @click="test">测试</button>
  </div>
</template>

<script lang="ts" setup name="Person">
import { ref } from 'vue'

// 数据
let car = ref({ brand: '奔驰', price: 100 })
let games = ref([
  { id: 'ahsgdyfa01', name: '英雄联盟' },
  { id: 'ahsgdyfa02', name: '王者荣耀' },
  { id: 'ahsgdyfa03', name: '原神' }
])
let obj = ref({
  a:{
    b:{
      c:{
        d:666
      }
    }
  }
})

console.log(car)

function changeCarPrice() {
  car.value.price += 10
}
function changeFirstGame() {
  games.value[0].name = '流星蝴蝶剑'
}
function test(){
  obj.value.a.b.c.d = 999
}
</script>
```

### ref 对比 reactive

宏观角度看：

> 1. `ref`用来定义：**基本类型数据**、**对象类型数据**；
> 2. `reactive`用来定义：**对象类型数据**。

* 区别：

> 1. `ref`创建的变量必须使用`.value`（可以使用`volar`插件自动添加`.value`）。
>    >
>    > ![自动补充value](images/自动补充value.png)
> 2. `reactive`重新分配一个新对象，会**失去**响应式（可以使用`Object.assign`去整体替换）。

* 使用原则：

> 1. 若需要一个基本类型的响应式数据，必须使用`ref`。
> 2. 若需要一个响应式对象，层级不深，`ref`、`reactive`都可以。
> 3. 若需要一个响应式对象，且层级较深，推荐使用`reactive`。

### toRefs 与 toRef

* 作用：将一个响应式对象中的每一个属性，转换为`ref`对象。
* 备注：`toRefs`与`toRef`功能一致，但`toRefs`可以批量转换。
* 语法如下：

```
html

<template>
  <div class="person">
    <h2>姓名：{{person.name}}</h2>
    <h2>年龄：{{person.age}}</h2>
    <h2>性别：{{person.gender}}</h2>
    <button @click="changeName">修改名字</button>
    <button @click="changeAge">修改年龄</button>
    <button @click="changeGender">修改性别</button>
  </div>
</template>

<script lang="ts" setup name="Person">
  import {ref,reactive,toRefs,toRef} from 'vue'

  // 数据
  let person = reactive({name:'张三', age:18, gender:'男'})
	
  // 通过toRefs将person对象中的n个属性批量取出，且依然保持响应式的能力
  let {name,gender} =  toRefs(person)
	
  // 通过toRef将person对象中的gender属性取出，且依然保持响应式的能力
  let age = toRef(person,'age')

  // 方法
  function changeName(){
    name.value += '~'
  }
  function changeAge(){
    age.value += 1
  }
  function changeGender(){
    gender.value = '女'
  }
</script>
```

## 基础指令

在Vue中，指令都是以`v-`开头的，每个指令都是 JavaScript 表达式

### v-text 与 v-html

`v-text` 用于设置元素的文本内容，`v-html` 指令用于设置元素的HTML内容

```
html

<template>
  <p>{{ msg }}</p>
  <p v-text="msg"></p>
  <p v-html="msg"></p>
</template>

<script setup>
  import { ref } from 'vue';
  const msg = ref('<a href="http://www.baidu.com"> Welcome </a>');
</script>
```

v-text, v-html、{{ }} 的正确使用与区别

v-text 与 v-html 指令都可以更新页面元素的内容，不同的是，v-text 会将数据以字符串文本的形式更新，而 v-html 则会直接将数据作为 HTML 标签内容更新。

在更新数据时，{{ }} 表达式只会更新原本占位插值所在的数据内容，而 v-text 与 v-html 指令则更新整个标签内容。

### v-model

`v-model` 指令用于实现双向数据绑定，它允许在表单元素（如输入框、选择框等）和数据之间进行双向绑定，从而实现数据的自动更新和显示。

#### v-model 的修饰符

##### .lazy 修饰符

在上面示例中默认情况下，v-model 指令在每次 input 事件触发后会将输入框的值与响应式的msg进行同步，添加 `.lazy` 以后，则转变为失去焦点同步。

```
html

<template>
  {{ msg }}
  <div>
    双向绑定：<input v-model="msg" type="text"/>
  </div>
  <div>
    失去焦点后双向绑定：<input v-model.lazy="msg" type="text"/>
  </div>
</template>

<script setup>
  import { ref } from 'vue';
  const msg = ref('');
</script>
```

##### .number 修饰符

将用户输入的数据自动转换为数值类型

```
html

<template>

  <input v-model="num1" type="text"/>
  <br/>
  <input v-model="num2" type="text"/>
  <br/>
  {{ num1 + num2 }}
  <br/>

  <input v-model.number="num3" type="text"/>
  <br/>
  <input v-model.number="num4" type="text"/>
  <br/>
  {{ num3 + num4 }}

</template>

<script setup>
  import { ref } from 'vue';
  const num1 = ref('');
  const num2 = ref('');
  const num3 = ref('');
  const num4 = ref('');
</script>
```

以上示例中 `.number` 修饰符绑定的值会想加，而不是字符串拼接，如果不想要修饰符，可以使用以下方式

```
vue

{{ parseInt(num1) + parseInt(num2) }}
```

#### .trim 修饰符

将用户输入的数据自动去除首尾空格

```
html

<template>
  <p>{{ msg }}</p>
  <input type="text" v-model.trim="msg"/> <br/>
</template>

<script setup>
  import { ref } from 'vue';
  const msg = ref('');
</script>
```

### v-cloak

模板语法有一个缺点: 可能会出现闪烁问题，即页面数据可能还没加载渲染完成，就提前出现了两对{}。

实际应用中可能就是Vue实例中的数据。例如，通过发送异步请求获取来自网络(服务器)的数据，由于网络或者数据量大，需要一定的时间，这个时候Vue中的数据(Data)尚没有数据，就不会去渲染视图，那么在视图中会提前看到类似{{msg}的情况，这给用户的体验很不好，所以在数据尚未加载渲染完成时不要让类似{{msg}}出现，那么如何解决呢?可以使用v-cloak 指令来解决。

使用 v-cloak 指令要配合CSS样式一起使用否则不会生效。 通过CSS样式先设置为不显示，在数据流染完成之后就会自动修改displs值为显示。

```
html

<template>
  <div v-cloak>
    {{ message }}
  </div>
</template>

<script setup>
  import { ref,onMounted } from 'vue';
  const message = ref('123');
  onMounted(()=>{
    alert('挂载完毕')
  })
</script>

<style>
  [v-cloak] {
    display: none;
  }
</style>
```

### v-bind

v-bind 用来绑定标签上的属性（ src、href、title 等等） 或样式（style、class ）。

```
html

<img v-bind:src="imgUrl" alt="">
```

v-bind 可以简写成 :

```
html

<img :src="imgUrl" alt="">
```

修饰符

* camel - 将短横线命名的 attribute 转变为驼峰式命名。
* prop - 强制绑定为 DOM property (3.2+)。
* attr - 强制绑定为 DOM attribute (3.2+)。

示例

```
html


<img v-bind:src="imageSrc" />


<button v-bind:[key]="value"></button>


<img :src="imageSrc" />


<img :src />


<button :[key]="value"></button>


<img :src="'/path/to/images/' + fileName" />


<div :class="{ red: isRed }"></div>
<div :class="[classA, classB]"></div>
<div :class="[classA, { classB: isB, classC: isC }]"></div>


<div :style="{ fontSize: size + 'px' }"></div>
<div :style="[styleObjectA, styleObjectB]"></div>


<div v-bind="{ id: someProp, 'other-attr': otherProp }"></div>


<MyComponent :prop="someThing" />


<MyComponent v-bind="$props" />


<svg><a :xlink:special="foo"></a></svg>
```

### v-on

给元素绑定事件监听器。缩写：@

修饰符

* stop - 调用 event.stopPropagation()。
* prevent - 调用 event.preventDefault()。
* capture - 在捕获模式添加事件监听器。
* self - 只有事件从元素本身发出才触发处理函数。
* {keyAlias} - 只在某些按键下触发处理函数。
* once - 最多触发一次处理函数。
* left - 只在鼠标左键事件触发处理函数。
* right - 只在鼠标右键事件触发处理函数。
* middle - 只在鼠标中键事件触发处理函数。
* passive - 通过 { passive: true } 附加一个 DOM 事件。

Vue 全家桶 - 基础命令

之前的Idea正版激活码到期后，我来更新一下破解版的操作，此版本适应于 IDEA 2023.3，低版本可以使用30天无限重置激活，废话不多说，直接上破解教程。

## 下载破解包

链接: <https://pan.baidu.com/s/1OdSP8XSH6larmGpUMPuVpg>
提取码: w3u2
复制这段内容后打开百度网盘手机App，操作更方便哦

## 确认路径

此破解包安装后，会改变Mac系统的环境变量，且不能被删除（一旦破解包被误删， Idea启动就会报错），所以启动时一定确认好，我是将此破解包放到了IntelliJ IDEA.app 的包内容下

![image.png](https://blog.liushigong.cn/static/img/fa87e3de3969d6708b80af7529a9c8e0.image.webp)

## 修改破解包配置

### 修改 install.sh

![image.png](https://blog.liushigong.cn/static/img/d2f21644d2951630fbbb508cf683d046.image.webp)

将 BASE\_PATH 的路径，修改为上面环节确认的路径

```
sh

BASE_PATH="/Applications/IntelliJ IDEA.app/Contents/jetbra"
```

### 修改 idea.vmoptions

![image.png](https://blog.liushigong.cn/static/img/9be25916f052f4d9b077dcd9773eefad.image.webp)

将 -javaagent 路径修改为上面环节确认的路径

```
sh

-javaagent:/Applications/IntelliJ IDEA.app/Contents/jetbra/ja-netfilter.jar=jetbrains
```

## 安装破解包

新建终端，打开上面环节确认的路径

![image.png](https://blog.liushigong.cn/static/img/6be2db2398ee03bd4e2f5986da657054.image.webp)

启动脚本

```
sh

sudo bash ./install.sh
```

提示 `done. the "kill Dock" command can fix the crash issue.` 即为成功

![image.png](https://blog.liushigong.cn/static/img/567165e67810dc0372db4e184f555119.image.webp)

重启系统，命令`env`查看环境变量（重启以后的效果如下）：

![image.png](https://blog.liushigong.cn/static/img/430b77588fb8309e2f0014d1db5349dd.image.webp)

提示

**成功后，Mac 系统的环境变量需要重启才会生效**

部分小伙伴 Mac 系统执行脚本遇到如下错误：

`sed: RE error: illegal byte sequence`

执行以下命令以后即可。

```
sh

export LC_COLLATE='C'
export LC_CTYPE='C'
```

### 配置激活码

电脑重启以后，打开Idea，填入以下激活码激活即可。

```
6G5NXCPJZB-eyJsaWNlbnNlSWQiOiI2RzVOWENQSlpCIiwibGljZW5zZWVOYW1lIjoic2lnbnVwIHNjb290ZXIiLCJhc3NpZ25lZU5hbWUiOiIiLCJhc3NpZ25lZUVtYWlsIjoiIiwibGljZW5zZVJlc3RyaWN0aW9uIjoiIiwiY2hlY2tDb25jdXJyZW50VXNlIjpmYWxzZSwicHJvZHVjdHMiOlt7ImNvZGUiOiJQU0kiLCJmYWxsYmFja0RhdGUiOiIyMDI1LTA4LTAxIiwicGFpZFVwVG8iOiIyMDI1LTA4LTAxIiwiZXh0ZW5kZWQiOnRydWV9LHsiY29kZSI6IlBEQiIsImZhbGxiYWNrRGF0ZSI6IjIwMjUtMDgtMDEiLCJwYWlkVXBUbyI6IjIwMjUtMDgtMDEiLCJleHRlbmRlZCI6dHJ1ZX0seyJjb2RlIjoiSUkiLCJmYWxsYmFja0RhdGUiOiIyMDI1LTA4LTAxIiwicGFpZFVwVG8iOiIyMDI1LTA4LTAxIiwiZXh0ZW5kZWQiOmZhbHNlfSx7ImNvZGUiOiJQUEMiLCJmYWxsYmFja0RhdGUiOiIyMDI1LTA4LTAxIiwicGFpZFVwVG8iOiIyMDI1LTA4LTAxIiwiZXh0ZW5kZWQiOnRydWV9LHsiY29kZSI6IlBHTyIsImZhbGxiYWNrRGF0ZSI6IjIwMjUtMDgtMDEiLCJwYWlkVXBUbyI6IjIwMjUtMDgtMDEiLCJleHRlbmRlZCI6dHJ1ZX0seyJjb2RlIjoiUFNXIiwiZmFsbGJhY2tEYXRlIjoiMjAyNS0wOC0wMSIsInBhaWRVcFRvIjoiMjAyNS0wOC0wMSIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQV1MiLCJmYWxsYmFja0RhdGUiOiIyMDI1LTA4LTAxIiwicGFpZFVwVG8iOiIyMDI1LTA4LTAxIiwiZXh0ZW5kZWQiOnRydWV9LHsiY29kZSI6IlBQUyIsImZhbGxiYWNrRGF0ZSI6IjIwMjUtMDgtMDEiLCJwYWlkVXBUbyI6IjIwMjUtMDgtMDEiLCJleHRlbmRlZCI6dHJ1ZX0seyJjb2RlIjoiUFJCIiwiZmFsbGJhY2tEYXRlIjoiMjAyNS0wOC0wMSIsInBhaWRVcFRvIjoiMjAyNS0wOC0wMSIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQQ1dNUCIsImZhbGxiYWNrRGF0ZSI6IjIwMjUtMDgtMDEiLCJwYWlkVXBUbyI6IjIwMjUtMDgtMDEiLCJleHRlbmRlZCI6dHJ1ZX1dLCJtZXRhZGF0YSI6IjAxMjAyMjA5MDJQU0FOMDAwMDA1IiwiaGFzaCI6IlRSSUFMOi0xMDc4MzkwNTY4IiwiZ3JhY2VQZXJpb2REYXlzIjo3LCJhdXRvUHJvbG9uZ2F0ZWQiOmZhbHNlLCJpc0F1dG9Qcm9sb25nYXRlZCI6ZmFsc2V9-SnRVlQQR1/9nxZ2AXsQ0seYwU5OjaiUMXrnQIIdNRvykzqQ0Q+vjXlmO7iAUwhwlsyfoMrLuvmLYwoD7fV8Mpz9Gs2gsTR8DfSHuAdvZlFENlIuFoIqyO8BneM9paD0yLxiqxy/WWuOqW6c1v9ubbfdT6z9UnzSUjPKlsjXfq9J2gcDALrv9E0RPTOZqKfnsg7PF0wNQ0/d00dy1k3zI+zJyTRpDxkCaGgijlY/LZ/wqd/kRfcbQuRzdJ/JXa3nj26rACqykKXaBH5thuvkTyySOpZwZMJVJyW7B7ro/hkFCljZug3K+bTw5VwySzJtDcQ9tDYuu0zSAeXrcv2qrOg==-MIIETDCCAjSgAwIBAgIBDTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIwMTAxOTA5MDU1M1oXDTIyMTAyMTA5MDU1M1owHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMDEwMTkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCUlaUFc1wf+CfY9wzFWEL2euKQ5nswqb57V8QZG7d7RoR6rwYUIXseTOAFq210oMEe++LCjzKDuqwDfsyhgDNTgZBPAaC4vUU2oy+XR+Fq8nBixWIsH668HeOnRK6RRhsr0rJzRB95aZ3EAPzBuQ2qPaNGm17pAX0Rd6MPRgjp75IWwI9eA6aMEdPQEVN7uyOtM5zSsjoj79Lbu1fjShOnQZuJcsV8tqnayeFkNzv2LTOlofU/Tbx502Ro073gGjoeRzNvrynAP03pL486P3KCAyiNPhDs2z8/COMrxRlZW5mfzo0xsK0dQGNH3UoG/9RVwHG4eS8LFpMTR9oetHZBAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQUJNoRIpb1hUHAk0foMSNM9MCEAv8wSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBABqRoNGxAQct9dQUFK8xqhiZaYPd30TlmCmSAaGJ0eBpvkVeqA2jGYhAQRqFiAlFC63JKvWvRZO1iRuWCEfUMkdqQ9VQPXziE/BlsOIgrL6RlJfuFcEZ8TK3syIfIGQZNCxYhLLUuet2HE6LJYPQ5c0jH4kDooRpcVZ4rBxNwddpctUO2te9UU5/FjhioZQsPvd92qOTsV+8Cyl2fvNhNKD1Uu9ff5AkVIQn4JU23ozdB/R5oUlebwaTE6WZNBs+TA/qPj+5/we9NH71WRB0hqUoLI2AKKyiPw++FtN4Su1vsdDlrAzDj9ILjpjJKA1ImuVcG329/WTYIKysZ1CWK3zATg9BeCUPAV1pQy8ToXOq+RSYen6winZ2OO93eyHv2Iw5kbn1dqfBw1BuTE29V2FJKicJSu8iEOpfoafwJISXmz1wnnWL3V/0NxTulfWsXugOoLfv0ZIBP1xH9kmf22jjQ2JiHhQZP7ZDsreRrOeIQ/c4yR8IQvMLfC0WKQqrHu5ZzXTH4NO3CwGWSlTY74kE91zXB5mwWAx1jig+UXYc2w4RkVhy0//lOmVya/PEepuuTTI4+UJwC7qbVlh5zfhj8oTNUXgN0AOc+Q0/WFPl1aw5VV/VrO8FCoB15lFVlpKaQ1Yh+DVU8ke+rt9Th0BCHXe0uZOEmH0nOnH/0onD
```

![image.png](https://blog.liushigong.cn/static/img/0121ab5d9e0dcb40a4e6cc905869a413.image.webp)

激活日期到2025年8月，完美！

![image.png](https://blog.liushigong.cn/static/img/fab4e14a469a3b2e4160b4c2d1b27cf2.image.webp)

Mac IntelliJ IDEA 2023.3破解激活

我们思考这样一个问题，在互联网应用中，如果一张数据库的表中有1千万的数据量，某次需求调整，需要修改字段类型或者修改字段长度，或者 int 类型达到上限，你会怎么做？直接使用 `ALTER TABLE` 吗？

![image.png](https://blog.liushigong.cn/static/img/53a94247dfc782c4e07ed9bfd50e2e4c.image.webp)

## `ALTER TABLE` 问题分析

首先我们来分析一下，这个问题的本质就是对 mysql DDL 操作，虽然 MySQL 8.0.12 版本引入 `Instant DDL`（Instant Data Definition Language）允许在不阻塞读写（Online）的情况下，以毫秒级的速度修改表结构，当时在某些时候，还是会退回到最保守的 COPY 算法，例如：

* 修改数据类型
* 修改长度 (跨临界点，例如 varchar(255) 改成varchar(256))
* 修改字符集

COPY 算法

COPY 算法就是“复制数据”的过程。

当你要修改表结构时，MySQL 会生成一个临时表，把原表的数据一行行读出来，经过处理后再写入临时表，最后用临时表替换原表。

在使用 COPY 算法时，MySQL 在数据复制阶段，会给原表加上排他锁（Exclusive Metadata Lock）。这意味着在 DDL 执行期间，任何对原表的 `INSERT、UPDATE、DELETE` 操作都会被阻塞，直到 DDL 完成。

通过上面的分析，我们可以发现对于千万级的大表，直接使用 `ALTER TABLE` 会导致锁表，这个过程可能持续很长一段时间，这期间业务写入会堆积，连接池耗尽，最终导致整个服务不可用。

结合具体的场景来分析，如果是面向企业级的 TOB 系统，晚上系统是处于无人操作下，直接使用 `ALTER TABLE` 也不能说错。但是对于互联网的 TOC 应用是随时能访问的，对于高可用非常关注，所以我们需要另外的方案，这也是接下来我们的主题，数据迁移。

## 数据迁移

数据迁移是指把一批数据从一个数据库表迁移到另一个数据库表中。数据迁移的使用场景无非就是以下几种：

* 对某张表进行分库分表
* 数据库表中导致锁表的 DDL 操作
* 历史数据归档
* 需求调整产生的技术架构改变

当然数据迁移的前提是要以 **迁移的数据体量** 做考量的，不同的业务场景与不同的数据量，迁移的方案肯定是不一样的。如果只是几十万，都不需要搞那么复杂，直接导入导出 或者 写代码同步过来再做一下数据核对都能搞得定。

接下来我就以千万级数据量的大表为例，讲解下在业务无感知的情况下进如何行 **平滑迁移**。

### 迁移的数据类型

对于数据迁移的场景来说，主要包含两种数据的迁移类型，一个是开始迁移时的已存在数据的数据快照，也就是 **存量数据**，一个是程序运行时产生的新的数据，这部分数据就是 **增量数据**。

![image.png](https://blog.liushigong.cn/static/img/35f564f19beb0fe90773b3bf7f570c46.image.webp)

也就是我们在正式的数据迁移开始之前，需要定义个节点，作为存量数据的一致性数据快照，而在这个节点以后产生的 `insert` 数据，都是增量数据。在此处需要考虑一点，如果是 `update` 和 `delete` 操作的数据，不一定是存量也不一定是增量，要看他 `insert` 的时候是增量还是存量。

### 如何保障数据完整性的思考

在做数据迁移的时候，需要思考如何保障数据的完整性与一致性，怎么做到在不停机的情况下，将数据完整的迁移完成，例如上面描述的 `update` 和 `delete` 场景，都是需要去解决的问题。

其实最核心的解决处理就是在数据的读写上，那么我们就从 **读** 和 **写** 两步操作分析，首先是 **写** 处理：

* **数据实时性**：在开始平滑迁移后，需要保证旧系统和新系统数据的实时同步，直至完全切换到新系统。
* **insert 数据验证**：在双写的同时，需要有验证机制，例如定时查询每天的数据增量进行对比
* **update/delete 数据验证**：需要区别是增量数据还是存量数据的操作，进行单写或者双写。
* **存量数据的完整性**：存量数据在迁移的过程中需要确保所有数据都能准确的迁移到新表中，不能丢失数据。
* **存量数据数据验证**：存量数据迁移完成后，也是需要对存量数据进行验证。

接下来我们来分析下 **读** 操作的处理：

* **全量验证**：当写操作全部完成以后，我们再一次进行全量的验证，防止存量数据先读取在写入时，在并发下读取数据后数据产生了变更，导致最终的数据不一致的情况。
* **部分切流**：当全量数据么有问题以后，那么可以通过自定义开关控制，进行部分切流，如果有灰度环境可以在灰度上进行控制，在试验阶段，要保证尽可能的对业务影响最小
* **全量切流**：当部分切流验证没有问题后，就会进行全量切流，我们需要可以支持回滚，当一旦有问题，可以快速的做回滚。

![image.png](https://blog.liushigong.cn/static/img/fac0f24d2a7c37d230084533fdb4cb49.image.webp)

### 增量数据的迁移

首先我们来思考对于增量数据的迁移，处理的方案来说都是基于 **双写机制**，数据双写是指同时进行新表和老表的写入，让新表与老表中同时都有增量数据，这么做的主要原因一方面是让新数据不丢，另外也是随时可以做回滚。

![image.png](https://blog.liushigong.cn/static/img/b3c11ae0236355e6edebfbeff536a2f0.image.webp)

双写的方案有很多，主要有以下这么几种：

* **工具增量双写**：在增量双写过程中，我们可以用 `canal`、`flink cdc` 等这种增量数据更新的工具来进行双写，他们的原理就是在原库写入数据后，基于产生的binlog，自动把数据再写入新库。这个方案的好处是无需编码，支持各种异构的数据库，也支持表结构的各种不一致的转换。缺点就是依赖工具，需要单独部署，同时有可能存在失败或者延迟的风险，一旦过程中出问题了，中间的数据可能会丢失。
* **代码实现双写**：我们可以自己编码，在代码中实现双写，即写完旧库之后再写入新库。如果是同一个数据库的不同表的话，这里还可以借助事务保证数据的完整性。但是一般都是跨表或者跨库，所以这里需要考虑好重试的机制。优点就是代码实现的可靠性更强一些，逻辑可以自己定制，缺点就是需要写代码，比较复杂。
* **中间件异步双写**：其本质还是编码，但是我们不是直联数据库做写入，而是在写入新库的时候，通过 MQ 来做异步写入。

注意

编码方案中，在新表写入时，序列化ID 需要与旧表保持一致，而不是自增处理。

#### 增量数据更新

在数据迁移过程中，业务数据是会发生不断地变化的，前面的双写我们提了，只把新发生的 `insert` 当做增量。那这个过程中，如果发生了`update` 或者 `delete` 要怎么办呢？

其实这里就需要我们在编码的时候进行控制，在 `update/delete` 的时候，判断一下这个数据是增量的还是存量的，其实就是判断新表中是否有这个数据，如果有，就需要做双写更新，如果没有，就说明这是个存量数据，只更新旧表就行了。不用担心他们会丢，因为后续我们会做存量同步，这部分更新也会带过来的。

```
java

publiv viod update(){
    if(增量数据){
        同时更新旧表和新表();
    }else{
        更新旧表();    
    }
}
```

#### 增量数据核对

在数据迁移过程中，做数据核对是至关重要的。尤其是增量数据，因为增量数据需要双写，双写是有可能失败的，所以需要有一定的机制可以发现这些双写失败的数据。

在做数据核对方面，有很多方式，从编码上来说，像通过定时，单独服务批量查询数据，通过 MD5 加密进行对比；又或者加载到内存中转为字符串通过哈希code对比；建议去做旁路验证，流程是可以通过旁路（可以起一个异步线程，或者通过MQ等）进行一次新库的读取，然后把拿到的结果和旧库的读取作比对，当发现不一致的时候，报警报出来，进行人工核对。

还可以借助工具，把新表和旧表的数据做逐条核对，确保他们的数据是一模一样。

* mysqldiff：MySQL官方mysql-utilities工具集的一部分，用于对比不同数据库间的表结构或数据结构差异
* pt-table-checksum：Percona Toolkit核心工具，专为线上主从数据一致性高效校验设计，支持自动分块控制对业务影响
* Navicat：提供数据同步、结构比对等可视化核对功能
* GitHub check-data工具：支持双库数据CRC32校验及复核机制，可输出详细差异报告

### 存量数据的迁移

做好了增量数据迁移和核对之后，我们就可以把存量的数据也迁移过来了。存量数据的迁移也有很多方案，比如自己写代码去扫表迁移，也可以通过工具做存量的数据同步。

* **DataX**：是阿里云 DataWorks数据集成 的开源版本，在阿里巴巴集团内被广泛使用的离线数据同步工具/平台。DataX 实现了包括 MySQL、Oracle、OceanBase、SqlServer、Postgre、HDFS、Hive、ADS、HBase、TableStore(OTS)、MaxCompute(ODPS)、Hologres、DRDS, databend 等各种异构数据源之间高效的数据同步功能。
* **canal**：要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费
* **Kettle**：是一款开源的ETL（Extract, Transform, Load）工具，主要用于数据的抽取、转换和加载。通过Kettle，我们可以轻松地进行数据迁移，实现不同数据库之间的数据传输和整合。它允许你管理来自不同数据库的数据，通过提供一个图形化的用户环境来进行操作。
* **Flink CDC**（Change Data Capture，即数据变更抓取）是一个开源的数据库变更日志捕获和处理框架，它可以实时地从各种数据库（如MySQL、PostgreSQL、Oracle、MongoDB等）中捕获数据变更并将其转换为流式数据。Flink CDC 可以帮助实时应用程序实时地处理和分析这些流数据，从而实现数据同步、数据管道、实时分析和实时应用等功能。

对于存量的数据迁移，需要考虑几个问题：

1、**不能丢数据**：迁移过程中，数据的完整性需要保证，不能中间丢了数据  
2、**断点能续传**：迁移过程中，如果失败了，需要能够在失败处做断点续传，确保不重复不丢失。  
3、**不要覆盖增量数据**：存量数据在迁移的过程中，新表中是有增量数据的，所以，需要确保存量数据的迁移，不会覆盖到这部分已经存在的增量数据。  
4、**迁移性能要好**：存量数据一般都是量很大，所以迁移过程中的性能也是至关重要的。

为了保证数据不丢和能实现断点续传，我们可以在旧表中增加一个字段，来标识出这条记录是否已经被迁移过，这样我们就可以在一条记录迁移成功后，把他的这个标识改了，这样如果中间失败了，我们就知道哪些数据迁移过，哪些数据没迁移过，就只迁移这些没迁移的就行了。

有了这个标识之后，我们就可以做分批的迁移了，因为我们可以通过标记清晰的知道还有多少数据没迁移，可以方便的做分批处理和扫描。

为了不在存量数据迁移的过程中把增量数据覆盖了，这里就需要在 `insert` 之前做一个检查，判断下这个数据新表中是否已经存在了，已经存在的话，要么就是增量数据双写写进来的，要么就是上一次同步的时候失败了导致旧表的标记没来及更新，不管怎么样，直接认为这条记录已经迁移成功了就行。

提示

对于一些单表的操作，可以通过主键索引来保证唯一性，防止覆盖。

至于性能的问题，我们就需要通过各种手段来解决了，例如批处理，多线程、MQ等。

#### 存量数据核对

存量数据迁移完成以后，需要进行数据核对，与增量数据类似，就不过多描述了。

当增量与存量数据都完成以后，进行一次 **全量数据的验证**，主要防止增量数据期间产生的数据不一致的情况，验证完成后下一步就是要做读写切流了，要把读请求从老表切流到新表了，在这之前就需要确保是否可以切流。

## 数据切流

在确保数据都完成迁移之后，我们可以做切流了，一般是先把读请求切流到新的表上，跑一段时间，确保存量和增量数据都没问题，在切流写请求。

### 切流读新

在切流的时候，我们要逐步进行，比如根据可以基于用户ID的尾号，或者其他的业务字段来做切流，从10%，到20%，再到30%，50%，最后逐步放量到100%，最好有灰度的机制验证。

![image.png](https://blog.liushigong.cn/static/img/594ca72dd5866c6345f0124585cecbd8.image.webp)

这一步在切流之后，我们的旁路的策略也需要跟着调整。因为切流后读新表了，那么旁路就需要切换到读旧表。

### 切流写新

这是最后一步了，这一步也是唯一的一步不能回滚的步骤了，开始写切流。

![image.png](https://blog.liushigong.cn/static/img/06c0aa3badf5e74f0d0e3a8d5528be5b.image.webp)

这一步我们就要把双写去掉，完全变成单写了，这一步之后，旧表的数据就不会再做更新了。所以，在这一步之前，要做好足够的验证和核对，确保数据无误之后，在做谨慎操作。建议先切流1%，或者0.1%这样的比例切流。

### 开关&监控

在上述切流的这个过程中，我们就需要在代码中提前放好开关，然后在上线之后，只需要通过推开关就可以做控制流程的切换了。可以把这些开关配置到配置中心上，然后可以做到动态切换即可。

```
java

if(flag){
  // ...
  
}else{
  // ...
  
}
```

这里的 flag 就是个开关，这个值你可以通过配置中心进行动态的调整。

然后，除了核对以外，监控也至关重要，需要做好足够的监控来帮助我们提前的去发现问题。而且监控和核对是要覆盖了整个迁移流程的，一定不能裸奔！

比如在做旧表的读的时候，我们可以通过旁路（可以起一个异步线程，或者通过MQ等）进行一次新库的读取，然后把拿到的结果和旧库的读取作比对，当发现不一致的时候，报警报出来，进行人工核对。

到此我们整个平滑迁移就已经完成了。