Nexus 是一个用于专门搭建 Maven 仓库的软件，除了作为 Maven 仓库，它还能够作为 Docker 镜像仓库、Yum 仓库等等。

Nexus 部署

deploy.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: nexus
  name: nexus
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nexus
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: nexus
    spec:
      initContainers:
        - name: volume-mount-hack
          image: busybox:latest
          command:
            - sh
            - '-c'
            - 'chown -R 200:200 /nexus-data'
          volumeMounts:
            - name: nexus-data
              mountPath: /nexus-data
      containers:
      - image: sonatype/nexus3:3.37.3
        name: nexus
        ports:
          - containerPort: 8081
        env:
          - name: INSTALL4J_ADD_VM_PARAMS
            value: "-Xms2703m -Xmx2703m -XX:MaxDirectMemorySize=2703m -Djava.util.prefs.userRoot=${NEXUS_DATA}/javaprefs"
        resources:
          limits:
            cpu: 2000m
            memory: 2048Mi      
          requests:
            cpu: 2000m
            memory: 2048Mi
        volumeMounts:
            - name: nexus-data
              mountPath: /nexus-data
      volumes:
      - name: nexus-data
        # 自行修改挂载类型，不修改则需创建对应PV和PVC👇
        persistentVolumeClaim:
          claimName: nexus-data
  
---
apiVersion: v1
kind: Service
metadata:
  name: nexus
  labels:
    app: nexus
spec:
  type: NodePort
  ports:
    - name: nexus
      port: 8081
      targetPort: 8081
      protocol: TCP
  selector:
    app: nexus

部署后，在容器内部获取 admin 密码

1

echo $(cat /nexus-data/admin.password)

默认仓库说明

• maven-central：中央仓库，默认从 https://repo1.maven.org/maven2/ 拉取 jar 包
• maven-releases：私库发行 jar，建议将设置改为 Allow redeploy
• maven-snapshots：私库快照 jar，即库中的 jar 均为调试版本
• maven-public：仓库分组，把上面三个仓库组合在一起对外提供服务，在本地 maven 的 settings.xml 文件或项目的 pom.xml 文件设置为该仓库地址，即可调用

仓库类型说明

• group：仓库组，起到了聚合的作用，在该组中的仓库都可以通过该组的 URL 进行访问
• hosted：私有仓库，顾名思义，用来存储自己的 jar 包
• snapshot：快照仓库
• release：本地项目的正式版本仓库
• proxy：代理，Nexus 的 maven-central 就是这种类型，代理地址为 https://repo1.maven.org/maven2/ ，默认会去该地址下拉取 jar 包
• central：中央仓库

新增代理仓库

创建仓库选择 maven2(proxy) 类型

添加到 maven-public

Maven 配置使用私服

要在本地 Maven 在私服拉取 jar 的方式有两种：

• settings.xml：全局配置模式
• pom.xml：项目独享模式

如果两种方式都配置了，那么以 pom.xml 文件配置为准。

当我们通过 Maven 使用 Nexus 的 maven-public 的时候，会按照以下方式顺序访问：

1. 本地仓库

2. 私服 maven-releases

3. 私服 maven-snapshots

4. 远程阿里 maven 仓库

5. 远程中央仓库

通过 settings.xml 文件配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<!-- servers块中添加用户认证信息 -->
<server>
   <id>nexus</id>
   <username>admin</username>
   <password>changeme</password>
</server>
<!-- mirrors块中添加maven-public信息 -->
<mirror>
   <!-- 唯一标识符 -->
   <id>nexus</id> 
   <!-- 名称 -->
   <name>cqm maven</name>
   <!-- maven-public地址 -->
   <url>http://192.168.159.11:35826/repository/maven-public/</url>
   <!-- *指的是访问任何仓库都使用我们的私服，可设置为central等等 -->
   <mirrorOf>*</mirrorOf>
</mirror>

也可以设置为阿里的

1
2
3
4
5
6

<mirror>
   <id>alimaven</id>
   <name>aliyun maven</name>
   <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
   <mirrorOf>central</mirrorOf>
</mirror>

通过 pom.xml 文件配置

1
2
3
4
5
6
7
8
9
10
11
12
13

<repositories>
    <repository>
        <id>mnexus</id>
        <name>cqm nexus</name>
        <url>http://192.168.159.11:35826/repository/maven-public/</url>
        <releases>
            <enabled>true</enabled>
        </releases>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>

同样也可以设置为阿里的

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<repositories>
   <repository>
      <id>alimaven</id>
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
      <releases>
         <enabled>true</enabled>
      </releases>
      <snapshots>
         <enabled>true</enabled>
         <updatePolicy>always</updatePolicy>
         <checksumPolicy>fail</checksumPolicy>
      </snapshots>
   </repository>
</repositories>

使用 Maven 批量向 Nexus 上传

首先需要将 .m2/repository 下的相应 jar 包和 pom 文件 cp 出来，再进行 deploy。

1
2

# -DrepositoryId 参数调用了 settings.xml 中 servers 块的账号密码进行认证
find . -name "*.jar" | awk '{ gsub("\.jar$","",$0); print "mvn deploy:deploy-file -Dfile="$0".jar -DpomFile="$0".pom -Dpackaging=jar -DrepositoryId=nexus -Durl=\"http://nexus-path\""}'	

MySQL 是一款关系型数据库管理系统。

一、MySQL基础

1.1 安装MySQL

docker-compose

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

version: '3.8'
services:
  db:
    image: mysql:5.7.35
    command: --default-authentication-plugin=mysql_native_password
    restart: always
    ports:
      - 3306:3306
    environment:
      MYSQL_ROOT_PASSWORD: toortoor
    
  adminer:
    image: adminer:latest
    restart: always
    ports:
      - 8080:8080

1.2 基础SQL语句

1. 刷新权限

1

flush privileges;

2. 数据库基本操作

1
2
3
4
5
6

-- 创建
create database [if not exists] `db_name`;
-- 删除
drop database [if exists] `db_name`;
-- 使用
use `db_name`;

3. 表基本操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

-- 创建
create table [if not exists] `table_name`;
-- 删除
drop table [if exists] `table_name`;
-- 查看
describe `table_name`;
-- 创建一个学生表
create table if not exists `students`(
    -- 创建id列，数据类型为4位的int类型，不允许为空，自增 
    `id` int(4) not null auto_increment comment '学号',
    -- 创建name列，数据类型为30位的varchar类型，不允许为空，默认值为匿名
    `name` varchar(30) not null default '匿名' comment '姓名',
    `pwd` varchar(20) not null default '123456' comment '密码',
    `gender` varchar(2) not null default '女' comment '性别',
    -- 创建birthday列，datetime类型，默认为空
    `brithday` datetime default null comment '出生日期',
    `address` varchar(100) default null comment '家庭住址',
    `email` varchar(50) default null comment '邮箱',
    -- 设置主键，一般一个表只有一个主键
    primary key(`id`)
)
-- 设置引擎
engine=innodb
-- 默认编码
default charset=utf8;

4. 修改表

1
2
3
4
5
6
7
8
9
10

-- 修改表名称
alter table `table_name` rename as new_`table_name`;
-- 增加字段
alter table `table_name` add age int(10);
-- 修改约束
alter table `table_name` modify age varchar(10);
-- 重命名字段
alter table `table_name` change age new_age int(10);
-- 删除字段
alter table `table_name` drop age;

5. 查看创建语句

1
2

show create database `db_name`;
show create table `table_name`;

1.3 引擎INNODB和MYISAM区别

不同引擎在文件上的区别

• innodb：
  • *.frm：表结构定义文件
  • ibdata1：数据文件
• mysiam：
  • *.frm：表结构定义文件
  • *.MYD：数据文件
  • *.MYI：索引文件

二、MySQL数据操作

2.1 外键

外键就是一个表的某一列去引用另一个表的某一列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

-- 该示例为students中的grade_id列引用grade中的grade_id列
create table `grade`(
    `grade_id` int(10) not null auto_increment comment '年级'
    primary key(`grade_id`)
)engine=innodb default charset=utf8

create table `students`(  
    `id` int(4) not null auto_increment comment '学号',
    `name` varchar(30) not null default '匿名' comment '姓名',
    `grade_id` int(10) not null comment '年级',
    primary key(`id`),
    -- 定义外键
    key `FK_grade_id` (`grade_id`),
    -- 给外键添加约束
    constraint `FK_grade_id` foreign key (`grade_id`) references `grade` (`grade_id`)
)engine=innodb default charset=utf8

如果要给已经存在的表添加外键

1

alter table `table_name` add constraint `FK_name` foreign key (`列名称`) references `引用的表名` (`引用的列名称`)

删除外键

1

alter table `table_name` drop foreign key 'FK_name'

2.2 DML数据操纵语言

2.2.1 insert

1
2
3
4

insert into `table_name`(`字段1`,`字段2`,`字段3`) values('值1'),('值2'),('值3');
insert into `students`(`name`) values('cqm'),('lwt');
-- 字段可以省略，但后面的值必须一一对应
insert into `students`(`name`,`pwd`,`email`) values('lwt','111','lwt@qq.com');

2.2.2 update

1
2
3
4
5
6
7

-- 如果不指定条件，那么会修改所有的值
update `table_name` set `字段`='值' where 条件;
-- 条件可以是 =|<|>|!=|between|and|or 等等
update `students` set `name`='handsome_cqm' where `id`=1;
update `students` set `name`='cqm' where `name`='handsome_cqm'
update `students` set `name`='newlwt',`email`='new@qq.com' where `name`='lwt';
update `students` set `name`='cqm' where id between 1 and 2;

2.2.3 delete

1
2
3
4

delete from `table_name` where 条件;
delete from `students` where `id`=1;
-- 清空表
truncate `table_name`;

delete 和 truncate 区别：

• 都可以清空表，都不会删除表结构
• truncate 可以重置自增列，且不会影响事务
• delete 清空表后，如果引擎是 innodb，重启数据库自增列就会变回1，因为是存储在内存中的；如果引擎是 myisam，则不会，因为是存储在文件中的

2.3 DQL数据库查询语言

2.3.1 select

1. 查询所有数据

1

select * from `table_name`;

2. 查询某列数据

1

select `name`,`gander` from `students`;

3. 给字段结果起别名

1

select `name` as '姓名',`gender` as '性别' from `students`;

4. concat 函数

1

select concat('姓名：',`name`) from `students`;

5. 去重

1

select distinct `字段` from `table_name`

6. 批量操作数据

1

select `score`+1 as `new_score` from `table_name`;

2.3.2 where

1. 逻辑运算符运用

1
2
3

select `score` from `table_name` where `score` >= 95 and `score` <= 100;
select `score` from `table_name` where `score` between 95 and 100;
select `score` from `table_name` where not `score` != 95 and `score` != 100;

2. 模糊查询

查找花名册中姓陈的名字

1
2
3
4

-- %:匹配一个或多个字符
-- _:匹配一个字符
select `name` from `table_name` where `name` like '陈%';
select `name` from `table_name` where `name` like '陈_明';

查找特定学号的信息

1

select `name` from `table_name` where `id` in (1,2,3);

查找地址为空或不空的同学

1
2

select `name` from `table_name` where `address` is null;
select `name` from `table_name` where `address` is not null;

2.3.3 联表查询

联表查询包括：

• inner（内连接）：如果表中有至少一个匹配，则返回行
• left（外连接）：即使右表中没有匹配，也从左表返回所有的行
• right（外连接）：即使左表中没有匹配，也从右表返回所有的行
• full（外连接）：只要其中一个表中存在匹配，则返回行

inner 实际就是取两个表的交集，例如有两个表，一个表有学生的基本信息，另一个表有学生的成绩，两个表都有学生的学号列，那么就可以联合起来查询

1

select `name`,`subjectno`,`score` from `students` inner join `result` where student.id = result.id

left 假设学生表中有 ccc 这么一个学生，但成绩表里没有 ccc 学生的成绩，如果使用了左连接，左表是学生表，右表是成绩表，那么也会返回 cqm 学生的值，显示为空

right 相反，如果成绩表里有个 ddd 学生的成绩，但学生表里没有这个学生的信息，如果使用了右连接，左表是学生表，右表是成绩表，那么也会返回 ddd 学生的成绩，注意这时候就看不到 ccc 学生的成绩信息了，因为左表中没有 ccc 学生的成绩信息

通过联表查询就可以查出缺考的同学

查询参加考试了的同学信息

1

select distinct `name` from `students` right join `result` on students.id = result.id where `score` is not null;

查询参加了考试的同学以及所对应的学科成绩

2.3.4 where和on的区别

在进行联表查询的时候，数据库都会在中间生成一张临时表，在使用外连接时，on 和 where 区别如下：

• on 条件是在生成临时表时使用的条件，它不管 on 中的条件是否为真，都会返回左边表中的记录。
• where 条件是在临时表生成好后，再对临时表进行过滤的条件。这时已经没有 left join 的含义（必须返回左边表的记录）了，条件不为真的就全部过滤掉。
• 如果是 inner join，则无区别

2.3.5 自连接

自连接实际上就是一张表与自己连接，将一张表拆为两张表

原表

父类表

子类表

自查询结果

2.3.6 分页和排序

排序 order by

• desc：降序
• asc：升序

1
2

-- 语法
order by desc|asc

查询语文成绩并排序

分页 limit

1
2

-- 语法
limit 起始值,页面显示多少条数据

打印第一页语文成绩

打印第二页数学成绩

分页和排序配合起来就可以查询学生的前几名成绩，例如语文成绩前三名

2.3.7 子查询

本质上就是在判断语句里嵌套一个查询语句，例如要查询所有语文成绩并降序排序，可以通过联表查询和子查询两种方式实现

2.4 聚合函数

2.4.1 count

count 函数用于计数，例如查询有多少学生

1

select count(`name`) from students;

函数内所带的参数不同，背后运行也不同：

• count(字段)：会忽略空值，不计数
• count(*)：不会忽略空值
• count(1)：不会忽略空值
• 从效率上看：如果查询的列为主键，那么 count(字段) 比 count(1) 快，不为主键则反之；如果表中只有一列，则 count(*) 最快

2.4.2 sum

顾名思义，用于求和，例如查询所有成绩之和

1

select sum(`score`) as '总分' from result

2.4.3 avg

1

select avg(`score`) as '平均分' from result

2.4.4 max和min

1

select max(`score`) as '最高分' from result

1

select min(`score`) as '最低分' from result

查询所有科目的平均分、最高分和最低分

1
2
3
4
5
6

select subjectname, avg(studentresult), max(studentresult), min(studentresult)
from `result`
inner join `subject`
on `result`.subjectno = `subject`.subjectno
-- 定义字段进行分组
group by result.subjectno;

通过分组后的次要条件，查询平均分大于 80 分的科目

1
2
3
4
5
6
7

select subjectname, avg(studentresult) as 平均分
from `result`
inner join `subject`
on `result`.subjectno = `subject`.subjectno
group by `result`.subjectno
-- 分组后的次要条件
having 平均分 > 80;

2.5 MD5加密

在数据库中，密码等敏感信息都不会以明文的形式存储的，可以通过md5 进行加密

1
2

-- 更新密码以达成加密
update students set pwd=md5(pwd);

1
2

-- 插入的时候就进行加密
insert into students values(1, 'cqm', md5('12345'))

2.6 事务

事务就是一系列 SQL 语句，要么全部执行，要么全部不执行。

事务的特性（ACID）：

• 原子性（Atomicity）：所有操作要么全部成功，要么全部失败
• 一致性（Consistency）：事务的执行的前后数据的完整性保持一致
• 隔离性（Isolation）：一个事务执行的过程中，不受到别的事务的干扰
• 持久性（Durability）：事务一旦结束，就会持久到数据库

隔离所导致的一些问题：

• 脏读：一个事务读取到了另一个事务没提交的数据
• 不可重复读：一个事务的多次查询结果不同，是因为查询期间数据被另一个事务提交而修改了
• 虚读：一个事务A在进行修改数据的操作时，另一个事务B插入了新的一行数据，而对于事务A来看事务B添加的那行就没有做修改，就发生了虚读

1. 事务关闭自动提交

1

set autocommit = 0;

2. 事务开启

1

start transaction;

3. 事务提交

1

commit;

4. 事务回滚

1

rollback;

5. 事务结束

1

set autocommit = 1;

6. 保存点

1
2
3
4
5
6

-- 添加保存点
savepoint 保存点名称
-- 回滚到保存点
rollback to savepoint 保存点名称
-- 删除保存点
release savepoint 保存点名称

2.7 索引

索引是帮助 MySQL 高效获取数据的数据结构。

索引的分类：

• 主键索引（primary key）：只有一列可以作为主键，且主键的值不可重复，一般用于用户ID之类的
• 唯一索引（unique key）：唯一索引可以有多个，且值唯一
• 常规索引（key）：例如一个表中的数据经常用到，就可以添加个常规索引
• 全文索引（fulltext）：快速定位数据

1. 查看某个表的所有索引

1

show index from `table_name`;

2. 添加全文索引

1

alter table `table_name` add fulltext index `index_name`(`要添加索引的字段名`);

3. 添加常规索引

1
2

-- 这样会给表中某个字段的数据全部都添加上索引，在数据量大的时候可以提高查询效率
create index `id_table_name_字段名` on `table_name`('字段名');

索引使用原则：

• 并不是索引越多越好
• 不要对进程变动的数据添加索引
• 数据量小的表不需要索引
• 索引一般用于常查询的字段上

2.8 权限管理

在 MySQL 中，用户表为 mysql.user，而权限管理其实都是在该表上操作。

1. 创建用户

1
2
3
4
5
6

-- host可以为以下的值
-- %:允许所有ip连接
-- localhost:只允许本地连接
-- 192.168.88.%:只允许给网段连接
-- 192.168.88.10:只允许该ip连接
create user 'user_name'@'host' identified by 'user_password';

2. 修改当前用户密码

1

set password = password('new_password');

3. 修改指定用户密码

1

set password for user_name = password('new_password');

4. 重命名

1

rename user user_name to new_user_name;

5. 授权

1
2

-- 权限:select、insert、delete等等，所有权限则为all
grant 权限 on `db_name`.`table_name` to 'user_name'@'host';

6. 授予某个用户部分权限

1

grant select,insert on mysql.user to 'cqm'@'%';

7. 给某个用户授予全部数据库的权限

1
2

-- 基本权限都有，但不会给grant权限
grant all privileges on *.* to 'cqm'@'%';

8. 删除用户

1

drop user 'user_name'@'host';

9. 取消权限

1

revoke 权限 on `db_name`.`table_name` from 'user_name'@'host';

10. 查询用户权限

1

show grants for 'user_name'@'host';

2.9 备份

备份文件都是以 .sql 为后缀的文件。

1. 导出

1
2
3
4
5

# -d:要操作的数据库
# -h:指定主机
# -P:指定端口
# --all-databases:操作所有数据库
mysqldump -uroot -ppassword -d db1_name db2_name > db_backup.sql

2. 导入

1

mysqldump -uroot -ppassword -d db_name < db_backup.sql

三、MySQL配置

3.1 主从同步/复制

MySQL 主从同步即每当主数据库进行了数据的操作后，就会将操作写入 binlog 文件，从数据库会启动一个 IO 线程去监控主数据库的 binlog 文件，并将 binlog 文件的内容写入自己的 relaylog 文件中，同时会启动一个 SQL 线程去监控 relaylog 文件，如果发生变化就更新数据。

主从复制的类型：

• statement模式（sbr）：只有修改数据的 SQL 语句会记录到 binlog 中，优点是减少了日志量，节省 IO，提高性能，不足是可能会导致主从节点之间的数据有差异。
• row模式（rbr）：仅记录被修改的数据，不怕无法正确复制的问题，但会产生大量的 binlog。
• mixed模式（mbr）：sbr 和 rbr 的混合模式，一般复制用 sbr，sbr 无法复制的用 rbr。

主从同步实现

1. docker-compose.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

version: '3.8'
services:
  mysql_master:
    image: mysql:5.7.35
    command: --default-authentication-plugin=mysql_native_password
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: toortoor
    ports:
      - 3306:3306
    volumes:
      - ./master/my.cnf:/etc/mysql/my.cnf
      
  mysql_slave:
    image: mysql:5.7.35
    command: --default-authentication-plugin=mysql_native_password
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: toortoor
    ports:
      - 3307:3306
    volumes:
      - ./slave/my.cnf:/etc/mysql/my.cnf

2. master/my.cnf

1
2
3
4
5
6
7
8
9
10
11
12
13

[mysqld]
server-id = 1                   #节点ID，确保唯一
log-bin = mysql-bin             #开启mysql的binlog日志功能
sync_binlog = 1                 #控制数据库的binlog刷到磁盘上去，0不控制，性能最好；1每次事物提交都会刷到日志文件中，性能最差，最安全
binlog_format = mixed           #binlog日志格式，mysql默认采用statement，建议使用mixed
expire_logs_days = 7            #binlog过期清理时间
max_binlog_size = 100m          #binlog每个日志文件大小
binlog_cache_size = 4m          #binlog缓存大小
max_binlog_cache_size= 512m     #最大binlog缓存大
binlog-ignore-db=mysql          #不生成日志文件的数据库，多个忽略数据库可以用逗号拼接，或者复制这句话，写多行
auto-increment-offset = 1       #自增值的偏移量
auto-increment-increment = 1    #自增值的自增量
slave-skip-errors = all         #跳过从库错误

3. slave/my.cnf

1
2
3
4
5
6
7

[mysqld]
server-id = 2
log-bin=mysql-bin
relay-log = mysql-relay-bin
replicate-wild-ignore-table=mysql.%
replicate-wild-ignore-table=test.%
replicate-wild-ignore-table=information_schema.%

4. 在 master 创建复制用户并授权

1
2
3

create user 'repl_user'@'%' identified by 'toortoor';
grant replication slave on *.* to 'repl_user'@'%' identified by 'toortoor';
flush privileges;

5. 查看 master 状态

1
2
3
4
5
6

show master status;
+------------------+----------+...
| File             | Position |...
+------------------+----------+...
| mysql-bin.000003 |      844 |...
+------------------+----------+...

6. 在从数据库配置

1
2
3
4
5
6
7
8
9

change master to
MASTER_HOST = '172.19.0.3',
MASTER_USER = 'repl_user', 
MASTER_PASSWORD = 'toortoor',
MASTER_PORT = 3306,
MASTER_LOG_FILE='mysql-bin.000003',
MASTER_LOG_POS=844,
MASTER_RETRY_COUNT = 60,
MASTER_HEARTBEAT_PERIOD = 10000; 

7. 启动从配置

1
2

start slave;
show slave status\G;

8. 如果配置失败，可以执行

1
2

stop slave;
set global sql_slave_skip_counter=1;

3.2 Mycat读写分离

在一般项目中，对于数据库的操作读要远大于写，而如果所有的操作都放在一个节点上，那么就很容易出现压力过大而宕机，读写分离就可以很好解决该问题，主要通过 mycat 的中间件来实现。

分库分表类型：

• 水平拆分：将不同等级的会员信息写到不同的表中
• 垂直拆分：将买家信息、卖家信息、商品信息、支付信息等不同信息写到不同的表中

Mycat的主要文件：

1. server.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

<!-- Mycat用户名 -->
<user name="root" defaultAccount="true">
    			<!-- 密码 -->
                <property name="password">123456</property>
    			<!-- 逻辑库名 -->
                <property name="schemas">TESTDB</property>
    			<!-- 默认逻辑库 -->
                <property name="defaultSchema">TESTDB</property>
                <!--No MyCAT Database selected 错误前会尝试使用该schema作为schema，不设置则为null,报
错 -->

                <!-- 表级 DML 权限设置 -->
    			<!-- 0为禁止，1为开启 -->
    			<!-- 按顺序分别为insert、update、select、delete -->
                <!--
                <privileges check="false">
                        <schema name="TESTDB" dml="0110" >
                                <table name="tb01" dml="0000"></table>
                                <table name="tb02" dml="1111"></table>
                        </schema>
                </privileges>
                 -->
        </user>
		<!-- 其他用户设置 -->
        <user name="user">
                <property name="password">user</property>
                <property name="schemas">TESTDB</property>
                <property name="readOnly">true</property>
                <property name="defaultSchema">TESTDB</property>
        </user>

2. schema.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

<mycat:schema xmlns:mycat="http://io.mycat/">
        <!-- 
			 name为逻辑库名称，与server.xml文件对应 
             checkSQLschema为true，sql为select * from table_name
			 checkSQLschema为false，sql为select * from TESTDB.table_name
			 sqlMaxLimit是指如果sql中没有limit，则自动添加，如果有则不添加
		-->
        <schema name="TESTDB" checkSQLschema="true" sqlMaxLimit="100" randomDataNode="dn1">
                <!-- 
					 name为逻辑表名
					 dataNode为数据节点名称
				     rule为规则
				-->
                <table name="customer" primaryKey="id" dataNode="dn1,dn2" rule="sharding-by-intfile" autoIncrement="true" fetchStoreNodeByJdbc="true">
                        <childTable name="customer_addr" primaryKey="id" joinKey="customer_id" parentKey="id"> </childTable>
                </table>
        </schema>
        <!-- 
			 name为数据节点名称
			 dataHost为数据库地址
			 database为mysql中的database
			 实际就是将TESTDB逻辑库拆成dn1和dn2，而dn1和dn2又对应db1和db2
		-->
        <dataNode name="dn1" dataHost="localhost1" database="db1" />
        <dataNode name="dn2" dataHost="localhost1" database="db2" />
        <dataNode name="dn3" dataHost="localhost1" database="db3" />
        <!--
			 balance:
				0:不开启读写分离，所有操作都在writeHost上
				1:所有读操作都随机发送到当前的writeHost对应的readHost和备用的writeHost
				2:所有读操作都随机发送到所有的主机上
				3:所有读操作只发送到readHost上
			 writeType:
				0:所有写操作都在第一台writeHost上，第一台挂了再切到第二台
				1:所有写操作都随机分配到writeHost
			 switchType: 用于是否允许writeHost和readHost之间自动切换
				-1:不允许
				1:允许
				2:基于mysql的主从同步的状态决定是否切换
        -->
        <dataHost name="localhost1" maxCon="1000" minCon="10" balance="0"
                          writeType="0" dbType="mysql" dbDriver="jdbc" switchType="1"  slaveThreshold="100">
            	<!-- 用此命令来进行心跳检测 -->
                <heartbeat>select user()</heartbeat>
                <!-- 设置读写分离 -->
                <writeHost host="hostM1" url="jdbc:mysql://localhost:3306" user="root"
                                   password="root">
                    <readHost host="hostS1" url="jdbc:mysql://localhost:3306" user="root"
                                   password="root" />
                    </readHost>
                </writeHost>
        </dataHost>
</mycat:schema>

3. rule.xml

1
2
3
4
5
6
7
8
9
10
11
12
13

<!-- 平均分算法 -->
<tableRule name="mod-long">
        <rule>
                <!-- 根据id值平均分 -->
                <columns>id</columns>
                <algorithm>mod-long</algorithm>
        </rule>
</tableRule>
...
<function name="mod-long" class="io.mycat.route.function.PartitionByMod">
         <!-- 切片个数 -->
         <property name="count">2</property>
</function>

4. 在 master 节点创建数据库

1
2
3

-- 与schema.xml中的database参数相同
create database db1;
create database db2;

5. 在每个库里创建表

1
2
3
4
5

create table students(
	id int(4),
	name varchar(10),
	primary key(`id`)
)engine=innodb default charset=utf8;

6. 开启 Mycat，默认开启8066服务端端口和9066管理端端口

1

./mycat start

7. 在有安装 mysql 的主机登录 Mycat，也可以通过 navicat 连接

1

mysql -uroot -ptoortoor -h 192.168.88.136 -P 8066

8. 只要在 Mycat 进行 SQL 操作，都会流到 mysql 集群中被处理，也可以看到已经实现了分库分表

3.3 使用haproxy实现Mycat高可用

haproxy 可以实现 Mycat 集群的高可用和负载均衡，而 haproxy 的高可用通过 keepalived 来实现。

1. 安装 haproxy

1

yum -y install haproxy

2. 修改日志文件

1
2
3
4
5

vim /etc/rsyslog.conf
# Provides UDP syslog reception
$ModLoad imudp
$UDPServerRun 514
systemctl restart rsyslog

3. 配置 haproxy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

vim /etc/haproxy/haproxy.cfg
# haproxy的配置文件由两个部分构成，全局设定和代理设定
# 分为五段:global、defaults、frontend、backend、listen
global
    # 定义全局的syslog服务器
    log         127.0.0.1 local2
    chroot      /var/lib/haproxy
    pidfile     /var/run/haproxy.pid
    maxconn     4000
    user        haproxy
    group       haproxy
    # 设置haproxy后台守护进程形式运行
    daemon
    stats socket /var/lib/haproxy/stats
defaults
    # 处理模式
    # http:七层
    # tcp:四层
    # health:状态检查,只会返回OK
    mode                    tcp
    # 继承global中log的定义
    log                     global
    option                  tcplog
    option                  dontlognull
    option http-server-close
    # option forwardfor       except 127.0.0.0/8
    # serverId对应的服务器挂掉后,强制定向到其他健康的服务器
    option                  redispatch
    retries                 3
    timeout http-request    10s
    timeout queue           1m
    timeout connect         10s
    timeout client          1m
    timeout server          1m
    timeout http-keep-alive 10s
    timeout check           10s
    maxconn                 3000
frontend  mycat
    # 开启本地监控端口
    bind             0.0.0.0:8066
    bind             0.0.0.0:9066
    mode             tcp
    log              global
    default_backend  mycat
backend mycat
    balance     roundrobin
    # 监控的Mycat
    server      mycat1 192.168.88.135:8066 check inter 5s rise 2 fall 3
    server      mycat2 192.168.88.135:8066 check inter 5s rise 2 fall 3
    server      mycatadmin1 192.168.88.136:9066 check inter 5s rise 2 fall 3
    server      mycatadmin2 192.168.88.136:9066 check inter 5s rise 2 fall 3
    listen      stats
    mode        http
    # 访问haproxy的端口
    bind        0.0.0.0:9999
    stats       enable
    stats       hide-version
    # url路径
    stats uri   /haproxy
    stats realm Haproxy\ Statistics
    # 用户名/密码
    stats auth  admin:admin
    stats admin if TRUE

4. 访问 haproxy

3.4 使用keepalived实现去中心化

1. 安装 keepalived

1

yum -y install keepalived

2. 配置 Master 节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

vim /etc/keepalived/keepalived.conf
! Configuration File for keepalived

global_defs {
    # 识别节点的id
    router_id haproxy01
}

vrrp_instance VI_1 {
    # 设置角色，由于抢占容易出现 VIP 切换而闪断带来的风险，所以该配置为不抢占模式
    state BACKUP
    # VIP所绑定的网卡
    interface ens33
    # 虚拟路由ID号，两个节点必须一样
    virtual_router_id 30
    # 权重
    priority 100
    # 开启不抢占
    # nopreempt
    # 组播信息发送间隔，两个节点必须一样
    advert_int 1
    # 设置验证信息
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    # VIP地址池，可以多个
    virtual_ipaddress {
        192.168.88.200
    }
    # 将 track_script 块加入 instance 配置块
    track_script{
        chk_haproxy
    }
}

# 定义监控脚本
vrrp_script chk_haproxy {
    script "/etc/keepalived/haproxy_check.sh"
    # 时间间隔
    interval 2
    # 条件成立权重+2
    weight 2
}

3. 配置 Slave 节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

vim /etc/keepalived/keepalived.conf
! Configuration File for keepalived

global_defs {
    router_id haproxy02
}

vrrp_instance VI_1 {
    state BACKUP
    interface ens33
    virtual_router_id 30
    priority 80
    # nopreempt
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
        192.168.88.200
    }
    track_script{
        chk_haproxy
    }
}

vrrp_script chk_haproxy {
    script "/etc/keepalived/haproxy_check.sh"
    interval 2
    weight 2
}

4. 编写监控脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

vim /etc/keepalived/haproxy_check.sh
#!/bin/bash

START_HAPROXY="systemctl start haproxy"
STOP_KEEPALIVED="systemctl stop keepalived"
LOG_DIR="/etc/keepalived/haproxy_check.log"
HAPS=`ps -C haproxy --no-header | wc -l`

date "+%F %H:%M:%S" > $LOG_DIR
echo "Check haproxy status" >> $LOG_DIR
if [ $HAPS -eq 0 ];
then
    echo "Haproxy is down" >> $LOG_DIR
    echo "Try to turn on Haproxy..." >> $LOG_DIR
    echo $START_HAPROXY | sh
    sleep 3
    if [ `ps -C haproxy --no-header | wc -l` -eq 0 ];
    then
        echo -e "Start Haproxy failed, killall keepalived\n" >> $LOG_DIR
        echo $STOP_KEEPALIVED | sh
    else
        echo -e "Start Haproxy successed\n" >> $LOG_DIR
    fi
else
    echo -e "Haproxy is running\n" >> $LOG_DIR
fi

5. 启动 keepalived 后可以看到 VIP 被哪台服务器抢占了，通过该 VIP 就可以访问到对应的 haproxy，haproxy 就会将流量流到后面的 Mycat，再由 Mycat 来实现分表分库；haproxy 停止后 keepalived 也会通过脚本尝试去重新开启，如果开启不成功就会停止 keepalived，VIP 就由 slave 节点抢占，用户依旧可以通过 VIP 来操控数据库，且无感知。

6. 通过 VIP 去连接 Mycat 插入数据，尝试能否实现分库分表

可以看到插入的数据都分到了 db1、db2 中

3.5 Sharding JDBC读写分离

Apache ShardingSphere 是一套开源的分布式数据库解决方案组成的生态圈，它由 JDBC、Proxy 和 Sidecar（规划中）这 3 款既能够独立部署，又支持混合部署配合使用的产品组成。

Sharding JDBC 同样也可以实现分库分表、数据分片、读写分离等功能，但与 Mycat 不同的是，Mycat 是一个独立的程序，而 Sharding JDBC 是以 jar 包的形式与应用程序融合在一起运行的。

一、简介

REmote DIctionary Server（Redis）是一个由 Salvatore Sanfilippo 写的 key-value 存储系统，是跨平台的非关系型数据库。

Redis 就是一款 NoSQL，而 NoSQL 就是指非关系型数据库，主要分为四种：

1. 键值型：Redis
2. 文档型：ElasticSearch、Mongdb
3. 面向列：Hbase
4. 图形化：Neo4j

二、Redis基础

2.1 Redis安装

1. 通过 docker-compose 安装 redis

1
2
3
4
5
6
7
8
9
10

version: '3.8'
services:
  redis:
    image: daocloud.io/library/redis:5.0.9
    restart: always
    container_name: redis
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 6379:6379

2. 进入容器内部测试 redis

1
2
3
4
5
6

# 连接redis
redis-cli
# set新建键值对
set key value
# get获取键值
get key

2.2 Redis常用命令

redis 的数据存储结构有以下几种：

• key-string（字符串）：一个 key 对应一个值
• key-hash（哈希）：一个 key 对应一个 map
• key-list（列表）：一个 key 对应一个列表
• key-set（集合）：一个 key 对应一个集合
• key-zset（有序集合）：一个 key 对应一个有序的集合

2.2.1 string常用命令

1. 设置值

1

set key value

2. 取值

1

get key

3. 批量操作

1
2

mset key1 value1 key2 value2 ...
mget key1 key2 ... 

4. 自增

1

incr key

5. 自减

1

decr key

6. 自增自减指定数量

1
2

incrby key number
decrby key number

7. 设置值的同时指定生存时间

1

setex key seconds value

8. 设置值，如果当前 key 不存在如同 set，如果存在则说明都不做

1

setex key value

9. 在 key 对应的 value 后追加内容

1

append key value

10. 查看 value 字符串长度

1

strlen key

2.2.2 hash常用命令

1. 存储数据

1

hset key field value

2. 获取数据

1

hget key field

3. 批量操作

1
2

hmset key1 field1 value1 field2 value2 ...
hmget key1 firle1 field2 ...

4. 指定自增

1

hincrby key field number

5. 设置值，如果当前 key 不存在如同 set，如果存在则说明都不做

1

hsetnx key field value

6. 检查 field 是否存在

1

hexists key field

7. 删除某个 field

1

hdel key field1 field2 ...

8. 获取当前 hash 结构中的全部 field 和 value

1

hgetall key

9. 获取当前 hash 结构中的全部 field

1

hkeys key

10. 获取当前 hash 结构中的全部 value

1

hvals key

11. 获取当前 hash 中 field 的数量

1

hlen key

2.2.3 list常用命令

1. 存储数据

1
2
3
4
5
6
7
8
9
10
11

# 从左侧插入数据
lpush key value1 value2 ...
# 从右侧插入数据
rpush key value1 value2 ...

# 如果key不存在，什么都不做，如果key存在但不是list结构，也什么都不做
lpushx key value1 value2 ...
rpushx key value1 value2 ...

# 通过索引位置添加value
lset key index value

2. 获取数据

1
2
3
4
5
6
7
8
9
10
11
12
13

# 左侧弹出数据并移除
lpop key
# 右侧弹出数据并移除
rpop key

# 获取一定范围的数据，start从0开始，stop为-1时为最后一个value，-2时为倒数第二个value
lrange key start stop

# 根据索引位置获取value
lindex key index

# 获取整个list的长度
llen key

3. 删除数据

1
2
3
4
5
6
7
8

# 删除list中count个value的值，当count>0，从左向右删除，但count<0，从右向左删除，但count==0，全部删除
lrem key count value

# 保留列表中指定范围内的数据，超出这个范围的都会被移除
ltrim start stop

# 将list1中的最后一个数据弹出，插入到list2中的第一个位置
rpoplpush key1 key2

2.2.4 set常用命令

1. 存储数据

1
2

# value不允许重复，且数据无序排列
sadd key value1 value2 ...

2. 获取数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 获取全部数据
smembers key

# 随机获取数据，并移除，可加弹出数量
spop key number

# 取多个set的交集
sinter key1 key2 ...

# 取多个set的并集
sunion key1 key2 ...

# 取多个set的差集
sdiff key1 key2 ...

# 查看当前set是否包含某个值
sismember key value

3. 删除数据

1

srem key value1 value2 ...

2.2.5 zset常用命令

1. 存储数据

1
2
3
4
5

# score必须是数值，value不允许重复
zadd key score1 value1 score2 value2 ...

# 修改score，如果value存在则增加分数，如果不存在则相当于zadd
zincrby key number value

2. 获取数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 查看指定value的分数
zscore key value

# 获取value数量
zcard key

# 根据score范围查询value数量
zcount key min max

# 根据分数从小到大排序，获取指定范围内的数据，添加了withscores参数会返回value的具体score
zrange key start stop withscores

# 从大到小
zrevrange key start stop withscores

# 根据分数的范围获取数据，如果不希望包括min和max的值可以用(min max)的方式，最大最小值用±inf表示
zrangebyscore key min max withscores [limit,offset,count]
zrevrangebyscore key max min withscores [limit,offset,count]

3. 删除数据

1

zrem key value1 value2 ...

2.2.6 key常用命令

1. 查看所有key

1

keys *

2. 查看某个key是否存在

1

exists key

3. 删除key

1

del key

4. 设置key的生存时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 单位为s
expire key seconds

# 单位为ms
pexpire key milliseconds

# 指定生存到某个时间点
expireat key timestamp
pexpireat key millseconds

# 查看key的剩余生存时间，返回-2则key不存在，-1则没设置生存时间
ttl key
pttl key

# 移除生存时间
persist key

5. 选择操作的库

1
2
3
4
5

# redis默认有16个库
select 0~15

# 移动key到另一个库中
move key db

2.2.7 库的常用命令

1. 清空当前所在数据库

1

flushdb

2. 清空所有数据库

1

flushdball

3. 查看当前库有多少key

1

dbsize

4. 查看最后一次操作的时间

1

lastsave

5. 实时监控redis接收到的命令

1

monitor

三、Redis配置

3.1 Redis的AUTH

1. docker-compose.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13

version: '3.8'
services:
  redis:
    image: daocloud.io/library/redis:5.0.9
    container_name: redis
    restart: always
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 6379:6379
    volumes:
      - ./redis.conf:/usr/local/redis/redis.conf
    command: ["redis-server", "/usr/local/redis/redis.conf"]

2. 设置 Redis 连接密码

1
2

vim redis.conf
requirepass toortoor

1

docker-compose up -d

3. 进入 Redis 之后都需要输入密码才可以创建 key

1
2

redis-cli
auth toortoor

3.2 Redis的事务

Redis 事务可以一次执行多个命令， 并且带有以下三个重要的保证：

• 批量操作在发送 EXEC 命令前被放入队列缓存
• 收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行
• 在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中

一个事务从开始到执行会经历以下几个阶段：

• 开始事务：multi
• 命令入队：……
• 执行事务：exec
• 取消事务：discard
• 监听：在开启事务之前，先通过 watch 监听事务中要操作的 key，如果在事务过程中有其他的客户端修改了 key，那么事务将会被取消

事务可以理解为一个打包的批量执行脚本，但批量指令并非原子化的操作，中间某条指令的失败不会导致前面已做指令的回滚，也不会造成后续的指令不做。

1. 监听

1

watch name age gander

2. 开始事务

1

multi

3. 命令入队

1
2
3

set name cqm
set age 22
set gander male

4. 执行事务/取消事务

1

exec/discard

3.3 Redis的持久化

3.3.1 RDB持久化

Redis 的配置文件位于 Redis 安装目录, ROB 是默认的持久化机制。

1. docker-compose.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

version: '3.8'
services:
  redis:
    image: daocloud.io/library/redis:5.0.9
    container_name: redis
    restart: always
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 6379:6379
    volumes:
      - ./redis.conf:/usr/local/redis/redis.conf
      - ./data:/data
    # 加载redis.conf
    command: ["redis-server", "/usr/local/redis/redis.conf"]

2. redis.conf

1
2
3
4
5
6
7
8
9

vim redis.conf
# 在900秒内有1一个 key 发生了变化，就执行 RDB 持久化
save 900 1
save 300 10
save 60 10000
# 开启RDB持久化
rdbchecksum yes
# RDB持久化名称
dbfilename dump.rdb

3. 测试持久化

1
2
3
4

set name cqm
set age 22
# 关闭redis并保存
shutdown save

4. 可以看到 data 目录下多了个 rdb 文件，即使 redis 容器重启也不会造成 key 的丢失

3.3.2 AOF持久化

AOF 比起 RDB 有更高的数据安全性，如果同时开启了 AOF 和 RDB，那么前者比后者的优先级更高，且如果先开启了 RDB 在开启 AOF，那么 RDB 中的内容会被 AOF 的内容覆盖。

1. redis.conf

1
2
3
4
5
6
7
8
9

# 开启AOF持久化
appendonly yes
# AOF文件名
appendfilename appendonly.aof
# AOF持久化执行策略
# always:每次执行写操作都调用fsync
# everysec:最多每秒调用一次fsync
# no:根据环境的不同在不确定的时间调用fsync
appendfsync always|everysec|no

2. 重启 docker-compose 测试

1
2
3

set gander male
# 不RDB持久化
shutdown nosave

3. 可以看到 data 目录下多了个 aof 文件，即 AOF 持久化生成的文件

3.4 Redis主从架构

Redis 的主从架构是指 Master 节点负责写操作，而其余的 Slave 节点负责读操作。

1. docker-compose.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

version: '3.8'
services:
  redis-master:
    container_name: redis-master
    image: daocloud.io/library/redis:5.0.9
    restart: always
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7001:6379
    volumes:
      - ./redis1.conf:/usr/local/redis/redis.conf
      - ./data1:/data
    command: ["redis-server", "/usr/local/redis/redis.conf"]
  redis-slave1:
    container_name: redis-slave1
    image: daocloud.io/library/redis:5.0.9
    restart: always
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7002:6379
    volumes:
      - ./redis2.conf:/usr/local/redis/redis.conf
      - ./data2:/data
    command: ["redis-server", "/usr/local/redis/redis.conf"]
    # 连接redis-master容器，并将该容器ip地址映射为master
    links:
      - redis-master:master
  redis-slave2:
    container_name: redis-slave2
    image: daocloud.io/library/redis:5.0.9
    restart: always
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7003:6379
    volumes:
      - ./redis3.conf:/usr/local/redis/redis.conf
      - ./data3:/data
    command: ["redis-server", "/usr/local/redis/redis.conf"]
    links:
      - redis-master:master

2. 从节点 redis.conf

1
2

# slaveof <主节点地址> <端口>
slaveof master 6379

3. 启动后进入容器内部通过 info 可看到节点信息

3.5 Redis哨兵模式

Redis 的主从架构有一个很明显的问题，就是当 Master 节点出现问题宕机后，那么 Redis 集群就没有可以进行写操作的 Redis 了，而哨兵就可以解决该问题。

在每个节点中都会有个哨兵与 Redis 进行连接，且哨兵与哨兵之间也会进行连接，如果 Master 节点出现故障宕机了，那么哨兵们就会选出一个 Slave 来作为新的 Master 来提供写的操作。

1. docker-compose.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

version: '3.8'
services:
  redis-master:
    container_name: redis-master
    image: daocloud.io/library/redis:5.0.9
    restart: always
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7001:6379
    volumes:
      - ./redis1.conf:/usr/local/redis/redis.conf
      - ./data1:/data
      - ./sentinel1.conf:/data/sentinel.conf
    command: ["redis-server", "/usr/local/redis/redis.conf"]
  redis-slave1:
    container_name: redis-slave1
    image: daocloud.io/library/redis:5.0.9
    restart: always
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7002:6379
    volumes:
      - ./redis2.conf:/usr/local/redis/redis.conf
      - ./data2:/data
      - ./sentinel2.conf:/data/sentinel.conf
    command: ["redis-server", "/usr/local/redis/redis.conf"]
    links:
      - redis-master:master
  redis-slave2:
    container_name: redis-slave2
    image: daocloud.io/library/redis:5.0.9
    restart: always
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7003:6379
    volumes:
      - ./redis3.conf:/usr/local/redis/redis.conf
      - ./data3:/data
      - ./sentinel3.conf:/data/sentinel.conf
    command: ["redis-server", "/usr/local/redis/redis.conf"]
    links:
      - redis-master:master

2. Master 节点 sentinel.conf

1
2
3
4
5
6

# 以守护进程的方式运行redis
daemonize yes
# 指定Master节点，sentinel monitor <名称> <ip> <端口> <Slave个数>
sentinel monitor master localhost 6379 2
# 指定哨兵每隔多久检测一次redis主从架构
sentinel down-after-milliseconds master 10000

3. Slave 节点 sentinel.conf

1
2
3

daemonize yes
sentinel monitor master master 6379 2
sentinel down-after-milliseconds master 10000

4. 进入容器启动哨兵，当 Master 节点出现问题后，就会在两个 Slave 中选出一个作为新的 Master，而旧的 Master 启动后就会变为新的 Slave

1

redis-sentinel /data/sentinel.conf

3.6 Redis集群

Redis 集群在保证主从和哨兵的基本功能之外，还能提高 Redis 存储数据的能力，主要的特点如下

• Redis 集群是无中心的
• Redis 集群有ping-pang的机制
• 投票机制，集群节点的数量必须是 2n+1
• 分配了 16484 个 hash 槽，在存储数据时，会对 key 进行 crc16 的算法，并对 16384 进行取余，通过结果分配到对应的节点上，每个节点都有自己维护的 hash 槽
• 每个主节点都要跟一个从节点，但这里的从节点只管备份，不管查询
• 集群中半数的节点宕机后，那么集群就瘫痪

1. docker-compose.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

version: '3.8'
services:
  redis1:
    container_name: redis1
    image: daocloud.io/library/redis:5.0.9
    restart: always
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7001:7001
      - 17001:17001
    volumes:
      - ./conf.d/redis1.conf:/usr/local/redis/redis.conf
    command: ["redis-server", "/usr/local/redis/redis.conf"]
  redis2:
    container_name: redis2
    image: daocloud.io/library/redis:5.0.9
    restart: always
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7002:7002
      - 17002:17002
    volumes:
      - ./conf.d/redis2.conf:/usr/local/redis/redis.conf
    command: ["redis-server", "/usr/local/redis/redis.conf"]
  redis3:
    container_name: redis3
    image: daocloud.io/library/redis:5.0.9
    restart: always
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7003:7003
      - 17003:17003
    volumes:
      - ./conf.d/redis3.conf:/usr/local/redis/redis.conf
    command: ["redis-server", "/usr/local/redis/redis.conf"]
  redis4:
    container_name: redis4
    image: daocloud.io/library/redis:5.0.9
    restart: always
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7004:7004
      - 17004:17004
    volumes:
      - ./conf.d/redis4.conf:/usr/local/redis/redis.conf
    command: ["redis-server", "/usr/local/redis/redis.conf"]
  redis5:
    container_name: redis5
    image: daocloud.io/library/redis:5.0.9
    restart: always
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7005:7005
      - 17005:17005
    volumes:
      - ./conf.d/redis5.conf:/usr/local/redis/redis.conf
    command: ["redis-server", "/usr/local/redis/redis.conf"]
  redis6:
    container_name: redis6
    image: daocloud.io/library/redis:5.0.9
    restart: always
    environment:
      - TZ=Asia/Shanghai
    ports:
      - 7006:7006
      - 17006:17006
    volumes:
      - ./conf.d/redis6.conf:/usr/local/redis/redis.conf
    command: ["redis-server", "/usr/local/redis/redis.conf"]

2. redis{1..6}.conf，x 为 {1..6}

1
2
3
4
5
6
7
8
9
10
11
12

# 指定redis端口
port 700x
# 开启集群
cluster-enabled yes
# 集群信息文件
cluster-config-file nodes-700x.conf
# 集群对外ip
cluster-announce-ip 192.168.88.135
# 集群对外端口
cluster-announce-port 700x
# 集群总线端口
cluster-announce-bus-port 1700x

3. 进入任意 reids 容器创建集群

1
2

# --cluster-replicas:每个主节点分配的从节点个数
redis-cli --cluster create 192.168.88.135:7001 192.168.88.135:7002 192.168.88.135:7003 192.168.88.135:7004 192.168.88.135:7005 192.168.88.135:7006 --cluster-replicas 1

4. 由于每个主节点都被分配了不同的 hash 槽，所以要在容器内任意切换不同的 redis 节点需要加参数 -c

1

redis-cli -h 192.168.88.135 -p 7001 -c

四、Redis常见问题

4.1 Redis的删除策略

当 key 的生存时间到了，Redis 并不会立即删除该 key，而是遵守以下删除策略来进行删除

• 定期删除：Redis 每隔一段时间就回去查看设置了生存时间的 key，默认是 100ms 查看 3 个 key
• 惰性删除：当用户去查询已经超过了生存时间的 key，Redis 会先查看该 key 是否已经超过了生存时间，如果超过，那么 Redis 会将该 key 删除并给用户返回一个空值

4.2 Redis的淘汰机制

当 Redis 内存满的时候添加了一个新的数据，那么就会执行 Redis 的淘汰机制，通过 maxmemory-policy 来设置，参数如下

1. volatile-lru：当内存不足时，会删除一个设置了生存时间且最近最少使用的 key

2. allkeys-lru：当内存不足时，会删除一个设置了最近最少使用的 key

3. volatile-lfu：当内存不足时，会删除一个设置了生存时间且最近使用频率最低的 key

4. allkeys-lfu：当内存不足时，会删除一个设置了最近使用频率最低的 key

5. volatile-random：当内存不足时，会随机删除一个设置了生存时间的 key

6. allkeys-random：当内存不足时，会随机删除一个 key

7. volatile-ttl：当内存不足时，会删除一个生存时间最少的 key

8. noeviction：内存不足时，直接报错

4.3 缓存问题

缓存穿透

当客户查询的数据 Redis 中没有，数据库中也没有，且请求量特别大时，就会导致数据库的压力过大，解决方法如下

• 根据 id 查询时，如果 id 是自增的，那么可以将最大的 id 放到 Reids 中，当查询数据时直接对比 id 即可
• 如果 id 不是 int 型，那么可以将全部的 id 放入 set 中，用户查询之前可以先到 set 查看是否有该 id
• 获取用户的 ip 地址，对该地址进行访问限制

缓存击穿

当用户查询的是热点数据时，那么并发量肯定是很高的，当 Redis 中的热点数据过期了，那么数据库的压力就会很大，甚至宕机，解决方法如下

• 在访问热点数据时，缓存中没有的时候，可以添加一把锁，让几个请求去访问数据库，避免数据库宕机
• 把热点数据的生存时间去掉

缓存雪崩

当大量缓存同时到期时，导致请求都去到了数据库，也很容易导致数据库宕机，解决方法如下

• 对缓存中的数据设置一个随机的生存时间，避免同时过期

缓存倾斜

如果将热点数据放在集群中的某一 Redis 节点上时，那么大量的数据都会去到该 Redis 节点，导致节点宕机，解决方法如下

• 主从架构，准备大量的从节点
• 在 Tomcat 中做 JVM 缓存，在查询 Redis 前先查询 JVM 缓存

一、Apache

1.1 Apache介绍

Apache HTTP Server（简称Apache）是Apache软件基金会的一个开放源码的网页服务器，是世界使用排名第一的Web服务器软件。它可以运行在几乎所有广泛使用的计算机平台上，由于其跨平台和安全性被广泛使用，是最流行的Web服务器端软件之一。它快速、可靠并且可通过简单的API扩充，将Perl/Python等解释器编译到服务器中。

Apache HTTP服务器是一个模块化的服务器，源于NCSAhttpd服务器，经过多次修改，成为世界使用排名第一的Web服务器软件。

Apache官方文档：http://httpd.apache.org/docs/

1.2 通过脚本源码安装Apache

1. 编写安装脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189