使用golang理解mysql的两阶段提交

文章源于一个问题：如果我们现在有两个mysql实例，在我们要尽量简单地完成分布式事务，怎么处理？

场景重现

比如我们现在有两个数据库，mysql3306和mysql3307。这里我们使用docker来创建这两个实例：

# mysql3306创建命令

docker run -d -p 3306:3306 -v /Users/yjf/Documents/workspace/mysql-docker/my3306.cnf:/etc/mysql/mysql.conf.d/mysqld.cnf -v /Users/yjf/Documents/workspace/mysql-docker/data3306:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql-3307 mysql:5.7

# msyql3306的配置：

[mysqld]

pid-file     = /var/run/mysqld/mysqld.pid

socket          = /var/run/mysqld/mysqld.sock

datadir          = /var/lib/mysql

server-id = 1

log_bin = mysql-bin

binlog_format = ROW

expire_logs_days = 30

# mysql3307创建命令

docker run -d -p 3307:3306 -v /Users/yjf/Documents/workspace/mysql-docker/my3307.cnf:/etc/mysql/mysql.conf.d/mysqld.cnf -v /Users/yjf/Documents/workspace/mysql-docker/data3307:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql-3307 mysql:5.7

# msyql3307的配置：

[mysqld]

pid-file     = /var/run/mysqld/mysqld.pid

socket          = /var/run/mysqld/mysqld.sock

datadir          = /var/lib/mysql

server-id = 2

log_bin = mysql-bin

binlog_format = ROW

expire_logs_days = 30

在mysql3306中

我们有一个user表

create table user (

    id int,

    name varchar(10),

    score int

);

insert into user values(1, "foo", 10)

在mysql3307中，我们有一个wallet表。

create table wallet (

    id int,

    money float

);

insert into wallet values(1, 10.1)

我们可以看到，id为1的用户初始分数（score）为10，而它的钱，在wallet中初始钱（money）为10.1。

现在假设我们有一个操作，需要对这个用户进行操作：每次操作增加分数2，并且增加钱数1.2。

这个操作需要很强的一致性。

思考

两阶段提交

这里是一个分布式事务的概念，我们可以使用2PC的方法进行保证事务

2PC的概念如图所示，引入一个资源协调者的概念，由这个资源协调者进行事务协调。

第一阶段，由这个资源协调者对每个mysql实例调用prepare命令，让所有的mysql实例准备好，如果其中由mysql实例没有准备好，协调者就让所有实例调用rollback命令进行回滚。如果所有mysql都prepare完成，那么就进入第二阶段。

第二阶段，资源协调者让每个mysql实例都调用commit方法，进行提交。

mysql里面也提供了分布式事务的语句XA。

用单个实例的事务行不行

等等，这个两阶段提交和我们的事务感觉也差不多，都是进行一次开始，然后执行，最后commit，mysql为什么还要专门定义一个xa的命令呢？于是我陷入了思考...

思考不如实操，于是我用golang写了一个使用mysql的事务实现的“两阶段提交”:

package main

import (

     "database/sql"

     "fmt"

     _ "github.com/go-sql-driver/mysql"

     "github.com/pkg/errors"

)

func main() {

     var err error

     // db1的连接

     db1, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/hade1")

     if err != nil {

          panic(err.Error())

     }

     defer db1.Close()

     // db2的连接

     db2, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3307)/hade2")

     if err != nil {

          panic(err.Error())

     }

     defer db2.Close()

     // 开始前显示

     var score int

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     var money float64

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

     tx1, err := db1.Begin()

     if err != nil {

          panic(errors.WithStack(err))

     }

     tx2, err := db2.Begin()

     if err != nil {

          panic(errors.WithStack(err))

     }

     defer func() {

          if err := recover(); err != nil {

               fmt.Printf("%+v\n", err)

               fmt.Println("=== call rollback ====")

               tx1.Rollback()

               tx2.Rollback()

          }

          db1.QueryRow("select score from user where id = 1").Scan(&score)

          fmt.Println("user1 score:", score)

          db2.QueryRow("select money from wallet where id = 1").Scan(&money)

          fmt.Println("wallet1 money:", money)

     }()

     // DML操作

     if _, err = tx1.Exec("update user set score=score+2 where id =1"); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = tx2.Exec("update wallet set money=money+1.2 where id=1"); err != nil {

          panic(errors.WithStack(err))

     }

    // panic(errors.New("commit before error"))

     // commit

     fmt.Println("=== call commit ====")

     err = tx1.Commit()

     if err != nil {

          panic(errors.WithStack(err))

     }

    // panic(errors.New("commit db2 before error"))

     err = tx2.Commit()

     if err != nil {

          panic(errors.WithStack(err))

     }

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

}

我这里已经非常小心地在defer中recover错误信息，并且执行了rollback命令。

如果我在commit命令之前的任意一个地方调用了panic(errors.New("commit before error")) 那么命令就会进入到了rollback这里，就会把两个实例的事务都进行回滚。

通过结果我们可以看到，分数和钱数都没有改变。这个是ok的。

但是如果我在db2的commit之前触发了panic，那么这个命令进入到了rollback中，但是db1已经commit了，db2还没有commit，这个时候会出现什么情况？

非常可惜，我们看到了这里的score增长了，但是money没有增长，这个就说明无法做到事务一致性了。

回到mysql的xa

那么还要回归到2PC，mysql为2PC的实现增加了xa命令，那么使用这个命令我们能不能避免这个问题呢？

同样，我用golang写了一个使用xa命令的代码

package main

import (

     "database/sql"

     "fmt"

     "strconv"

     "time"

     _ "github.com/go-sql-driver/mysql"

     "github.com/pkg/errors"

)

func main() {

     var err error

     // db1的连接

     db1, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/hade1")

     if err != nil {

          panic(err.Error())

     }

     defer db1.Close()

     // db2的连接

     db2, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3307)/hade2")

     if err != nil {

          panic(err.Error())

     }

     defer db2.Close()

     // 开始前显示

     var score int

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     var money float64

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

     // 生成xid

     xid := strconv.FormatInt(time.Now().Unix(), 10)

     fmt.Println("=== xid:" + xid + " ====")

     defer func() {

          if err := recover(); err != nil {

               fmt.Printf("%+v\n", err)

               fmt.Println("=== call rollback ====")

               db1.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))

               db2.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))

          }

          db1.QueryRow("select score from user where id = 1").Scan(&score)

          fmt.Println("user1 score:", score)

          db2.QueryRow("select money from wallet where id = 1").Scan(&money)

          fmt.Println("wallet1 money:", money)

     }()

     // XA 启动

     fmt.Println("=== call start ====")

     if _, err = db1.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // DML操作

     if _, err = db1.Exec("update user set score=score+2 where id =1"); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec("update wallet set money=money+1.2 where id=1"); err != nil {

          panic(errors.WithStack(err))

     }

     // XA end

     fmt.Println("=== call end ====")

     if _, err = db1.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // prepare

     fmt.Println("=== call prepare ====")

     if _, err = db1.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // panic(errors.New("db2 prepare error"))

     if _, err = db2.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // commit

     fmt.Println("=== call commit ====")

     if _, err = db1.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // panic(errors.New("db2 commit error"))

     if _, err = db2.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

}

首先看成功的情况：

一切完美。

如果我们在prepare阶段抛出panic，那么结果如下:

证明在第一阶段出现异常是可以回滚的。

但是如果我们在commit阶段抛出panic:

我们发现，这里的分数增加了，但是money却没有增加。

那么这个xa和单个事务有什么区别呢？我又陷入了深深的沉思...

xa的用法不对

经过在技术群（全栈神盾局）请教，讨论之后，发现这里对2pc的两个阶段理解还没到位，这里之所以分为两个阶段，是强调的是每个阶段都会持久化，就是第一个阶段完成了之后，每个mysql实例就把第一个阶段的请求实例化了，这个时候不管是mysql实例停止了还是其他问题，每次重启的时候都会重新回复这个commit。

我们把这个代码的rollback去掉，假设commit必须成功。

package main

import (

     "database/sql"

     "fmt"

     "strconv"

     "time"

     _ "github.com/go-sql-driver/mysql"

     "github.com/pkg/errors"

)

func main() {

     var err error

     // db1的连接

     db1, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/hade1")

     if err != nil {

          panic(err.Error())

     }

     defer db1.Close()

     // db2的连接

     db2, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3307)/hade2")

     if err != nil {

          panic(err.Error())

     }

     defer db2.Close()

     // 开始前显示

     var score int

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     var money float64

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

     // 生成xid

     xid := strconv.FormatInt(time.Now().Unix(), 10)

     fmt.Println("=== xid:" + xid + " ====")

     defer func() {

          if err := recover(); err != nil {

               fmt.Printf("%+v\n", err)

               fmt.Println("=== call rollback ====")

               // db1.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))

               // db2.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))

          }

          db1.QueryRow("select score from user where id = 1").Scan(&score)

          fmt.Println("user1 score:", score)

          db2.QueryRow("select money from wallet where id = 1").Scan(&money)

          fmt.Println("wallet1 money:", money)

     }()

     // XA 启动

     fmt.Println("=== call start ====")

     if _, err = db1.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // DML操作

     if _, err = db1.Exec("update user set score=score+2 where id =1"); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec("update wallet set money=money+1.2 where id=1"); err != nil {

          panic(errors.WithStack(err))

     }

     // XA end

     fmt.Println("=== call end ====")

     if _, err = db1.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // prepare

     fmt.Println("=== call prepare ====")

     if _, err = db1.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // panic(errors.New("db2 prepare error"))

     if _, err = db2.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // commit

     fmt.Println("=== call commit ====")

     if _, err = db1.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     panic(errors.New("db2 commit error"))

     if _, err = db2.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

}

这个时候，我们停掉程序（停掉mysql的链接），使用xa recover可以发现，db2的xa事务还留在db2中了。

我们在控制台直接调用xa commit '1585644880' 还能继续把这个xa事务进行提交。

这下money就进行了提交，又恢复了一致性。

所以呢，我琢磨了一下，我们写xa的代码应该如下：

package main

import (

     "database/sql"

     "fmt"

     "log"

     "strconv"

     "time"

     _ "github.com/go-sql-driver/mysql"

     "github.com/pkg/errors"

)

func main() {

     var err error

     // db1的连接

     db1, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/hade1")

     if err != nil {

          panic(err.Error())

     }

     defer db1.Close()

     // db2的连接

     db2, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3307)/hade2")

     if err != nil {

          panic(err.Error())

     }

     defer db2.Close()

     // 开始前显示

     var score int

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     var money float64

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

     // 生成xid

     xid := strconv.FormatInt(time.Now().Unix(), 10)

     fmt.Println("=== xid:" + xid + " ====")

     defer func() {

          if err := recover(); err != nil {

               fmt.Printf("%+v\n", err)

               fmt.Println("=== call rollback ====")

               db1.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))

               db2.Exec(fmt.Sprintf("XA ROLLBACK '%s'", xid))

          }

          db1.QueryRow("select score from user where id = 1").Scan(&score)

          fmt.Println("user1 score:", score)

          db2.QueryRow("select money from wallet where id = 1").Scan(&money)

          fmt.Println("wallet1 money:", money)

     }()

     // XA 启动

     fmt.Println("=== call start ====")

     if _, err = db1.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec(fmt.Sprintf("XA START '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // DML操作

     if _, err = db1.Exec("update user set score=score+2 where id =1"); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec("update wallet set money=money+1.2 where id=1"); err != nil {

          panic(errors.WithStack(err))

     }

     // XA end

     fmt.Println("=== call end ====")

     if _, err = db1.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     if _, err = db2.Exec(fmt.Sprintf("XA END '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // prepare

     fmt.Println("=== call prepare ====")

     if _, err = db1.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // panic(errors.New("db2 prepare error"))

     if _, err = db2.Exec(fmt.Sprintf("XA PREPARE '%s'", xid)); err != nil {

          panic(errors.WithStack(err))

     }

     // commit

     fmt.Println("=== call commit ====")

     if _, err = db1.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {

          // TODO: 尝试重新提交COMMIT

          // TODO: 如果还失败，记录xid，进入数据恢复逻辑，等待数据库恢复重新提交

          log.Println("xid:" + xid)

     }

     // panic(errors.New("db2 commit error"))

     if _, err = db2.Exec(fmt.Sprintf("XA COMMIT '%s'", xid)); err != nil {

          log.Println("xid:" + xid)

     }

     db1.QueryRow("select score from user where id = 1").Scan(&score)

     fmt.Println("user1 score:", score)

     db2.QueryRow("select money from wallet where id = 1").Scan(&money)

     fmt.Println("wallet1 money:", money)

}

就是第二阶段的commit，我们必须设定它一定会“成功”，如果有不成功的情况，那么就需要记录下不成功的xid，有一个数据恢复逻辑，重新commit这个xid。来保证最终一致性。

binlog

其实我们使用binlog也能看出一些端倪

# 这里的mysql-bin.0003替换成为你当前的log

SHOW BINLOG EVENTS in 'mysql-bin.000003';


## XA的binlog

| mysql-bin.000003 | 1967 | Anonymous_Gtid |         1 |        2032 | SET @@SESSION.GTID_NEXT= 'ANONYMOUS'                                               |

| mysql-bin.000003 | 2032 | Query          |         1 |        2138 | XA START X'31353835363338363233',X'',1                                             |

| mysql-bin.000003 | 2138 | Table_map      |         1 |        2190 | table_id: 108 (hade1.user)                                                         |

| mysql-bin.000003 | 2190 | Update_rows    |         1 |        2252 | table_id: 108 flags: STMT_END_F                                                    |

| mysql-bin.000003 | 2252 | Query          |         1 |        2356 | XA END X'31353835363338363233',X'',1                                               |

| mysql-bin.000003 | 2356 | XA_prepare     |         1 |        2402 | XA PREPARE X'31353835363338363233',X'',1                                           |

| mysql-bin.000003 | 2402 | Anonymous_Gtid |         1 |        2467 | SET @@SESSION.GTID_NEXT= 'ANONYMOUS'                                               |

| mysql-bin.000003 | 2467 | Query          |         1 |        2574 | XA COMMIT X'31353835363338363233',X'',1

## 非xa的事务

| mysql-bin.000003 | 2574 | Anonymous_Gtid |         1 |        2639 | SET @@SESSION.GTID_NEXT= 'ANONYMOUS'                                               |

| mysql-bin.000003 | 2639 | Query          |         1 |        2712 | BEGIN                                                                              |

| mysql-bin.000003 | 2712 | Table_map      |         1 |        2764 | table_id: 108 (hade1.user)                                                         |

| mysql-bin.000003 | 2764 | Update_rows    |         1 |        2826 | table_id: 108 flags: STMT_END_F                                                    |

| mysql-bin.000003 | 2826 | Xid            |         1 |        2857 | COMMIT /* xid=67 */

我们很明显可以看到两阶段提交中是有两个GTID的，生成一个GTID就代表内部生成一个事务，所以第一个阶段prepare结束之后，第二个阶段commit的时候就持久化了第一个阶段的内容，并且生成了第二个事务。当commit失败的时候，最多就是第二个事务丢失，第一个事务实际上已经保存起来了了（只是还没commit）。

而非xa的事务，只有一个GTID，在commit之前任意一个阶段出现问题，整个事务就全部丢失，无法找回了。所以这就是mysql xa命令的机制。

总结

看了一些资料，原来mysql从5.7之后才真正实现了两阶段的xa。当然这个两阶段方式在真实的工程中的使用其实很少的，xa的第一定律是避免使用xa。工程中会有很多方式来避免这种分库的事务情况。

不过，不妨碍掌握了mysql的xa，在一些特定的场合，我们也能完美解决问题。

使用golang理解mysql的两阶段提交的更多相关文章

  1. 全网最牛X的！！！ MySQL两阶段提交串讲

    目录 一.吹个牛 二.事务及它的特性 三.简单看下两阶段提交的流程 四.两阶段写日志用意? 五.加餐:sync_binlog = 1 问题 六.如何判断binlog和redolog是否达成了一致 七. ...

  2. 聊一聊 MySQL 中的数据编辑过程中涉及的两阶段提交

    MySQL 数据库中的两阶段提交,不知道您知道不?这篇文章就简单的聊一聊 MySQL 数据库中的两阶段提交,两阶段提交发生在数据变更期间(更新.删除.新增等),两阶段提交过程中涉及到了 MySQL 数 ...

  3. flink-----实时项目---day07-----1.Flink的checkpoint原理分析 2. 自定义两阶段提交sink（MySQL） 3 将数据写入Hbase（使用幂等性结合at least Once实现精确一次性语义） 4 ProtoBuf

    1.Flink中exactly once实现原理分析 生产者从kafka拉取数据以及消费者往kafka写数据都需要保证exactly once.目前flink中支持exactly once的sourc ...

  4. MySQL binlog 组提交与 XA(两阶段提交)

    1. XA-2PC (two phase commit, 两阶段提交 ) XA是由X/Open组织提出的分布式事务的规范(X代表transaction; A代表accordant?).XA规范主要定义 ...

  5. MySQL binlog 组提交与 XA(分布式事务、两阶段提交)【转】

    概念: XA(分布式事务)规范主要定义了(全局)事务管理器(TM: Transaction Manager)和(局部)资源管理器(RM: Resource Manager)之间的接口.XA为了实现分布 ...

  6. MySQL binlog 组提交与 XA(两阶段提交)--1

    参考了网上几篇比较靠谱的文章 http://www.linuxidc.com/Linux/2015-11/124942.htm http://blog.csdn.net/woqutechteam/ar ...

  7. MySQL源码之两阶段提交

    在双1的情况下,两阶段提交的过程 环境准备:mysql 5.5.18, innodb 1.1 version配置: sync_binlog=1 innodb_flush_log_at_trx_comm ...

  8. MySQL两阶段提交

    参数介绍 innodb_flush_log_at_trx_commit 0: 每隔1s,系统后台线程刷log buffer,也就是把redo日志刷盘,这里会调用fsync,所以可能丢失最后1s的事务. ...

  9. 基于两阶段提交的分布式事务实现(UP-2PC)

    引言:分布式事务是分布式数据库的基础性功能,在2017年上海MySQL嘉年华(IMG)和中国数据库大会(DTCC2018)中作者都对银联UPSQL Proxy的分布式事务做了简要介绍,受限于交流形式难 ...

随机推荐

  1. javascript中你可能遇到的隐式调用

    前言 不知道用隐式调用来形容是否确切,其行为总是隐藏在背后,时不时出来露脸一下,作用貌似不大,但是了解一下还是有用处的,保不准在你的使用下大有作为.所谓的隐式调用简单来说就是自动调用一些方法,而这些方 ...

  2. 课题：html5图像羽化（不规则区域羽化，feather，html5羽化）

    下午搜索了一堆相关文章,没有找到符合要求的. 对一张图片应用不规则区域的羽化,该怎么做呢? 首先去查了下 羽化的原理,然而没有什么用, 然后就开始从表现层去研究怎么模拟? idea 1: blur滤镜 ...

  3. CSS 图像拼合技术（雪碧图）

    1.css 图像拼合 图像拼合就是单个图像的集合. 有许多图像的网页可能需要很长的时间来加载和生成多个服务器的请求. 使用图像拼合会降低服务器的请求数量,并节省带宽. 代码如下: <!docty ...

  4. Nuxt简单使用Google/Baidu Analyze

    博客地址: https://www.seyana.life/post/17 具体账号注册方法和绑定方法可以去到官网下,都有相应的指南, 一般设置也比较简单,只需要把对应js代码添加到head中即可, ...

  5. （27）ASP.NET Core .NET标准REST库Refit

    1.简介 Refit是一个受到Square的Retrofit库(Java)启发的自动类型安全REST库.通过HttpClient网络请求(POST,GET,PUT,DELETE等封装)把REST AP ...

  6. 06 Linux 的常用命令

    Linux 刚面世时并没有图形界面,所有的操作全靠命令完成,如 磁盘操作.文件存取.目录操作.进程管理.文件权限 设定等 在职场中,大量的 服务器维护工作 都是在 远程 通过 SSH 客户端 来完成的 ...

  7. mysql 学习日记 悲观和乐观锁

    理解  悲观锁就是什么事情都是需要小心翼翼,生怕弄错了出大问题, 一般情况下 "增删改" 都是有事务在进行操作的,但是 "查" 是不需要事务操作的, 但是凡事没 ...

  8. 在k3d上快速安装Istio，助你在本地灵活使用K8S！

    作者丨Mitsuyuki Shiiba 原文链接: https://dev.to/bufferings/tried-k8s-istio-in-my-local-machine-with-k3d-52g ...

  9. libfastcommon总结（二）从文件中加载配置信息

    头文件为ini_file_reader.h 主要接口 IniContext iniContext;//定义配置文件信息 iniLoadFromFile();//加载文件为结构化配置信息    iniG ...

  10. linux入门系列18--Web服务之Apache服务1

    前面系列文章讲解了Linux下通过文件传输.文件共享.邮件系统来分享和获取资源,本文讲解网络资源获取和共享的另外一种形式,通过Apache服务程序来提供Web服务. 本文先讲解目前主流的Web服务程序 ...