Go不是纯粹的面向对象语言，和传统的面向对象编程有区别，所以说Go语言支持面向对象编程特性是比较准确的。

Go语言基于结构体struct来实现OOP特性，通过type和struct关键字声明结构体，格式如下：

    type 类型名 struct { // 类型名在同一个包内不能重复
      字段1 字段1类型 // 字段名必须唯一
      字段2 字段2类型
    }

结构体从本质上讲是一种自定义的数据类型，只不过这种数据类型比较复杂，可以认为结构体是一种聚合类型。

## 结构体实例化

声明结构体变量再赋值：

    type Student struct {
      sid    int      // 字段首字母小写，类似private，其它包不能使用
      course []string // 选修课程
    }
    func main() {
    // 声明一个结构体对象，值类型，默认开辟空间，字段赋予零值
    var s Student
    fmt.Println("s:", s) // s: {0 []}
    // 访问结构体成员使用点号 . 操作符
    fmt.Println(s.sid) // 0
    // 更改成员变量值
    s.sid = 1001
    fmt.Println(s.sid) // 1001
    // 方式2：键值对赋值
    s2 := Student{sid: 1002, course: []string{"chinese", "math"}}
    fmt.Println(s2)
    // 方式3：多值赋值
    s3 := Student{1003, []string{"chinese", "math"}}
    fmt.Println(s3)
    }

实例化之&结构体：

    func initSid(s *Student) {
    s.sid = 1001 // 其实是(*s).sid = 1001
    }
    func main() {
    s := Student{course: []string{"chinese", "math"}}
    initSid(&s)
    fmt.Println(s) // {1001 [chinese math]}
    s2 := &Student{course: []string{"chinese", "math"}}
    initSid(s2)
    fmt.Println(s2) // &{1001 [chinese math]}
    }

实例化之new(结构体)：

    func main() {
    s := new(Student) // 等同于 &Student{}
    fmt.Println(s)    // &{0 []}
    }

### 模拟构造函数

Go语言没有构造函数，但可以使用结构体初始化过程来模拟实现构造函数（首字母大写）。

    // 自定义工厂函数，返回局部变量地址
    func NewStudent(sid int, course []string) *Student {
    return &Student{
    sid:    sid,
    course: course}
    }
    func main() {
    s := NewStudent(1001, []string{"math", "english"})
    fmt.Println(s) // &{1001 [math english]}
    }

## 方法接收器

Go语言中的方法（Method）是一种作用于特定类型变量的函数，这种特定类型变量叫做接收者（Receiver）。方法与函数的区别是，函数不属于任何类型，方法属于特定类型。

    func (s Student) learn() {
    fmt.Printf("%d 正在学习...", s.sid)
    }
    func main() {
    s := NewStudent(1001, []string{"math", "english"})
    s.learn()
    }

接收者是指针类型：

    type Player struct {
    Name        string
    HealthPoint int
    }
    func NewPlayer(name string, hp int) *Player {
    return &Player{
    name,
    hp,
    }
    }
    func (p *Player) attack() {
    fmt.Printf("%s 发起攻击！\n", p.Name)
    }
    func (p *Player) attacked() {
    fmt.Printf("%s 被攻击！\n", p.Name)
    p.HealthPoint -= 10
    fmt.Println("HealthPoint:", p.HealthPoint)
    }
    func main() {
    player := NewPlayer("张三", 100)
    player.attack()
    player.attacked()
    }

## 匿名字段

结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段称为匿名字段。

    type Person struct {
    string // 其实是string string
    int    // 其实是int int
    }
    func main() {
    p := Person{
    "张三",
    18,
    }
    fmt.Println(p.string, p.int) // 张三 18
    }

结构体也可以作为匿名字段使用：

    type Addr struct {
    province string
    city     string
    }
    type Person struct {
    string
    int
    Addr // 其实是Addr Addr
    }
    func main() {
    p := Person{
    "张三",
    18,
    Addr{"广东", "深圳"},
    }
    fmt.Println(p.Addr.province, p.city) // 广东 深圳
    }

当结构体中有和匿名字段相同字段时，采用外层优先访问原则。

## 包和封装

每个目录一个包，main包包含可执行入口。

为结构定义的方法必须放在同一个包内，可以是不同文件。

## 结构体继承

    // Animal 动物
    type Animal struct {
    name string
    }
    func (a *Animal) eat() {
    fmt.Printf("%s is eating！\n", a.name)
    }
    // Dog 类型
    type Dog struct {
    Kind    string
    *Animal // 通过嵌套匿名结构体实现继承，直接写类型，没有字段名
    }
    func (d *Dog) bark() {
    fmt.Printf("%s is barking ~\n", d.name)
    }
    func main() {
    d := &Dog{
    Kind: "金毛",
    Animal: &Animal{ // 注意嵌套的是结构体指针
    name: "旺财",
    },
    }
    d.eat()
    d.bark()
    }

## 结构体标签

    type Stu struct {
    Name string json:&quot;name&quot; // 结构体标签
    Age  int    json:&quot;-&quot;    // 表示不参与序列化
    }
    func main() {
    stuStruct := Stu{Name: "张三", Age: 18}
    // 序列化
    jsonStuStruct, _ := json.Marshal(stuStruct)
    fmt.Println(string(jsonStuStruct)) // {"name":"张三"}
    // 反序列化
    var StuStruct Stu
    err := json.Unmarshal(jsonStuStruct, &StuStruct)
    if err != nil {
    return
    }
    fmt.Println(StuStruct) // {张三 0}
    }


Go语言面向对象

## ihavenotv

是一个免费提供纪录片在线观看的网站，免费提供超过4000部高质量纪录片。

该网站从不同的来源精心挑选了高质量的纪录片视频，提供了丰富多样的纪录片，涵盖了科学、自然、历史、艺术、文化、社会、采访、人物传记等各个领域的纪录片，所有的纪录片都能在线免费观看，网站上的纪录片都是英文的。

## 网站地址

ihavenotv：[https://ihavenotv.com/](https://ihavenotv.com/)


ihavenotv-免费在线观看纪录片网站

两台或以上数据库实例，通过二进制日志，实现数据的“同步"关系。

## 主从复制

实例准备：两台以上MySQL实例，server_id不同。

### 主库

- 主库开启二进制日志
- 主库建立复制用户：grant replication slave on *.* to repl@'10.0.0.%' identified by '123';
- 主库备份：mysqldump -A --master-data=2 --single-transaction -R -E --triggers >/tmp/full.sql
- 告知从库复制信息，找到复制开始起点：`grep "\-- CHANGE MASTER TO" /tmp/full.sql`

### 从库

- 恢复到从库：mysql </tmp/full.sql
- 从帮助中获取change master to语句进行修改：mysql> help change master to
- 执行CHANGE MASTER TO命令
- 从库开启专用复制线程：start slave;
- 验证主从状态：show slave status \G

## 主从复制原理

### 文件

主库：binlog文件

从库：

- relay-log文件：存储接收的binlog，默认存储在从库数据目录下，手工定义：relay_log_basename=/data/3307/data/relay-bin
- master.info：连接主库信息，已经接收binlog位置点信息。默认存储在从库数据目录下，也可将配置信息写入到表中：master_info_repository = TABLE
- relay-log.info：记录⽂件复制进度，下⼀个事件从什么位置开始。默认存储在从库数据目录下，也可以手工定义：relay_log_info_repository = TABLE

### 线程

主库：Binlog_dump_Thread，作用是用来接收从库请求，并将binlog投递给从库。显示正在运行线程：show processlist;

从库:

- IO线程：请求binlog，接收binlog
- SQL线程：回放relay日志

### 原理

1. S：change master to信息写入到master.info，执行start slave;启动IO线程和SQL线程
2. S：IO线程读取master.info信息，获取主库信息连接主库
3. M：分配DUMP线程，专门和IO线程通信
4. S：IO线程根据master.info记录的binlog文件名和position号，请求主库新日志
5. M：DUMP线程接收请求，截取日志，返回给IO线程
6. S：IO线程将收到日志存储到TCP/IP缓存，立即返回ACK给主库，主库工作完成
7. S：IO线程将缓存数据，存储到relay-log日志文件，并更新master.info，IO线程工作结束
8. S：SQL线程读取relay-log.info，获取上次执行到的位置点
9. S：SQL线程向后执行新的relay-log，再次更新relay-log.info

小细节：
S：参数relay_log_purge=ON，会定期删除用用过的relay-log
M：DUMP线程会实时监控主库binlog变化，如果有新变化，发信号给从库，IO线程再请求

### 主从监控

主库方面：

- show processlist;
- show slave hosts;

从库方面：

- show slave status \G

## MHA

全称：Master High Availability，是Perl语言写的MySQL故障切换方案，故障切换时间10-30s。

MHA由node和manager组成；

- node：所有数据库机器都要部署，master是一个node，slave也是一个node
- manager：相当于server，会对node进行管理，配置检查，binlog和relay-log获取，执行切换任务等。可以单独部署在server上（tj），单独部署可以管理多套主从架构。也可以部署在某个slave上，如果部署在slave上，那么该slave就无法被升级为主库

### 部署MHA高可用框架

配置关键程序软连接：

    ln -s /app/database/mysql/bin/mysqlbinlog /usr/bin/mysqlbinlog
    ln -s /app/database/mysql/bin/mysql /usr/bin/mysql

配置各节点互信：

    rm -rf /root/.ssh
    ssh-keygen
    cd /root/.ssh
    mv id_rsa.pub authorized_keys
    scp -r /root/.ssh 10.0.0.52:/root 
    scp -r /root/.ssh 10.0.0.53:/root

各节点安装Node：

    yum install perl-DBD-MySQL -y
    rpm -ivh mha4mysql-node-0.58-0.el7.centos.noarch.rpm

安装Manager：

    yum install -y perl-Config-Tiny epel-release perl-Log-Dispatch perl-Parallel-ForkManager perl-Time-HiRes
    rpm -ivh mha4mysql-manager-0.58-0.el7.centos.noarch.rpm

创建MHA专用监控管理用户：grant all privileges on *.* to mha@'10.0.0.%' identified by 'mha';

## Atlas

Atlas中间件是由奇虎360基于MySQL官方中间件mysql-proxy二次开发实现，能够对数据库进行读写分离、分库分表配置，配合MHA架构进行高可用环境搭建有较好效果。

## MyCAT

分布式架构


MySQL架构

InnoDB架构图：
![](https://thumbsnap.com/i/joGnTeTY.png)
查看优化器算法开关：select @@optimizer_switch;

修改，例如：`set global optimizer_switch='batched_key_access=on';`，退出客户端，重新进入客户端查看修改结果。

设置方法也可以使用优化器提示Hints的形式，或者设置my.cnf配置文件。

## 索引自优化

### AHI

Adaptive Hash Index，即自适应哈希索引，作用是自动评估热内存索引page，生成Hash索引表，帮助InnoDB快速读取索引页，加快索引读取的速度，相当于索引的索引。

### Change Buffer

比如insert、update、delete数据，对于聚簇索引会立即更新，而对于辅助索引不是实时更新的。

在InnoDB内存结构中，加入了Insert Buffer，现在版本叫Change Buffer。Change Buffer功能是临时缓冲辅助索引需要的数据更新。当我们需要査询新insert的数据，会在内存中进行merge合并操作，此时辅助索引就是最新的。

## 优化器算法

### ICP

Index Condition Pushdown，即索引下推，作用是解决联合索引只能部分应用的情况。为了减少没必要的数据页被扫描，将不走索引的条件，在engine层取数据之前先做二次过滤，一些无关数据就会被提前过滤掉。

例如，有一个索引index(a,b,c)，查询语句：select * from t where a= and c=，在server层先做a列过滤条件的索引优化，在将c列的过滤下推到engine层先做过滤，再加载数据页。

### MRR

Multi-Range Read，是优化器将随机磁盘IO转化为顺序磁盘IO以降低查询过程中IO开销的一种手段，是一种回表优化。

回表是指先走二级索引，找到对应的主键值，再根据主键值再到聚集索引当中，拿到一行行的数据。由于二级索引上引用的主键值不一定是有序的，因此有可能造成大量的随机IO，如果回表前把主键值给排下序，那么在回表时就可以用顺序IO取代原本的随机IO。

具体可参考：[https://mariadb.com/kb/en/multi-range-read-optimization/](https://mariadb.com/kb/en/multi-range-read-optimization/)

### SNLJ

Index Nested-Loop Join，INLJ算法，即嵌套循环连接，常用于连接小表或是一个表中数据量不大的子集。具体实现方式是先遍历外表，对于每一行，再遍历内表，找到符合连接条件的行，返回结果。

Simple Nested-Loop Join，即SNLJ算法。具体实现方式是驱动表全表扫描取出所有字段，逐行匹配被驱动表，而被驱动表未使用到索引，每次匹配页都进行一次全表扫描。

### BNL

Block Nested-Loop Join，即块嵌套循环连接。该算法使用了join buffer作为优化，其中由参数join_buffer_size设定join_buffer大小，默认值是256K。

在A表和B表关联条件匹配时，不再一次一次进行循环，而是采用一次性将驱动表的关联值和非驱动表匹配.一次性返回结果。BNLJ算法主要优化了CPU消耗，减少了IO次数。

### BKA

Batched Key Access，主要是用来优化非驱动表关联列有辅助索引，相当于BNL+MRR的功能。要启动KBA算法优化，先设置：`set global optimizer_switch='mrr=on,mrr_cost_based=off,batched_key_access=on';`，退出客户端，重新进入客户端查看修改结果。


MySQL索引自优化算法

## 开读

开读（Open Books Hong Kong）先导计划由香港中文大学、香港城市大学和香港大学三间高等教育院校的图书馆与出版社联合发起。这是香港首个开放取用（open access）图书计划，旨在开放学术成果、创建健康公平的知识传播生态。

本计划于2024年7月17日推出由三间大学出版社出版的九本中文图书，免费开放予公众阅读、下载、取用和传播。图书内容涵盖历史、哲学、宗教、法学、人类学、性别研究等人文社科多个领域。数月后将有第二批图书加入计划，向公众开放。

开读计划不仅展示了香港高等教育院校致力于“开放知识”的决心，亦是中文学术图书开放取用的新尝试。计划目前在探索期，希望未来能持续开放优质中文著作，与世界分享香港出版的研究成果。近年来，教资会积极推动开放取用，期待本计划能够推动学界积极参与全球知识开放运动，并让社会大众受益。

作为中国和世界间的桥樑，香港可以发挥促进跨文化交流的作用。作为计划发起人之一，香港中文大学图书馆馆长文奈尔（Benjamin Meunier）指出，虽然开放取用在香港尚属起步阶段，但未来可期 。他说：“开读计划充分体现了香港的前瞻性思维，为全球读者提供了一个知识宝库。”

书籍下载不设门槛，文件格式是PDF为主，电子书资源清晰！

## 网站地址

开读：[https://openbookshongkong.com/](https://openbookshongkong.com/)


开读 香港首个开放取用图书计划 免费电子书

这里是 aboss.top 的自留地。写了十几年野路子代码，攒了些摸爬滚打的经验，做成系列课程慢慢讲；也留了一小块地方，记记代码之外的胡思乱想。