😀 这里写文章的前言：
机器学习三大范式（监督/无监督/强化）与深度网络的关系；回归 vs 分类；输入类型（表格、序列、图像、图结构）；模型作为函数族 + 训练数据选择具体函数；生成模型与潜变量

📝 机器学习的三大范式与深度网络关系

核心关系

深度神经网络是目前最强大、最实用的一类机器学习模型。将深度网络应用到数据上的过程称为深度学习。深度网络并非三大范式本身，而是实现这三大范式的核心工具/模型家族。三大范式定义了“学什么、如何学”的问题类型和目标，而深度网络提供了强大的函数逼近能力，使这些范式在复杂、高维、结构化数据上取得当前最佳性能。

• 监督学习：深度网络学习从输入 x 到输出 y 的映射 y=f[x,ϕ]。
• 无监督学习：深度网络学习数据的内在结构或概率分布（生成模型）。
• 强化学习：深度网络常被用来表示策略（从状态到动作的映射）或价值函数。

三大范式是否可以通过深度网络实现？

是的，完全可以，而且目前最前沿的实现几乎都依赖深度网络。

具体说明如下：

（1）监督学习

• 定义：从带标签的输入-输出对中学习映射关系。
• 深度网络实现方式：
  • 网络作为函数 f[x,ϕ]，参数 ϕ 通过最小化损失函数（如平方损失、交叉熵）来训练。
  • 可处理回归（连续输出）、分类（概率输出）、结构化输出（语义分割、深度估计、翻译、图像生成描述等）。
  • 优势：能处理高维、变长、具有内部结构的输入（图像、文本、音频、分子图等），并输出同样复杂的结构。
• 书中例子：房价预测、情感分类、音乐类型识别、图像物体分类、语义分割、单目深度估计、语音转文字、机器翻译、文本生成图像等。

（2）无监督学习

• 定义：只有输入数据，没有对应输出标签。目标是描述或理解数据的结构（而非学习映射）。
• 深度网络实现方式（重点是生成式模型）：
  • 学习合成与训练数据在统计上难以区分的新样本。
  • 一些模型直接建模数据的概率分布并从中采样；另一些只学习生成机制。
  • 常引入潜变量（latent variables）来捕捉数据的低维本质结构（例如人脸表情可用约42个肌肉参数近似描述）。
  • 条件生成：在部分约束下生成（图像修复、文本补全等）。
• 书中例子：逼真的猫/建筑图像生成、短篇故事合成、图像修复、文本续写（如GPT系列）。

（3）强化学习

• 定义：智能体（agent）在环境中执行动作，改变状态并获得奖励。目标是学习能最大化长期累积奖励的策略。存在时间信用分配问题（奖励延迟）以及探索-利用权衡。
• 深度网络实现方式：
  • 最常见的是策略网络：深度网络直接将观察到的状态映射到动作（或动作分布）。
  • 也可用于近似价值函数（状态价值或动作价值）。
• 书中例子：
  • 类人机器人行走：从传感器状态到关节动作的映射。
  • 下棋：从棋盘状态到走法选择的映射。

回归和分类

回归

定义:

回归问题的目标是预测连续数值（或一组连续数值）。模型输出的是实数，而不是离散的类别标签。

• 单变量回归：输出一个连续数值。
• 多变量回归：输出多个连续数值。

直观理解:
把模型想象成一条（或一组）曲线/函数，它根据输入计算出一个“多少”的量。

分类

定义:

分类问题的目标是把输入分配到离散的类别中。模型通常输出每个类别的概率，然后取概率最高的类别作为最终预测。

• 二元分类（Binary Classification）：只有两个类别（是/否、正面/负面、猫/狗等）。
• 多类别分类（Multi-class Classification）：有三个或以上的互斥类别。

直观理解:

把模型想象成一个“投票器”或“概率分配器”，它告诉你输入更像哪一类。

回归 vs 分类 的核心对比

数据处理

现实世界的输入（文本、音频、图像、分子等）必须先被转换成数字向量，模型才能接受并处理。不同输入类型的结构差异很大，处理方式也因此不同。

表格数据

特点

• 固定长度的特征向量
• 没有内在结构（改变特征顺序，模型预期结果不变）
• 典型例子：房屋特征（面积、卧室数、楼层、位置编码等）

处理方式

• 直接把每个特征变成一个数字
• 类别特征需要编码（One-hot 或 Embedding）
• 数值特征通常做标准化/归一化（让数值在相似范围）

处理后的效果示例
假设预测房价，原始数据：

text

面积: 120㎡, 卧室: 3, 楼层: 8, 是否学区: 是

处理后变成固定长度向量：

text

[120.0, 3.0, 8.0, 1.0]          # 或标准化后 [0.85, 0.6, 0.4, 1.0]

模型直接接收这个向量。

文本数据(Text)

特点

• 长度不固定
• 顺序非常重要（“我的妻子吃了鸡肉” ≠ “鸡肉吃了我的妻子”）
• 必须先编码成数字

处理方式（书中举例 + 现代常用方法）

1. 分词（Tokenization）：把句子拆成词或子词
2. 建立词汇表：固定大小（书中例子用 10,000 个词）
3. 转换成索引序列：每个词对应一个整数 ID
4. 现代方法会进一步用 Embedding 层把索引变成稠密向量，或直接用 Transformer 的 tokenizer（如 BPE）

处理后的效果示例
原始文本：

text

"这家餐厅的服务很好"

处理后（简单索引方式，书中例子）：

text

[4521, 89, 3302, 17, 908]     # 每个数字是词汇表中的索引

或经过 Embedding 后变成矩阵（每个词变成一个向量）：

text

[[0.12, -0.45, 0.78, ...],    # “这家”的向量
 [0.33, 0.21, -0.09, ...],    # “餐厅”的向量
 ... ]

长度会不同，实际训练时常做 padding（补零）或截断，变成固定长度

🤗 总结归纳

总结文章的内容

📎 参考文章

• 一些引用
• 引用文章

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
为什么需要解析SQL？解析完SQL后又能做什么？
0. 校验SQL的语法是否合规

1. 数据安全需要解析SQL获取出对应的的操作
2. 数据血缘的抽取需要解析SQL
3. 类似Hive/Spark等在将SQL转化为mr,执行计划等的时候,也是需要解析SQL的
4. 等等;欢迎你来补充更多需要解析SQL的话题

📝 解析的方法

类似阿里开源的druid这种也是有解析SQL的功能的，但是稍微看了下源码，其底层好像也是有利用到antlr

antlr怎么用

IDEA插件

借助IDEA插件来进行安装,但是需要注意的是,项目中的antlr的版本最好是和idea中antlr的版本一致;如果不一致的话，需要使用antlr对应版本的jar来对g4文件生成对应的文件

手动JAR安装

对应版本下载地址: https://github.com/antlr/website-antlr4/tree/gh-pages/download

我们在此处的地址下载自己需要的对应版本;此处的anltr4如果你不想配置环境变量,就替换为 java jar antrlxxx.jar -o… 后面需要的参数

常用参数说明:

• -o : 生成 tokens,interp,java等路径
• -listener: 生成监听者模式的参数
• -visitor: 生成访问者模式的参数
• -lib: 指定g4文件的路径

antlr4 -o E:/coding_self/github_learn/grammars-v4/sql/hive/v3\gen 
-listener -visitor 
-lib E:/coding_self/github_learn/grammars-v4/sql/hive/v3 E:/coding_self/github_learn/grammars-v4/sql/hive/v3\HiveParser.g4 E:/coding_self/github_learn/grammars-v4/sql/hive/v3\HiveLexer.g4

其它方法

官网介绍的方法传送门: https://github.com/antlr/antlr4/blob/master/doc/java-target.md

生成效果

采用如上,最后生成的效果如下图;那我们就可以愉快的在代码中使用和调试了

使用流程

我们按照上面的流程,都生成对应的文件之后,就可以导入到项目中进行使用了;假设导入后报错的话,仔细检查下是否包名的路径之类的问题,手动处理下就好了

我们这里基于访问者来进行介绍

继承 BaseVisitor

比如我借助 grammars-v4 的hive4生成的访问者base类叫 HiveParserBaseVisitor

 借助 Spark的g4生成的 `SqlBaseBaseVisitor`

这里我已Hive的为准介绍,HiveSqlAst 来集成 HiveParserBaseVisitor

package com.iyang.bootbasicio.sql.hive.utils;

import com.iyang.bootbasicio.sql.hive.HiveParser;
import com.iyang.bootbasicio.sql.hive.HiveParserBaseVisitor;
import lombok.extern.slf4j.Slf4j;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/***
 * @author: yang_bao
 * @date: 2023/11/3
 * @desc:
 ***/

@Slf4j
public class HiveSqlAst extends HiveParserBaseVisitor {

    private Map<String, Set<String>> dnTableActionMap = new HashMap<>();

    public HiveSqlAst() {
    }

    public HiveSqlAst(Map<String, Set<String>> dnTableActionMap) {
        this.dnTableActionMap = dnTableActionMap;
    }

    public Map<String, Set<String>> getDnTableActionMap() {
        return dnTableActionMap;
    }

    @Override
    public String visitStatement(HiveParser.StatementContext ctx) {
        log.info(" enter visitStatement function ");
/*        HiveParser.DdlStatementContext ddlStatementContext = ctx.execStatement().ddlStatement();
        HiveParser.TableNameContext nameContext = ddlStatementContext.alterStatement().tableName();
        String dbText = nameContext.db.getText();
        String tabText = nameContext.tab.getText();

        log.info("the db is {} , tab is {} , meta is {} " , dbText, tabText,1);*/
 // 这步链式调用是不能少的,如果你发现少了的话,下面的解析方法就不会进去了
        super.visitStatement(ctx);
        return null;
        // return visitChildren(ctx);
    }

// 包含了 select 的查询
    @Override
    public Object visitSelectStatement(HiveParser.SelectStatementContext ctx) {
        System.out.println("\n");
        log.info("enter visitSelectStatement function ");
/*        HiveParser.AtomSelectStatementContext atomSelectStatementContext = ctx.atomSelectStatement();
        String tableName = atomSelectStatementContext.fromClause().fromSource().joinSource().atomjoinSource().tableSource().tabname.getText();

        log.info("the tableName is ---> {} " , tableName);*/
/*
        System.out.println(ctx.getText());
       try {
           SqlParser sqlParser = SqlParser.create(ctx.getText());
           SqlNode sqlNode = sqlParser.parseQuery();
           System.out.println(sqlNode);
       } catch (Exception e){
           e.printStackTrace();
       }
*/
/*        HiveParser.AtomSelectStatementContext atomCtx = ctx.atomSelectStatement();
        HiveParser.FromSourceContext fromSourceContext = atomCtx.fromClause().fromSource();
        HiveParser.AtomjoinSourceContext atomJoinSource = fromSourceContext.joinSource().atomjoinSource();
        String atomTableName = atomJoinSource.tableSource().getText();
        List<HiveParser.JoinSourcePartContext> partContexts = fromSourceContext.joinSource().joinSourcePart();
        for (HiveParser.JoinSourcePartContext sourcePartContext : partContexts) {
            String partTableName = sourcePartContext.tableSource().getText();
            log.info("the partTableName value is ---> {} ", partTableName);
        }
        log.info("the atomJoinTable value is ---> {} " , atomTableName);*/
        // String tabelName = ctx.atomSelectStatement().fromClause().fromSource().joinSource().atomjoinSource().tableSource().getText();

        HiveParser.AtomSelectStatementContext atomSelectStatement = ctx.atomSelectStatement();

        parseSelectSql(atomSelectStatement);
        return null;
    }

// 包含了 insert 
    @Override
    public Object visitInsertClause(HiveParser.InsertClauseContext ctx) {
        System.out.println("\n");
        HiveParser.TableOrPartitionContext tableOrPartition = ctx.destination().tableOrPartition();
        String tableName = tableOrPartition.tableName().getText();
        log.info("in visitInsertClause, the tableName is ---> {} " , tableName);
        return super.visitInsertClause(ctx);
    }

// alter 语句
    @Override
    public Object visitAlterStatement(HiveParser.AlterStatementContext ctx) {
        System.out.println("\n");
        log.info(" enter visitAlterStatement func ");
        String tableName = ctx.tableName().getText();
        log.info("the tableName is {} " , tableName);

        // tableName 可能会带上catalog的名称；如果需要的话，需要进行catalog的切割
        // ALTER TABLE HIVE_PROD.XIAOBAO_BIGSCREENT.T_ICCE_ENTERPRISE ADD COLUMNS ( SINK_TIME STRING COMMENT 'WRITE DATA TIME')
        return super.visitAlterStatement(ctx);
    }

// create 建表
    @Override
    public Object visitCreateTableStatement(HiveParser.CreateTableStatementContext ctx) {

        String tableName = ctx.tableName().getText();
        log.info("in visitCreateTableStatement, the tableName is {} " , tableName);
        return super.visitCreateTableStatement(ctx);
    }

// 修改语句
    @Override
    public Object visitUpdateStatement(HiveParser.UpdateStatementContext ctx) {
        String tableName = ctx.tableName().getText();
        log.info("in visitUpdateStatement, the tableName value is {} ", tableName);
        // where 中可能保存查询库或者表的条件
        setActionToMapByDbTableName(tableName, HiveActionEnum.UPDATE.getAction());
        return super.visitUpdateStatement(ctx);
    }

// delete 删除语句
    @Override
    public Object visitDeleteStatement(HiveParser.DeleteStatementContext ctx) {
        String tableName = ctx.tableName().getText();
        log.info("in visitDeleteStatement, the tableName value is {} " , tableName);
        // where 中可能保存查询库或者表的条件

        return super.visitDeleteStatement(ctx);
    }

// drop 删除表数据
    @Override
    public Object visitDropTableStatement(HiveParser.DropTableStatementContext ctx) {
        String tableName = ctx.tableName().getText();
        log.info(" in visitDropTableStatement , the tableName is {} " , tableName);
        return super.visitDropTableStatement(ctx);
    }

// drop删除库的数据
    @Override
    public Object visitDropDatabaseStatement(HiveParser.DropDatabaseStatementContext ctx) {
        String dbName = ctx.db_schema().getText();
        log.info(" in visitDropDatabaseStatement, the dbName is {} " , dbName);
        return super.visitDropDatabaseStatement(ctx);
    }

    /**
     * 解析 select 查询的sql语句,获取对应的库和表信息
     * 对 join,子查询sql,以及子查询SQL等嵌套递归查询
     */
    private void parseSelectSql(HiveParser.AtomSelectStatementContext atomSelectStatement){

        // atomSelectStatement 中存在需要解析的sql; fromSource,join,subQuery,
        HiveParser.JoinSourceContext sourceContext = atomSelectStatement.fromClause().fromSource().joinSource();
        // 获取传入进来的 atmo的表名字;判断非空即获取
        if (sourceContext.atomjoinSource().tableSource() != null){
            HiveParser.TableNameContext tabname = sourceContext.atomjoinSource().tableSource().tabname;
            log.info("the tabname value us ---> {} ", tabname.getText());
            setActionToMapByDbTableName(tabname.getText(), HiveActionEnum.SELECT.getAction());
        }
        for (HiveParser.JoinSourcePartContext sourcePartContext : sourceContext.joinSourcePart()) {
            // 解析join部分自身获取的 库和表信息
            if (sourcePartContext.tableSource() != null) {
                HiveParser.TableNameContext sourcePartTableName = sourcePartContext.tableSource().tabname;
                setActionToMapByDbTableName(sourcePartTableName.getText(), HiveActionEnum.SELECT.getAction());
                log.info("the sourcePartTableName value is ---> {}" , sourcePartTableName.getText());
            }
            // join部分的sql也是存在子sql的情况下;如果存在子sql的话,就进行迭代处理
            HiveParser.SubQuerySourceContext partSubQuery = sourcePartContext.subQuerySource();
            if (partSubQuery != null) {
                HiveParser.AtomSelectStatementContext partSubQueryAtmo = partSubQuery.queryStatementExpression().queryStatementExpressionBody().regularBody().selectStatement().atomSelectStatement();
                parseSelectSql(partSubQueryAtmo);
            }
            // 存在没有值的情况sql语句
            // HiveParser.TableNameContext sourcePartTableName = sourcePartContext.tableSource().tabname;
            // log.info("the sourcePartTableName value is ---> {}" , sourcePartTableName.getText());
        }

        // 子sql;如果子sql不是null
        HiveParser.SubQuerySourceContext subQuerySourceContext = sourceContext.atomjoinSource().subQuerySource();
        if (subQuerySourceContext != null) {
            HiveParser.AtomSelectStatementContext subQueryAtom = subQuerySourceContext.queryStatementExpression().queryStatementExpressionBody().regularBody().selectStatement().atomSelectStatement();
            parseSelectSql(subQueryAtom);
        }

    }

    /**
     * 封装 db table 对应的action到 map 集合中
     * @param dbTableName
     * @param action
     */
    private void setActionToMapByDbTableName(String dbTableName,String action){

        Set<String> dbTableActionSet = dnTableActionMap.getOrDefault(dbTableName, new HashSet<>());
        dbTableActionSet.add(action);
        dnTableActionMap.put(dbTableName, dbTableActionSet);

    }

}

解析使用

创建一个来进行调用使用;大家可以使用下面的例子来进行校验使用

package com.iyang.bootbasicio.sql.hive.utils;

import com.iyang.bootbasicio.sql.hive.HiveLexer;
import com.iyang.bootbasicio.sql.hive.HiveParser;
import lombok.extern.slf4j.Slf4j;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.atn.PredictionMode;

import java.util.Map;
import java.util.Set;

/***
 * @author: yang_bao
 * @date: 2023/11/3
 * @desc:
 ***/

@Slf4j
public class HiveSqlHelper {

    private static final String ALERT_SQL = "ALTER TABLE HIVE_PROD.XIAOBAO_BIGSCREENT.T_ICCE_ENTERPRISE ADD COLUMNS ( SINK_TIME STRING COMMENT 'WRITE DATA TIME')";
    private static final String SIMPLE_QUERY_SQL = "SELECT * FROM AAA.CCC";
    private static final String MANY_TABLE_SQL = "SELECT \n" +
            "    NULL                        AS   ID,\n" +
            "    CAST(TEMP_A.CREATE_DATE AS TIMESTAMP)          AS   TIMEC,\n" +
            "    TEMP_A.ENTERPRISE_NUM       AS   ENTERPRISE_NUM,\n" +
            "    TEMP_B.USER_NUM             AS   USER_NUM,\n" +
            "    TEMP_A.VIRTUAL_TENANT       AS   VTENANT,\n" +
            "    CAST(NOW() AS TIMESTAMP)    AS   ETL_LOAD_TS\n" +
            "FROM (\n" +
            "    SELECT \n" +
            "        COUNT(DISTINCT A.ENTERPRISE_ID) AS ENTERPRISE_NUM,\n" +
            "        A.PLATFORM_VIRTUAL_TENANT       AS VIRTUAL_TENANT,\n" +
            "        A.CREATE_DATE                   AS CREATE_DATE\n" +
            "    FROM (SELECT ENTERPRISE_ID,PLATFORM_VIRTUAL_TENANT,SUBSTRING(CREATE_DATE,1,10) AS CREATE_DATE FROM DIM_BIGSCREENT.DIM_ECENTERPRISE_LIST_DI) A GROUP BY PLATFORM_VIRTUAL_TENANT,CREATE_DATE\n" +
            ") TEMP_A LEFT JOIN\n" +
            "(\n" +
            "    SELECT\n" +
            "        COUNT(DISTINCT A.USER_ID) AS USER_NUM,\n" +
            "        A.PLATFORM_VIRTUAL_TENANT AS VIRTUAL_TENANT,\n" +
            "        A.CREATE_DATE\n" +
            "    FROM (SELECT USER_ID,PLATFORM_VIRTUAL_TENANT,SUBSTRING(CREATE_DATE,1,10) AS CREATE_DATE FROM DIM_BIGSCREENT.DIM_ECUSERENTERPRISE_RELATION_LIST_DI) A GROUP BY PLATFORM_VIRTUAL_TENANT,CREATE_DATE\n" +
            ") TEMP_B ON TEMP_A.VIRTUAL_TENANT = TEMP_B.VIRTUAL_TENANT AND TEMP_A.CREATE_DATE = TEMP_B.CREATE_DATE";

    private static final String JOIN_SQL = "select * from aaa.aa as a left join ccc.cc as c on a.id = c.id  left join ddd.dd as d on a.id = d.id";

    private static final String INSERT_QUERY_SQL = "INSERT OVERWRITE TABLE aaa.cc\n" +
            "select * from aaa.aa";

    private static final String CREATE_DDL_SQL = "create table if not exists  ads_bigscreent.ads_cloud_info_sum_df (\n" +
            "\tid                       bigint   comment 'id(主键)'  \t\t\t\t\t\t,\n" +
            "\tplatform_id\t         \t string   comment '平台ID'                          ,\n" +
            "\tplatform_name\t         string   comment '平台名称'                        ,\n" +
            "\tenterprise_num\t         bigint   comment '上云企业数量'                    ,\n" +
            "\tuser_num\t             bigint   comment '注册用户数'                      ,\n" +
            "\ttransaction_num\t     \t bigint   comment '交易用户数'                      ,\n" +
            "\tdeviceconnection_num\t bigint   comment '设备连接数'                      ,\n" +
            "\tpartners_num\t         bigint   comment '生态伙伴数量'                    ,\n" +
            "\tapps_num\t             bigint   comment '工业app数量'                     ,\n" +
            "\tvtenant\t\t\t\t\tstring \t\tcomment '租户'\t\t\t\t\t\t\t,\n" +
            "\tlongitude\t    \t\tdecimal(25,10)  comment\t'经度'\t\t\t\t\t\t,\n" +
            "    latitude\t    \t\tdecimal(25,10)  comment\t'纬度'\t\t\t\t\t\t,\n" +
            "\tetl_load_ts              timestamp comment '创建时间'\n" +
            ")  comment  '上云情况详情'";

    private static final String UPDATE_QUERY_SQL = "update ads_bigscreent.ads_cloud_info_sum_df set name = '123' where id in (select id from aaaa.aa) and " +
            " name in (select name from ads_bigscreent.ads_cloud_info_sum_df)";

    private static final String DELETE_QUERT_SQl = "delete from ads_bigscreent.ads_cloud_info_sum_df where id in (select id from aaaa.cc)";

    private static final String DROP_TABLE_SQL = "drop table ads_bigscreent.ads_cloud_info_sum_df";

    private static final String DROP_DATABASE_SQL = "drop database ads_bigscreent";

    private static final String QUERY_SUB_SQl = "select * from aaa.a as a left join (select * from ccc.c) as c on a.id = c.id";

    public static void main(String[] args) {

        HiveLexer lexer = new HiveLexer(CharStreams.fromString(UPDATE_QUERY_SQL));
        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
        HiveParser parser = new HiveParser(tokenStream);
        parser.getInterpreter().setPredictionMode(PredictionMode.SLL);

        HiveSqlAst hiveSqlAst = new HiveSqlAst();
        hiveSqlAst.visit(parser.statement());

        Map<String, Set<String>> dnTableActionMap = hiveSqlAst.getDnTableActionMap();
        log.info("the dnTableActionMap value is {} ", dnTableActionMap);
    }

}

使用结果

比如我们这里使用的一条update中嵌套一个select校验,看最后的结果都是查询出来的;如果只是库和表的校验的话,那么对应的功能就是可以满足了的

错误SQL解析的错误获取

继承 BaseErrorListener; 我们这里借助传入list来收起错误的error

@Slf4j
public class HiveErrorListener extends BaseErrorListener {

    private List<String> errorMsg ;

    public HiveErrorListener(List<String> errorMsg) {
        this.errorMsg = errorMsg;
    }

    @Override
    public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line,
                            int charPositionInLine, String msg, RecognitionException e) {
        errorMsg.add(msg);
        log.info("the HiveErrorListener(syntaxError) error info is {} " , msg);
    }
}

我们新addErrorListener和addErrorListener,注册上我们的错误监听器

public static void main(String[] args) {
 // 收集错误的集合
        List<String> errorList = new ArrayList<>();

        HiveLexer lexer = new HiveLexer(CharStreams.fromString(UPDATE_QUERY_SQL));
        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
        HiveParser parser = new HiveParser(tokenStream);
        parser.getInterpreter().setPredictionMode(PredictionMode.SLL);

        // 注册我们的错误监听
        lexer.removeErrorListeners();
        parser.removeErrorListeners();
        lexer.addErrorListener(new HiveErrorListener(errorList));
        parser.addErrorListener(new HiveErrorListener(errorList));

        HiveSqlAst hiveSqlAst = new HiveSqlAst();
        hiveSqlAst.visit(parser.statement());
        log.info("the error info is : {} " , errorList);

        Map<String, Set<String>> dnTableActionMap = hiveSqlAst.getDnTableActionMap();
        log.info("the dnTableActionMap value is {} ", dnTableActionMap);
    }

我们故意在sql前加个;号,就可以看到错误解析的具体位置在 ; 这里,还是非常的准确的

方法使用小结

可以看到该接口还提供了很多的对用操作方法,那么我们在使用的时候,就根据对应的方法耐心的调试即可

idea方法小结

上面不是提到我们安装了antlr的插件么？那么也得使用起来了吧

还是以grammer-v4为准来看; 点击 statement 会出现下面的Test Rule statement;然后我们就可以将我们SQL放入如下,就可以看到左下角的SQL语法树的结构

然后我们的代码就可以根据树的调用方法来进行精确的获取,并且同时也可以看到校验的SQL是否有问题

🤗 总结归纳

目前我这边更多的是解析出来SQL,然后对权限进行校验和拦截操作

对于多种不同类似的数据库,其语法是可能不同的,我们其实是可以借助一些设计模式来更好的帮助我们维护和扩展代码

最后,放一个我编写的demo的传送门: https://github.com/ruY9527/boot-case/blob/master/boot-base/boot-basic-io/src/main/java/com/iyang/bootbasicio/sql/hive/utils/HiveSqlHelper.java

📎 参考文章

• https://makeyourchoice.cn/archives/591/
• grammars-v4

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这是一篇记录生活的碎碎念：
欢迎你阅读我的碎碎念,非常感谢
稍微学会下记录生活或者想法，毕竟年纪大了，很容易忘记一些事包括之前一些有的没得

📝 多做少想的实际行动

想多了全是问题，做多了全是答案。想得再多都是焦虑，做得再少也算进步

学会主动远离一些人，告别自己的恋爱脑

远离那些让你内耗的人

经历了漫长的一段时间的自我内耗，就搁那么一丢丢给自己整没了;索性好在突然的醒悟;从醒悟到现在差不多快2个月了吧，坚持着做许多自己当初没做的事情

去慢慢逐渐告别了内耗

远离那些背叛过的人

此处借助张爱玲的一句话，来完全诠释这个二级标题的含义：

人家撇下你的那一刻，一定是觉得某个瞬间没有你，他会生活得更好，那一刻，一辈子都不值得原谅

所以对于有过背叛的人，只会给你非常清醒的上一课然后外加pua并且他已经走出教室，而空留你在座位上不断以我怀疑;于是也请你自己大胆承认这一切,大大方方的走出来，去找寻自己

远离那些故意激怒你的人

人在最初相识的时候，总是带着好奇和新鲜感并且此时估计也是他对你最尊重的时候;当他和你熟了之后，对你知根知底后，往往随着他的“高人一等”而不那么尊重你的时候，其实是你没透过本质去理解，因为他本质就是这样

所以那么故意激怒和恶心你的人，大可不必继续往下走;越往下走，越难理解

远离那些对你一而再，再而三撒谎的人

假设你认为你最喜欢的人对你是一而再，再而三的撒谎，并且瞒天过海的做着许多过分的事情，也尽可以大方的告别，没必要浪费自己的时间和生命

坦诚是一个人的为人之本，而不是任何的加分项

另外，也不要为了遮掩自己的错误，去用 善意的谎言将其替换，其实这是一种本末倒置的操作，事后当局人理解过来后，只会让人更恶心

做法：戳穿最后所谓的“善意谎言”,让自己彻底失去对他的任何信任信任;同时也会还一个清晰的自己

保持热情，行动起来，继续前行

无论我们经历过什么，也要让自己保持自己最初的热爱和选择；在苟且的生活中，慢慢需要和拼凑属于自己的生活碎片;当最后的结果哪怕是不尽如意的时候，也是有碎片可以支撑我们继续前行

在属于自己的萌芽期和黑暗期，去坚持自己

在看不到前方任何希望的时候，我们不妨让自己多做点和多坚持下，也许下次就能看到前进的方向和目标

一定要记住,永远要记住，找寻自己的道路上，始终让自己一个人继续前行，哪怕会经历漫长的黑暗，哪怕只有一瞬间的光芒，就是那一瞬间会变成自己内心永远的光

保持自己善良和良知

我这一生,自从明白事理后，自己内心始终有一杠称，永远不要做没有良知的事情以及千万不要抛弃自己的善良

🤗 总结归纳

我会继续完善自己,去贯穿自己;同时也希望自己要尽快的彻底恢复过来,虽然已经好了很多，但是还是缺少许多，得慢慢的恢复过来

我会在漫长的黑暗期以及萌芽期，去坚持和贯彻自己

最后，此篇碎碎念写于2023-12-08;把时间交还自己,我们回头后再来看看这个碎碎念,是不是会有不同的感悟和理解

📎 参考文章

💡 如果你也认为这篇生活碎碎念帮助到你的话，

😀 这里写文章的前言：
看摄影文章进行一个笔记记录
一个合格的摄影师可以恰当利用镜头虚化所带来的视觉效果,主动控制虚化范围

文件格式:

• RAW: 相机能记录的不加任何渲染的原始图片格式
• JPEG: 相机经过自己的系统和算法算出来的图片

📝 光圈

简介

光圈是镜头里用来控制镜头孔径大小的部件

孔越小,通过的光自然就越少,相机的感光原件接收到的光少了,画面就会越暗;孔越大,通光量越大,画面就越亮

f值小的是大光圈,f值大的是小光圈

在不考虑镜头焦段的情况下,同一枚镜头,光圈越大,景深越浅(照片中清晰的范围越小);光圈越小,景深越大(照片中清晰的范围越大)

看背景后的问题;可以看到f越大,背景其越清晰

物距: 相机离物理的距离;物距越近,景深也就越浅

长焦镜头: 压缩画面,压缩空间感

焦段越长,视角越窄,景深越浅,透视畸变越弱;焦段越短,视角越宽,景深越大,透视畸变越强

📝 ISO

感光度: 感光度就是相机对光的敏感程度; ISO其实是把ASA和DIN捏合在一起的一种计量单位

拉高ISO的代价就是会让画面产生噪点,过高的ISO会直接影响画面的纯净度

白平衡:

当我们在昏黄的灯光下拍一张白纸，白纸因为灯光照射的原因，会是黄色的；我们在日落之后拍一张白纸，白纸因为天空光线的原因，大概率会是蓝色的。虽然都是白纸，但在不同的光线条件下，它会变成不同的颜色，而相机上的白平衡就是用来平衡这个白色的，让白色在任何情况下都是白色。当白色是准确的白色，而不是乳白、象牙白、冷白、粉白这些飘忽不定的白色，其他颜色也就会跟着该是什么颜色就是什么颜色，以此来矫正一张照片的色温，防止照片偏色

宽容度:

指的是感光元件所能正确容纳的画面亮度反差的范围,说白了就是,画面最亮的部分和画面最暗的部分,能不能被相机以不损失成像细节的方式给拍下来

如果能,叫宽容度大;如果不能,扩容度小

HDR:高动态范围成像

亮的地方不过曝,暗的地方不死黑;实现的基本原理,在相机上,都是靠多帧合成

📝 测光

光比:

照明环境下,被摄物体暗面与亮面的受光比例

光比越大,明暗反差也就越大,也就是俗称的”对比度”越高,画面中明亮的部分和阴影部分之间的对比就越明显;光比越小,明暗反差就越小,对比度越低,画面中明亮部分和阴影部分之间的对比就越不明显

🤗 总结归纳

📎 参考文章

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
计划一个开源的数据平台; 参考许多数据中台的公司产品 以及 开源项目，进行一个整体的总结;可以大致归纳到如下一些点

• 离线
• 实时
• 算法
• 数据服务开发
• 数据质量检查
• 数据安全
• 数据资产
• 调度任务
• 环境模块

📝系统配置

最大力度以项目为隔离,来进行隔离 资源/用户/环境 等信息

进行如下的内容配置:

• 部门 & 租户
• 用户 & 角色
• 项目 ——> 项目资源(比如yarn,hdfs存储资源,数据源,集群资源)
• 业务流程(每个项目下有多个业务流程)
• 项目配置(比如这个项目的默认参数等)

📝离线开发

开发系统设置

• 数据交换 和 数据集成 ： 数据的同步，数据库的同步，csv/execl同步,非结构化数据同步
• 数据开发
  1. 传统数据库 ： MySql / GaussDB / Oracle / PostgreSQL / SqlServer / DB2 等数据库
  2. 大数据组件： Spark(Sparl/SparkSql/pySpark) / Hive / HBase 等
  3. 语言层面: python/shell/perl
  4. 建表的DDL
  5. 资源文件 : 不同文件格式的类型

表信息

主要分为数据源类型,以及每种数据源类型的对应的数据库(也就是在项目配置中进行配置了的)

不同的数据库类型,比如下面的:

hive/mysql/oracle等

运行记录

对执行的信息进行记录

资源文件

对资源文件进行上传,保存以及展示等信息处理(主要是上传到hdfs上)

自定义函数开发

• Hive函数
• 其它函数

离线作业

新建业务流程(可以简单的理解为一个工作流)

比如 大屏A , 大屏B , 大屏 C 都可以分别建设一条工作流

新建离线作业

• 数据同步,抽取数据

  1. 数据源配置: 源头表信息 ——> 目的表信息
  2. 字段映射关系
  3. 参数控制

  属性配置:

  • 使用的资源组
  • 运行参数
  • 本节点输入参数
  • 本节点输出参数
  • 依赖资源

  调度配置:

  • 生成实体的方法
  • 生效日期
  • 定时corn表达式(调度周期,根据天/星期/月等进行配置)
  • 调度优先级别
  • 调度依赖: 添加上下游节点 或者 将自身重置为根节点
  • 调度作用的范围: 当前业务流程 / 当前项目 / 当前租户

• 脚本开发: 针对不同的数据库进行不同的脚本(还可以选择数据库);不同类型

  1. Spark : 提交作业的方式,是否数据湖的format文件格式等,使用的版本,spark的参数; 调度的配置依赖上下游的作业
  2. Hive : 无需多的选择,默认的hive设置即可
  3. MySql: 数据源类型的选择(假设我配置了多个数据源,是可以进行选择执行和提交;提交版本和发布)
  4. hbase: 无需多的配置; 本节点输入参数,本节点输出参数
  5. 传统数据库: 支持多个数据源的,都是可以进行选择的,然后进行脚本的编写
  6. 常规语言开发: 对常规的语言进行开发设置(python,shell)

• 建表作业: 不同数据库类型的建表脚本进行开发(不参与工作流进行发布)

📝实时开发

系统属性设置

开发系统属性设置:

• 数据集成,比如 Flink CDC 等同步

实时计算

• FlinkSQL
• Flink
• Flink On 数据湖

建表语句

• Flink DDL
• Flink On 数据湖 DDL

资源文件类型

• jar
• py
• txt
• json
• xml
• 等等

实时运行的历史

对实时运行的历史进行一个记录

实时表的管理

对实时的表进行获取和管理

函数管理

• 系统函数
• 自定义函数

实时任务开发

系统参数

• checkpoint 是否开启
• checkpoint的模式是什么配置
• checkpoint的超时设置
• checkpoint的路径设置
• checkpoint保留的个数
• 日志配置

📝服务开发

自定义函数开发

对应一些便捷的函数等进行设置自定义开发

自定义SQL的API开发

• 对应业务流程的选择,也是将什么样的业务给暴露给外侧
• API的名称和请求路径
• 请求方式 和 返回类型的配置
• 调用的频率和超时时间的设置

环境的选择:

• 数据源类型(比如Mysql,Oracle等;关系型或者mpp型居多,如果是hive或者是spark的话，不是特别建议)
• 然后选择对应的 数据源 下面的数据库 ， 来进行脚本的开发，将脚本执行的结果拿到返回数据给返回回去
• API常见的一些分页设置等

📝运维中心

• 对我们的DDL进行统一运维处理
• 对我们的离线和实时,统一的任务调度和处理

🤗 总结归纳

📎 参考文章

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
记录各种软件好用的插件

📝 Google浏览器插件

沉浸式翻译

这里我已 Spring 官网为例，它会翻译每段，效果还是很好的

Sexy Undo Close Tab

记录你刚刚关闭的网页，不小心关错了，再也不用去历史记录中进行查找

SuperCopy 超级复制

一键破解禁止右键、破解禁止选择、破解禁止复制、破解禁止粘贴，启用复制，启用右键，启用选择，启用粘贴

Chrono下载管理器

比如我们有时候找一个网站的静态资源，就可以直接用这个插件的 资源嗅探 功能

Octotree - GitHub code tree

当我们访问 github 项目的时候，就不需要挨个点进去看，通过旁边的 ctotree 就可以看到项目的层级等

微信公众号同步助手

微信公众号文章同步助手，支持头条号、简书、知乎、WordPress

WebChatGPT

📝 Notion插件

Notion流程图插件

1. Diagrams.net：这个插件是Notion的官方合作伙伴插件，它提供了丰富的绘图工具，包括流程图、组织结构图、UML图等。您可以使用它来在Notion中创建专业的流程图。
2. Excalidraw：这个插件允许您在Notion中创建手绘风格的流程图和草图。它提供了简单易用的绘图工具，可以让您快速绘制流程图并进行协作。
3. Miro：Miro是一个在线协作白板工具，它提供了丰富的绘图功能，包括流程图、思维导图、用户旅程图等。您可以在Notion中使用Miro插件，将Miro的流程图嵌入到您的Notion页面中。

📝 IDEA插件

• Bito
• jclasslib Bytecode Viewer
• Maven Helper
• CodeGlance Pro
• Lombok Builder Helper
• MyBatisX
• SonarLint

google浏览器前端插件

React Developer Tools

Vue.js devtools

🤗 总结归纳

总结文章的内容

📎 参考文章

• 一些引用
• 引用文章

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
记录编译各种项目以及开源项目遇到的问题

本地安装jar包
pentaho-aggdesigner-algorithm-5.1.5-jhyde
eigenbase-properties-1.1.4
greenplum-jdbc-5.1.4

📝 缺少jar包本地编译

pentaho-aggdesigner-algorithm-5.1.5-jhyde

jar包

📎 pentaho-aggdesigner-algorithm-5.1.5-jhyde.jar

本地安装指令: -Dfile 切换为自己本地下载存放jar的位置

mvn install:install-file -Dfile=/home/luohong/Downloads/pentaho-aggdesigner-algorithm-5.1.5-jhyde.jar -DgroupId=org.pentaho -DartifactId=pentaho-aggdesigner-algorithm -Dversion=5.1.5-jhyde -Dpackaging=jar

eigenbase-properties-1.1.4

jar包

📎 eigenbase-properties-1.1.4.jar

本地安装指令: -Dfile 切换为自己本地下载存放jar的位置

mvn install:install-file -DgroupId=eigenbase -DartifactId=eigenbase-properties -Dversion=1.1.4 -Dpackaging=jar -Dfile=/home/luohong/Downloads/eigenbase-properties-1.1.4.jar

greenplum-jdbc-5.1.4

jar包

📎 greenplum-jdbc-5.1.4.jar

本地安装指令: -Dfile 切换为自己本地下载存放jar的位置

mvn install:install-file -DgroupId=com.pivotal -DartifactId=greenplum-jdbc -Dversion=5.1.4 -Dpackaging=jar -Dfile=/home/luohong/Downloads/greenplum-jdbc-5.1.4.jar

📝 前端环境配置

查看镜像源设置: npm config get registry

设置镜像源

阿里: npm config set registry https://registry.npm.taobao.org

vite问题

‘vite’ 不是内部或外部命令，也不是可运行的程序 或批处理文件

处理方法: npm i 进行安装

📝 python环境配置

设置镜像源

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

其它镜像源地址

清华：https://pypi.tuna.tsinghua.edu.cn/simple

阿里云：http://mirrors.aliyun.com/pypi/simple/

中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/

华中理工大学：http://pypi.hustunique.com/

山东理工大学：http://pypi.sdutlinux.org/ 

豆瓣：http://pypi.douban.com/simple/

python去除背景方法

• rembg 框架

python相关资源学习

📝 资源记录相关(主要学习资源记录)

AI相关

AI绘画

区块链

📝 IDEA插件记录

📝 资讯资源

📝 想看纪录片

🤗 总结归纳

📎 参考文章

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
数据中台技术记录

📝 数据底座

• CDH闭源前的最后一个版本
• CDP
• USDP
• DataSophon

📝 数据交换(数据集成)

从各种数据源采集结构化和非结构化数据，包括实时数据采集和批量数据采集

将来自不同系统和不同格式的数据进行整合，实现一个统一个的数据视图

数据交换

• API: 采集第三方的API的数据
• 日志采集： 采集应用日志
• 爬虫: 采集网页数据
• 数据源抽取: 直接通过数据源进行抽取

数据集成

数据提取(Data Extraction)

数据清洗（Data Cleaning)

数据转换（Data Transformation）

数据加载（Data Loading）

数据清洗

对采集的数据进行过滤、修正、归一化等,提高数据质量,修复脏数据。

📝 数据开发

离线开发

• Spark
• Hive
• Flink

实时开发

• Kafka
• Spark Streaming
• Flink

算法开发

暂不支持

📝 任务调度

• Azkaban
• Airflow
• 海滩调度器

📝 数据可视化

通告报表,dashboard等对数据和洞见进行直观的展示;帮助用户理解和决策

• Apache Superset:开源的数据可视化和探索工具
• Grafana:开源的数据监测和可视化工具,用于构建监控面板和报表
• Tableau:商业数据可视化工具,用于数据分析和报表制作

数据存储

数据湖,HDFS,数据库等进行存储

• Apache Hive:数据仓库,基于HDFS存储
• Apache HBase:NoSQL数据库,基于HDFS存储
• Apache Kudu:列式存储,基于HDFS存储
• Elasticsearch:搜索引擎,文档型数据库

数据治理

管理数据中台的用户、权限、流程等,确保数据中台的高效和稳定运行

元数据管理

• Apache Atlas:统一元数据管理平台
• datahub[datahub-project/datahub]

数据管理和数据权限

• Apache Atlas:数据治理平台
• Apache Ranger:实现权限管理

数据应用

通过API、数据服务等形式,将数据和分析能力提供给各业务系统使用

开源项目记录

• [https://github.com/DTStack]
• https://github.com/DTStack/chunjun
• https://github.com/DTStack/Taier
• https://github.com/DataLinkDC/dinky
• https://github.com/apache/incubator-streampark
• https://github.com/apache/dolphinscheduler
• https://github.com/ververica/flink-cdc-connectors
• https://github.com/alldatacenter/alldata
• https://github.com/WeBankFinTech/WeDataSphere

🤗 总结归纳

📎 参考文章

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
数仓开发规范

📝 ETL规范(Execl文件)

文档规范

execl表头记录所有表的信息，类似mysql的索引

单个表记录(单个execl页)

ODS作业规范(Execl文件)

模板说明(首页execl)

工程情况(单页execl)

ods作业梳理

数仓命名规范

库命名规范

表命名规范

• 所有层级表必须要加字段包括：etl_load_ts
• 表命名使用英文小写字母，单词之间用下划线分开，总长度不能超过 40 个字符

表类型

明细表：dtl 中间表：mid 信息：info 配置表：cfg
拉链表：zip 临时表：tmp 汇总表：sum 日志表：log
手工填报：imp(开头) 实时表：re

数据周期

时全量：hf 时增量：hi 时快照：hs
日全量：df 日增量：di 日快照：ds
周全量：wf 周增量：wi 周快照：ws
月全量：mf 月增量：mi 月快照：ms
注： df 每天全量（表没有分区），di 每天增量（每天一个分区），ds 每天增量保留
历史到目前记录（一天一个分区）

ods命名规范

• 增量：ods_源库名.o_{表名}_di
• 全量：ods_源库名.o_{表名}_df
• 接口：ods_源库名.o_api_[api 数据名称]_[数据周期]
• 文件：ods_源库名.o_flie_[业务数据名称]_[数据周期]
• 数据量：历史数据量小于 50W 条记录，且未来增长慢的全量同步
• 字段命名规范：字段默认使用源系统的字段名
• 字段名与关键字冲突：在源字段名后加上_col，即源字段名_col

dwd命名规范

{库}.{层级}{业务域}{数据域}{业务内容}{表类型}{数据周期} 例如：dwd_db.dwd_ds_user{order_info}_dtl_di

dws命名规范

{库}.{层级}{业务域}{数据域}{业务内容}{表类型}{数据周期} 例如：dws_db.dws_ds_user{order_info}_sum_di

dim命名规范

{库}.{层级}{pub/维度内容}{数据周期}

例如：dim_db.dim_pub_area_df

其中的 pub 与具体业务无关，各个业务部都可以共用，例如时间维度

ads命名规范

{库}.{层级}{项目内容|自定义}{表类型}_{数据周期} 例如：ads_db.ads_user_dmp_sum_df

临时表

{临时库}.{表名}_tmp{序号} 例如：

dwd_db_tmp.dwd_order_info_dtl_di_tmp01 dwd_db_tmp.dwd_order_info_dtl_di_tmp02

分区表

分区字段：

• 分 mi（00-59） 如 28
• 时 hh（00-23） 如 10
• 日 yyyy-mm-dd 如 2022-09-28
• 月 yyyy-mm 如 2022-09
• 年 yyyy 如 2022

区分表：分区表取数必须要加分区限制,分区注释必须注明根据那个字段进行分区

表分区到时、分分区级别时，表设计使用多级分区 ，如 时分区表；ts：表示日，hh： 表示时；分分区表：ts：表示日，hh：表示时；mi:表示分

实时表命名规范

• 各数仓层次表设计以 re_ 开头
• ODS 层表设计：{库}.re_{ods}{业务域}{数据域}{业务内容}{数据周期}，其他命 名规范见
• DWD 层表设计：{库}.re_{dwd}{业务域}{数据域}{业务内容}{数据周期}，其他命 名规范见
• DWS 层表设计：{库}.re_{dws}{业务域}{数据域}{业务内容}{数据周期}，其他命 名规范见
• DIM 层表设计：{库}.re_{dim}{pub/维度内容}{数据周期}，其他命名规范见

字段类型规范

• 字符：字符串类型使用string
• 数字：整形最大值 10 位以上：bigint ; 整形最大值在 3 位到 9 位：int（不考虑）; 非整形数字类型：decimal(25,10)
• 时间类型：最小粒度为天： date ；时间： timestamp
• 布尔类型是否判断：is_{业务}，不允许出现空值 ; 0: 表示否， 1：表示是

工作流命名

ods

工作流: job_{ods_库名}_{序号} 例如：job_ods_ams

task: 目标表名 例如：o_order_info_df

dwd

工作流: job_dwd_{业务域}{数据域}{序号} 例如：job_dwd_ds_user

task: 目标表名 例如：dwd_ds_user_xxx_df

dws

工作流：job_dws_{业务域}{数据域}{序号} 例如：job_dws_ds_user

task：目标表名 例如：dws_ds_user_xxx_df

ads

工作流：job_ads_{业务域}_{序号} 例如：job_ads_ds

task: 目标表名 例如：ads_user_dmp_xxx_df

数据模型设计

横向分层

ods

操作数据层，即原始数据层。ODS 层有些时候会细分为两层，一个 STG 数据缓冲层，存原 始数据，一个 ODS，存简单清洗的数据

dwd

明细数据层，对数据进行清洗、代码统一、字段统一、格式统一、简单聚合等工作。DWD 层存在的意义是做数据的标准化，为后续的处理提供干净、统一、标准的数据

dws

数据汇总层，按照业务目标，对已经处理好的数据进行横向汇聚、纵向汇总。按照宽表模型 进行数据冗余和预计算，以空间换时间

dim

维度层，即存储所有维度（可以理解为码表）。其实 DIM 不应该单独作为一层，因为从 DWD 层开始向上的所有层都需要用到 DIM 中的内容，是横跨多层的

ads

应用服务层，一般就直接对接 OLAP 分析，或者业务层数据调用接口

纵向分域

主题域通常是联系较为紧密的数据主题的集合，方便寻找和使用数据

dw层

正式库： dw_db 临时库：dw_db

划分依据：按照业务或业务过程划分,比如一个靠销售广告位置的门户网站主题域可能会有 广告域，客户域等，而广告域可能就会有广告的库存，销售分析、内部投放分析等主题

DIM层

正式库： dim_db 临时库：dim_db_tmp

划分依据：按照公司主数据划分

DM层

正式库： dm_db 临时库：dm_db_tmp

划分依据：按照主题域进行划分

ADS层

正式库： ads_db_tables 临时库：ads_db_tmp

划分依据：

1. 根据需求方划分：比如需求方为财务部，就可以设定对应的财务主题域（业务场景）， 而财务主题域里面可能就会有员工工资分析
2. 根据项目划分

🤗 总结归纳

📎 参考文章

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
一个简单的开头,简述这篇文章讨论的问题、目标、人物、背景是什么？并简述你给出的答案。

可以说说你的故事：阻碍、努力、结果成果，意外与转折。

📝 下载包准备

hadoop下载

下载地址：https://archive.apache.org/dist/hadoop/common/

选择我们对应的hadoop版本;比如我这里是是3.1.1就选择3.1.1

win10 需要的脚本下载

https://github.com/cdarlint/winutils/tree/master

选择我们对应的hadoop的版本

对应版本的脚本拷贝

操作一

将 hadoop.ddl 和 winutils.exe 拷贝到 下载的hadoop的版本的bin中

操作二

将 hadoop.ddl 文件同时拷贝一份到 C:\Windows\System32 目录

操作三

配置hadoop中的etc\hadoop的 hadoop-env.cmd 文件的java地址;切换为自己的java路径;

如果是C盘的话，Program Files需要替换为 PROGRA~1 ; 如下

set JAVA_HOME=C:\\PROGRA~1\\Java\\jdk1.8.0_161

操作四: 配置环境变量

HADOO_HOME配置

PATH中配置%HADOOP_HOME%\bin

操作五：测试是否成功

cmd中输入hadoop version;如果可以看到版本，就说明配置是成功的

操作hdfs以及Iceberg

注意点:

1. 通过iceberg和hive去读取hdfs的时候，会读取集群的名字;所以这里需要配置根据集群的名字能映射到NameNode(状态为Active的最保险)
2. 比如这里的usdp215对应的active namenode是 172.21.129.218 节点的话;则在host里进行配置即可
3. 到底就可以通过iceberg或者hdfs等api在win10上读取hadoop的数据等

🤗 总结归纳

📎 参考文章

• https://blog.csdn.net/qq_42970173/article/details/123714605
• https://blog.csdn.net/yy8623977/article/details/124047743

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
Spark3.0.1合并Iceberg的小文件

📝 Iceberg小文件处理

Spark3.0.1

Spark3.0.1版本的sql执行

参数说明:

• 如果有 catalog 的设置的话,在system前面加上 catalog. (catalog是你具体的catalog名字,比如spark_hadoop)
• ods_bigscreen.o_ecuser_list: 具体的数据库名字和表名字
• TIMESTAMP ‘2022-09-08 00:00:00.000’: 该时间之前的数据进行清除
• 1 是保留的版本数量，比如这里的1就是1

CALL system.expire_snapshots('ods_bigscreen.o_ecuser_list', TIMESTAMP '2022-09-08 00:00:00.000', 1)

执行结果如下图:

参数解析:

• deleted_data_files_count 删除对应表的data文件夹个数。如果我们的文件格式选择的是 parquet，那么文件是以 .parquet 结尾，比如 00000-0-0eca9076-9c03-4077-baa9-e68769e15c58-00001.parquet 就是一个数据文件。
• deleted_manifest_files_count: 删除元数据metadata文件夹的数据。其里面列出了组成某个快照（snapshot）的数据文件列表。每行都是每个数据文件的详细描述，包括数据文件的状态、文件路径、分区信息、列级别的统计信息（比如每列的最大最小值、空值数等）、文件的大小以及文件里面数据的行数等信息。其中列级别的统计信息在 Scan 的时候可以为算子下推提供数据，以便可以过滤掉不必要的文件。每次更新会产生多个清单文件。
• deleted_manifest_lists_count: 清单列表也是元数据文件，其里面存储的是清单文件的列表，每个清单文件占据一行。每行中存储了清单文件的路径、清单文件里面存储数据文件的分区范围、增加了几个数据文件、删除了几个数据文件等信息。这些信息可以用来在查询时提供过滤。清单列表也是 avro 格式进行存储的，所以是以 .avro 后缀结尾的；而且这个文件是以 snap- 开头的，比如 snap-7389540589641972921-1-aa90f6ed-aee2-49c7-a61c-bd13ed411c66.avro，其中 7389540589641972921 这串数字是代表快照 id（snapshot_id）。每次更新都会产生一个清单列表文件。

pySpark进行处理

使用 use 获取 某个数据库的表，然后对这些表进行 合并小文件处理

#!/user/bin/env spark-python
#-*-coding:utf-8 -*-
import sys,os
from pyspark.sql import SparkSession

# init spark
def getSpark():
    # spark连接初始化
    spark = SparkSession \
        .builder \
        .appName("PySpark_Platform_DataLake") \
        .config("spark.jars.packages","org.apache.iceberg:iceberg-spark3:0.13.2") \
        .config("spark.sql.extensions","org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions") \
        .config("spark.sql.catalog.spark_catalog","org.apache.iceberg.spark.SparkSessionCatalog") \
        .config("spark.sql.catalog.spark_catalog.type","hive") \
        .config("spark.sql.catalog.iceberg","org.apache.iceberg.spark.SparkCatalog") \
        .config("spark.sql.catalog.iceberg.type","hadoop") \
        .config("spark.sql.catalog.iceberg.warehouse","hdfs:///yundeecluster/datalake") \
        .enableHiveSupport() \
        .getOrCreate()
    return spark

        
if __name__ == "__main__":
        spark = getSpark()
        spark.sql("use xiaobao_bigscreent")
        df = spark.sql("show tables")
        for row in df.collect():
                if row['tableName'] == 'login_record_info':
                    continue;
                baseTable = 'xiaobao_bigscreent.' + row['tableName']
                # 重写数据文件, data 目录
                rewrite_manifests_sql = "CALL system.rewrite_manifests('{0}')".format(baseTable)
                # 重写 metadata 目录
                rewrite_data_files_sql = "call system.rewrite_data_files('{0}')".format(baseTable)
                # 清除快照过期文件
                snapshots_sql = "CALL system.expire_snapshots('{0}', TIMESTAMP '2122-12-30 00:00:00.000', 1)".format(baseTable)
                # 清除未关联上数据的 metedata 目录
                remove_orphan_files_sql = "CALL system.remove_orphan_files(table => '{0}')".format(baseTable)
                print('开始库和表是:')
                print(baseTable)
                spark.sql(rewrite_data_files_sql)
                spark.sql(rewrite_manifests_sql)
                spark.sql(snapshots_sql)
                spark.sql(remove_orphan_files_sql)

建表语句

在见表语句上加上对应的参数配置

CREATE TABLE ${CataLog名称}.${库名}.${表名} ( id bigint, name string) using icebergPARTITIONED BY ( loc string) TBLPROPERTIES ( 'write.metadata.delete-after-commit.enabled'= true,'write.metadata.previous-versions-max' = 3)

🤗 总结归纳

📎 参考文章

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
CDH搭建，减少了hadoop集群生态的维护

📝 CDH端口开放

修改主机hosts配置

host

比如这里的配置,每台集群的机器都需要配置, 具体自身的ip和hostname等进行配置

# 在文件末尾添加每个实例的内网IP及对应的hostname

172.17.79.117   hadoop102       hadoop102
172.17.79.116   hadoop103       hadoop103
172.17.79.118   hadoop104       hadoop104

ssh免密配置

配置所有机器之间相互的免密
CDH的服务是有server和agent概念的，agent收集到往server进行汇报情况

执行ssh-keygen -t rsa并敲三次回车，会在我们的/root/.ssh目录下生成两个文件id_rsa（私钥）、id_rsa.pub（公钥）

ssh-keygen -t rsa
cd .ssh

将公钥拷贝到免密登录的目标机器上

ssh-copy-id hadoop102

ssh-copy-id hadoop103

ssh-copy-id hadoop104

每台机器上重复ssh等操作

集群同步脚步

vim xsync : 将下面的脚步内容给复制到 xsync 中

chmod u+x xsync : 复制完值，给脚步加上对应的权限

#!/bin/bash
#1. 判断参数个数
if [ $# -lt 1 ]
then
  echo Not Enough Arguement!
  exit;
fi
#2. 遍历集群所有机器
for host in hadoop102 hadoop103 hadoop104
do
  echo ====================  $host  ====================
  #3. 遍历所有目录，挨个发送
  for file in $@
  do
    #4. 判断文件是否存在
    if [ -e $file ]
    then
      #5. 获取父目录
      pdir=$(cd -P $(dirname $file); pwd)
      #6. 获取当前文件的名称
      fname=$(basename $file)
      ssh $host "mkdir -p $pdir"
      rsync -av $pdir/$fname $host:$pdir
    else
      echo $file does not exists!
    fi
  done
done

同步执行指令脚步

vim xcall.sh

chmod u+x xcall.sh

#! /bin/bash

for i in hadoop102 hadoop103 hadoop104
do
        echo --------- $i ----------
        ssh $i "$*"
done

防火墙检测是否关闭

查看状态: sudo systemctl status firewalld

禁用： sudo systemctl disable firewalld

停止： sudo systemctl disable firewalld

检查hostname是否成功

hostname

hostnamectl status

禁用SELinux mode

安全增强的Linux (SELinux)允许通过策略设置访问控制。如果在部署CDH时遇到困难，请在将CDH部署到集群之前，在每个主机上将SELinux设置为permissive模式

getenforce

禁用透明大页配置

在每台服务器上分别执行

echo never > /sys/kernel/mm/transparent_hugepage/defrag
echo never > /sys/kernel/mm/transparent_hugepage/enabled
echo 'echo never > /sys/kernel/mm/transparent_hugepage/defrag' >> /etc/rc.local
echo 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' >> /etc/rc.local

# 前两行代码只能暂时生效，当重启后配置会消失
[root@hadoop102 parcel-repo]# echo never > /sys/kernel/mm/transparent_hugepage/defrag
[root@hadoop102 parcel-repo]# echo never > /sys/kernel/mm/transparent_hugepage/enabled

# 永久生效需要把信息加到启动项中
[root@hadoop102 parcel-repo]# echo 'echo never > /sys/kernel/mm/transparent_hugepage/defrag' >> /etc/rc.local
[root@hadoop102 parcel-repo]# echo 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' >> /etc/rc.loca

启动NTP服务

CDH要求在集群中的每台机器上配置一个网络时间协议(NTP)服务。大多数操作系统使用时间同步的ntpd服务。
注：RHEL 7兼容的操作系统默认使用chronyd而不是ntpd。如果chronyd正在运行，Cloudera Manager将使用它来确定主机时钟是否同步。否则，Cloudera Manager使用ntpd

ps -ef |grep chronyd

yum需要安装的源

yum -y install httpd

systemctl status httpd

systemctl start httpd

# 设置开机自启
systemctl enable httpd.service

yum源工具安装

yum -y install yum-utils createrepo

yum -y install yum-utils createrepo

导入 cm 资源包

创建/var/www/html/cm文件夹

将资料包中cm文件夹下的文件放入/var/www/html/cm文件夹中

创建/var/www/html/cm文件夹
mkdir cm

创建 repo

使用createrepo命令创建本地yum源;在/etc/yum.repos.d/文件夹下创建新的yum repo文件

使用createrepo命令创建本地yum源

配置了hosts文件的情况下我们可以直接使用hadoop102作为域名访问

===========手动编写repo============
vim /etc/yum.repos.d/cloudera-manager.repo
===========把下面五行代码写入repo文件中=========
[cloudera-manager]
name=Cloudera Manager, Version yum
baseurl=http://hadoop102/cm
gpgcheck=0
enabled=1

清除缓存

清除缓存并建立新的元数据缓存

// 清除缓存
yum clean all

// 建立元数据缓存
yum makecache

xsync /etc/yum.repos.d/cloudera-manager.repo 
yum clean all
yum makecache

# 验证源是否配置生效
yum list | grep cloudera-manager

CM及依赖组件安装

java环境

xcall yum -y install oracle-j2sdk1.8.x86_64

配置java的环境变量，因为我们在上面已经把/etc/profile中的内容追加到/root/.bashrc中，所以我们现在只需要配置/root/.bashrc文件即可

vim /root/bin/setjavahome.sh

sed -i '$a\# JAVA_HOME' /root/.bashrc
sed -i '$a\export JAVA_HOME=/usr/java/jdk1.8.0_181-cloudera' /root/.bashrc
sed -i '$a\export PATH=$JAVA_HOME/bin:$PATH' /root/.bashrc
sed -i '$a\export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar' /root/.bashrc

xsync /root/bin/setjavahome.sh

# 在三台上同时执行添加环境变量的和同步环境变量的操作
xcall  bash /root/bin/setjavahome.sh && source /root/.bashrc

# 验证java是否安装成功
xcall.sh java -version

mysql安装

wget -v http://repo.mysql.com/mysql-community-release-el7-5.noarch.rpm
sudo rpm -ivh mysql-community-release-el7-5.noarch.rpm
sudo yum -y update
sudo yum -y install mysql-server
sudo systemctl start mysqld

sudo systemctl stop mysqld

InnoDB log files 做备份

mkdir /root/backup/
mv /var/lib/mysql/ib_logfile0 /var/lib/mysql/ib_logfile1 /root/backup/

/etc/my.cnf文件修改

[mysqld]
datadir=/var/lib/mysql
socket=/var/lib/mysql/mysql.sock
# To prevent deadlocks, set the isolation level to READ-COMMITTED.
transaction-isolation = READ-COMMITTED
# Disabling symbolic-links is recommended to prevent assorted security risks;
# to do so, uncomment this line:
symbolic-links = 0

key_buffer_size = 32M
max_allowed_packet = 16M
thread_stack = 256K
thread_cache_size = 64
query_cache_limit = 8M
query_cache_size = 64M
query_cache_type = 1

#Allow 100 maximum connections for each database and then add 50extra connections. For example, for two databases, set the maximum connections to 250. If you store five databases on one host (the databases for Cloudera Manager Server, Activity Monitor, Reports Manager, Cloudera Navigator, and Hive metastore), set the maximum connections to 550.
max_connections = 550
#expire_logs_days = 10
#max_binlog_size = 100M

#log_bin should be on a disk with enough free space.
#Replace '/var/lib/mysql/mysql_binary_log' with an appropriate path for your
#system and chown the specified folder to the mysql user.
#如果需要替换mysql的log文件存放位置，需要此处拥有足够的空间并且把文件夹的属主改为mysql用户
log_bin=/var/lib/mysql/mysql_binary_log

#In later versions of MySQL, if you enable the binary log and do not set
#a server_id, MySQL will not start. The server_id must be unique within
#the replicating group.
server_id=1

binlog_format = mixed

read_buffer_size = 2M
read_rnd_buffer_size = 16M
sort_buffer_size = 8M
join_buffer_size = 8M

# InnoDB settings
innodb_file_per_table = 1
innodb_flush_log_at_trx_commit  = 2
innodb_log_buffer_size = 64M
innodb_buffer_pool_size = 4G
innodb_thread_concurrency = 8
#The default settings in the MySQL installations in most distributions use conservative buffer sizes and memory usage. Cloudera Management Service roles need high write throughput because they might insert many records in the database. Cloudera recommends that you set the innodb_flush_method property to O_DIRECT.
innodb_flush_method = O_DIRECT
innodb_log_file_size = 512M

[mysqld_safe]
log-error=/var/log/mysqld.log
pid-file=/var/run/mysqld/mysqld.pid
sql_mode=STRICT_ALL_TABLES

初始化mysql

配置my.cnf完成后，启动MySQL;需要注意:

1. 因为当前无密码，所以启动时直接回车
2. Disallow root login remotely 选项需要输入 N , 这样 root 用户才能远程访问

sudo systemctl enable mysqld

sudo systemctl start mysqld

sudo /usr/bin/mysql_secure_installation

[...]这里需要配置密码，密码可以为简单密码，例如123456
Enter current password for root (enter for none):（这里需要直接回车）
OK, successfully used password, moving on...
[...]
Set root password? [Y/n] Y
New password:（这里输入自定义的密码）
Re-enter new password:（这里输入自定义的密码）
Remove anonymous users? [Y/n] Y
[...]
Disallow root login remotely? [Y/n] N
[...]
Remove test database and access to it [Y/n] Y
[...]
Reload privilege tables now? [Y/n] Y
All done!

将JDBC的jar放入到/usr/share/java文件夹中

mkdir -p /usr/share/java/

cd /usr/share/java/
wget https://cdh-sgg.oss-cn-shenzhen.aliyuncs.com/fileshare/mysql-connector-java-5.1.46-bin.jar

mv mysql-connector-java-5.1.46-bin.jar mysql-connector-java.jar

创建各用户数据库（注意hive的数据库叫metastore）

mysql -u root -p
Enter password:
# 建表及修改权限的格式：
CREATE DATABASE <database> DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;
GRANT ALL ON <database>.* TO '<user>'@'%' IDENTIFIED BY '<password>';
# 以下是需要执行的SQL语句
# 替换之后需要执行的SQL为：
CREATE DATABASE scm DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;
CREATE DATABASE amon DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;
CREATE DATABASE rman DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;
CREATE DATABASE hue DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;
CREATE DATABASE metastore DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;
CREATE DATABASE sentry DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;
CREATE DATABASE nav DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;
CREATE DATABASE navms DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;
CREATE DATABASE oozie DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;
GRANT ALL ON scm.* TO 'scm'@'%' IDENTIFIED BY 'scm';
GRANT ALL ON amon.* TO 'amon'@'%' IDENTIFIED BY 'amon';
GRANT ALL ON rman.* TO 'rman'@'%' IDENTIFIED BY 'rman';
GRANT ALL ON hue.* TO 'hue'@'%' IDENTIFIED BY 'hue';
GRANT ALL ON metastore.* TO 'hive'@'%' IDENTIFIED BY 'hive';
GRANT ALL ON sentry.* TO 'sentry'@'%' IDENTIFIED BY 'sentry';
GRANT ALL ON nav.* TO 'nav'@'%' IDENTIFIED BY 'nav';
GRANT ALL ON navms.* TO 'navms'@'%' IDENTIFIED BY 'navms';
GRANT ALL ON oozie.* TO 'oozie'@'%' IDENTIFIED BY 'oozie';
#####注意此处再授权一个本主机名地址，不然web页面配置很容易出错，注意修改本地主机名hostname
GRANT ALL ON amon.* TO 'amon'@'hadoop102' IDENTIFIED BY 'amon';

FLUSH PRIVILEGES;

show grants for 'amon'@'%';  
show grants for 'rman'@'%';  
show grants for 'hive'@'%';
show grants for 'hue'@'%';
show grants for 'oozie'@'%';

quit

systemctl restart mysql.service

通过yum安装daemons,agent,server

yum list | grep cloudera-manager
yum -y  install cloudera-manager-daemons cloudera-manager-agent cloudera-manager-server

yum list | grep cloudera-manager
yum -y  install cloudera-manager-daemons cloudera-manager-agent

[root@hadoop102 ~]# sudo /opt/cloudera/cm/schema/scm_prepare_database.sh mysql scm scm
Enter SCM password: (scm)

JAVA_HOME=/usr/java/jdk1.8.0_181-cloudera
Verifying that we can write to /etc/cloudera-scm-server
Creating SCM configuration file in /etc/cloudera-scm-server
Executing:  /usr/java/jdk1.8.0_181-cloudera/bin/java -cp /usr/share/java/mysql-connector-java.jar:/usr/share/java/oracle-connector-java.jar:/usr/share/java/postgresql-connector-java.jar:/opt/cloudera/cm/schema/../lib/* com.cloudera.enterprise.dbutil.DbCommandExecutor /etc/cloudera-scm-server/db.properties com.cloudera.cmf.db.
log4j:ERROR Could not find value for key log4j.appender.Alog4j:ERROR Could not instantiate appender named "A".
[2021-06-22 21:14:01,762] INFO     0[main] - com.cloudera.enterprise.dbutil.DbCommandExecutor.testDbConnection(DbCommandExecutor.java) - Successfully connected to database.
All done, your SCM database is configured correctly!

配置本地Parcel存储库

systemctl start cloudera-scm-server
# 重启命令为：systemctl start cloudera-scm-server

# 可以用下面命令查看server的信息
tail -f /var/log/cloudera-scm-server/cloudera-scm-server.log
# 另开启一个窗口，监控日志中是否提示启动成功
tail -f /var/log/cloudera-scm-server/cloudera-scm-server.log|grep "Started Jetty server"
# 也可以用下面命令查看端口号占用情况
netstat -tunlp | grep 7180

# 当你看到以下信息时候 证明启动成功
INFO WebServerImpl:com.cloudera.server.cmf.WebServerImpl: Started Jetty server. 
下面可能会出现报错信息，这个是因为2021年CDH开始正式收费，从官方网站渠道已经无法拉取到任何安装包和校验文件，所以我们在4.4章节中手动上传文件进行校验。
2022-03-01 14:08:23,203 ERROR ParcelUpdateService:com.cloudera.parcel.components.ParcelDownloaderImpl: Failed to download manifest. Status code: 401 URI: https://archive.cloudera.com/p/cdh6/6.3.4/parcels/manifest.json
2022-03-01 14:08:23,203 ERROR ParcelUpdateService:com.cloudera.parcel.components.ParcelDownloaderImpl: Could not retrieve repository info for repo https://archive.cloudera.com/cdh6/6.3/parcels/. Got HTTP response code 401

# 此时登录网页
http://你的hadoop102的IP地址:7180
# 就能访问CDH集群 
默认的用户名：admin
默认的密码为：admin

参数配置

• dfs.client.use.datanode.hostname
• yarn.nodemanager.resource.cpu-vcores
• yarn.scheduler.maximum-allocation-vcore
• yarn.scheduler.maximum-allocation-mb
• yarn.nodemanager.resource.memory-mb
• spark.dynamicAllocation.enabled

调度相关参数设置:

yarn.scheduler.capacity.root.queues
yarn.scheduler.capacity.root.capacity
yarn.scheduler.capacity.root.spark.capacity
yarn.scheduler.capacity.root.hive.capacity

🤗 总结归纳

📎 参考文章

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
RocketMQ 基础知识

📝 整理流程

📝 模型概念

📔主题（Topic）

主题是 Apache RocketMQ 中消息传输和存储的顶层容器，用于标识同一类业务逻辑的消息

• 定义数据的分类隔离;在Apache RocketMQ的方案设计中，建议将不同业务的数据拆分到不同的主题中管理，通过主题实现存储的隔离性和订阅隔离性
• 主题下存在 MessageQueue : 队列，才是topic实际的操作单元，一个topic可能有多个队列，方便扩容

在 Apache RocketMQ 架构中，主题属于顶层资源和容器，拥有独立的权限管理、可观测性指标采集和监控等能力，创建和管理主题会占用一定的系统资源。因此，生产环境需要严格管理主题资源，请勿随意进行增、删、改、查操作

📔队列（MessageQueue）

队列是RocketMQ实际存储和传输的实际容器，也是RocketMQ消息的最小存储单元。Apache的一个主题由多个队列组成，以实现队列数量的水平拆分和队列内部的流式存储，在向内发送消息，但实际消息发送到该主题下的某个队列里

队列数量的设置应遵循少用够用原则，避免随意添加队列数量，造成下列问题

• 集群元数据膨胀：RocketMQ会以队列的粒度采集指标和监控数据，队列过多容易造成管控元数据膨胀
• 客户端压力过大：RocketMQ的消息读写都是针对队列进行操作，队列过多容易产生空轮询请求，增加系统负荷

📔消息（Message）

• 消息由生产者初始化并发送到RocketMQ服务端
• 消息按照达到RocketMQ服务端的顺序存储到队列中
• 消费者按照订阅的关系从RocketMQ服务端中获取消息并消费

四种类型：

• Normal： 普通消息，消息本身无特殊语义，消息之间也没有任何关联
• FIFO：顺序消息，RocketMQ通过消息分组 MessageGroup 标记一组特定消息的先后顺序，可以保证消息的投递顺序严格按照消息发送时的顺序
• Delay：定时/延时消息，通过指定延时时间控制消息生产后不要立即投递，而是在延时间隔后才对消费者可见
• Transaction：RocketMq支持事务消息，支持应用数据库更新和消息的事务一致性保障

📔生产者（Producer）

生产者是RocketMQ系统中用来构建并传输消息服务端的运行实体

生产者通常被集成在业务系统中，将业务消息按照要求封装成RocketMQ的消息(Message)并发送到服务端

• 发送方式：生产者可通过API接口设置消息发送的方式。Apache RocketMQ 支持同步传输和异步传输。
• 批量发送：生产者可通过API接口设置消息批量传输的方式。例如，批量发送的消息条数或消息大小。
• 事务行为：Apache RocketMQ 支持事务消息，对于事务消息需要生产者配合进行事务检查等行为保障事务的最终一致性

📔消费者分组（ConsumerGroup）

消费者分组是 Apache RocketMQ 系统中承载多个消费行为一致的消费者的负载均衡分组

和消费者不同，消费者分组并不是运行实体，而是一个逻辑资源。在 Apache RocketMQ 中，通过消费者分组内初始化多个消费者实现消费性能的水平扩展以及高可用容灾

在消费者分组中，统一定义以下消费行为，同一分组下的多个消费者将按照分组内统一的消费行为和负载均衡策略消费消息

• 订阅关系：Apache RocketMQ 以消费者分组的粒度管理订阅关系，实现订阅关系的管理和追溯
• 投递顺序性：Apache RocketMQ 的服务端将消息投递给消费者消费时，支持顺序投递和并发投递，投递方式在消费者分组中统一配置
• 消费重试策略： 消费者消费消息失败时的重试策略，包括重试次数、死信队列设置等

整体流程：

1. 消息有生产者初始化并发送到RocketMQ服务端
2. 消息按照到达RocketMQ服务端顺序存储到主题指定队列中
3. 消费者按照指定的订阅关系从RocketMQ服务端中获取消息并消费

📔消费者（Consumer）

消费者是 Apache RocketMQ 中用来接收并处理消息的运行实体。 消费者通常被集成在业务系统中，从 Apache RocketMQ 服务端获取消息，并将消息转化成业务可理解的信息，供业务逻辑处理

📔订阅关系（Subscription）

定义：消息过滤规则的类型。订阅关系中设置消息过滤规则后，系统将按照过滤规则匹配主题中的消息，只将符合条件的消息投递给消费者消费，实现消息的再次分类

• TAG过滤：按照tag字符串进行全文过滤匹配
• SQL92过滤：按照SQL语法对消息属性进行过滤匹配

消息持久化

• Commitlog: 存储消息的元数据，所有的消息都会按照顺序存入到commitLog文件当中;CommitLog是由多个文件组成，每个文件固定大小1G;以第一条偏移量为名
• ConsumerQueue：存储消息在CommitLog的索引；一个MessageQueue一个文件，记录当前MessageQueue被那些消费者组消费到了那条数据
• IndexFile: 为了消息查询提供了一种通过key或者时间区间来查询消息的方法，这种通过IndexFile来查找消息的方法不影响发送和消费消息的主流程
• checkpoint:数据存盘检查;主要记录commitLog文件,consumerQueue文件以及IndexFile文件最后一次刷盘的时间戳
• config/*.json: 这些文件是将RocketMQ的一些关键配置信息进行存盘保存。例如Topic配置，消费者组配置，消费者组消息偏移量offset等等一些信息
• abort: 该文件用来RocketMQ判断程序是否正常关闭的一个标识文件。正常情况下，会再启动创建，而关闭服务时删除。但是如果遇到一些宕机，或者kill -9这些非正常的关闭服务，这个abort文件就不会被删除；因此RocketMQ就可以判断上一次服务是非正常关闭，后续就会做一些数据恢复的操作

commitLog

CommitLog存储了所有的消息实体；所有生产者发过来的消息，都会无差别的依次的存储到CommitLog文件当中；

好处： 减少查找目标文件的时间，让消息以最快的速度落盘

对比Kafka存文件，需要寻找消息所属的Partition文件，在完成写入，当Topic较多的时候，这样的Partition寻址就会比较浪费时间，所以Kafka不适合多Topic的场景

RocketMQ的这种快速落盘的方式在多Topic的场景下，优势会比较明显

commitLog的文件大小是固定的，但是其存储的每个消息单元长度是不固定的

正因为消息的记录大小不固定，所以RocketMQ在每次存CommitLog文件时，都会去检查当前CommitLog文件空间是否足够，如果不够的话，会重新创建一个CommitLog文件

ConsumeQueue

consumeQueue文件主要是加速消费者的消费索引；它的每个文件夹对应RocketMQ中的一个MessageQueue，文件夹下的文件记录了每个MessageQueue中的消息在CommitLog文件当中的偏移量；这样，消费者通过ConsumeQueue文件，就可以快速找到CommitLog文件中感兴趣的消息记录；而消费者在ConsumeQueue文件当中的消费进度，会保存在config/consumerOffset.json文件中

每个ConsumeQueue文件由固定30万个固定大小20byte的数组块组成，数据块的内容包括：msgPhyOffset(8 byte,消息在文件中的起始位置) + msgSize(4 byte,消息在文件中占用的长度) + msgTagCode(8 byte,消息的tag的hash值)

IndexFile

辅助消息的检索；消费者进行消息消费时，通过ConsumeQueue文件就足够完成消息检索了，但是如果按照MessageId或者messageKey来检索文件，就不够了（比如RocketMQ的管理台）；IndexFile文件就是用来辅助这类消息检索的

他的文件名比较特殊，不是以消息偏移量命名，而是用的时间命名。但是其实，他也是一个固定大小的文件

文件由 indexHeader(固定40byte) + slot(固定500w个，每个固定20byte) + index(最多500w*4个,每个固定20byte)三部分组成

过期文件删除

消息既然要持久化,就必然有对应的删除机制

RocketMQ内置了一套过期文件的删除机制

如何判断过期文件

RocketMQ中,CommitLog文件和ConsumeQueue文件是以偏移量命名的,对于非当前写的文件，如果超过了一定的保留时间，那么这些文件都会被认为是过期文件，随时可以删除。

保留时间就是broker.conf中配置的fileReservedTime属性

注意，RocketMQ判断文件是否过期的唯一标准就是非当前写文件的保留时间，而并不关心文件当中的消息是否被消费过。所以，RocketMQ的消息堆积也是有时间限度的

如何删除过期文件

RocketMQ内部有一个定时任务，对文件进行扫描，并且触发文件删除的操作。用户可以指定文件删除操作的执行时间。在broker.conf中deleteWhen属性指定。默认是凌晨四点

RocketMQ还会检查服务器的磁盘空间是否足够，如果磁盘空间的使用率达到一定阈值，也会触发过期文件删除；所以RocketMQ官方就特别建议，borker的磁盘空间不要少于4G

高效写文件

零拷贝加速文件读写

零拷贝是操作系统层面提供的一种加速文件读写的操作机制，对应多的开源项目都在大量使用零拷贝，来提升IO操作的性能

对于java层面，对应着mmap和sendFile两种方式

理解CPU拷贝和DMA拷贝

操作系统对于内存空间，是分为用户态和内核态的。用户态的应用程序无法直接操作硬件，需要通过内核空间进行操作转换，才能真正操作硬件。这其实是为了保护操作系统的安全。正因为如此，应用程序需要与网卡、磁盘等硬件进行数据交互时，就需要在用户态和内核态之间来回的复制数据。而这些操作，原本都是需要由CPU来进行任务的分配、调度等管理步骤的，早先这些IO接口都是由CPU独立负责，所以当发生大规模的数据读写操作时，CPU的占用率会非常高

之后，操作系统为了避免CPU完成被各种IO调用给占用，引入了DMA(直接存储器).有DMA来负责这些频繁的IO操作

DMA是一套独立的指令集，不会直接占用CPU的计算资源；这样CPU就不需要参与具体的数据复制的工作，只需要管理DMA权限即可

DMA拷贝极大的释放了CPU的性能，因此他的拷贝速度会比CPU拷贝要快很多；但是DMA拷贝本身，也在不断优化

引入DMA拷贝之后，在读写请求的过程中，CPU不需要参与具体的工作，DMA可以独立完成数据在系统内部的复制。但是数据的复制，依然需要借助数据总线进行；但系统内的IO操作过多时，还是会占用过多的数据总线，造成总线冲突，最终还是会影响数据读写的性能

为了避免DMA总线冲突对性能的影响，后来又引入了Channel通道的方式。Channel，是一个完全独立的处理器，专门负责IO操作。既然是处理器，Channel就有自己的IO指令，与CPU无关，他也更适合大型的IO操作，性能更高

这也是java层面的零拷贝相关的操作都是通过Channel的子类实现的

零拷贝技术，其实并不是不拷贝，而是经历减少了CPU拷贝

mmap文件映射机制

主要是通过java.nio.channels.FileChannel的map方法完成映射

以一次文件的读写操作为例子，应用程序对磁盘文件的读与写，都需要经过内核态与用户态之间的的状态切换，每次状态切换的过程中，都需要大量的数据复制

在这个过程中,总共需要进行四次数据拷贝；而磁盘与内核态之间的数据拷贝，在操作系统层面已经由CPU拷贝优化为了DMA拷贝；而内核态与用户态之间拷贝依然是CPU拷贝；在这个场景下，零拷贝技术优化的重点，就是内核态与用户态之间的两次拷贝

而mmap文件映射的方式，就是在用户态不在保存文件的内容，而只保存文件的映射，包括文件的内存起始地址，文件大小等

真实的数据，也不需要在用户态留存，可以直接通过操作映射，在内核态完成数据复制

这种mmap的映射机制由于还是需要用户态保存文件的映射信息，数据复制的过程也需要用户态的参与，这其中的变数是非常多的。

所以mmap机制非常适合操作小文件，如果文件太大，映射信息也会过大，容易造成问多问题

通过mmap机制建议的映射文件不要超过2g,而RocketMQ做大的commitLog文件保持在1g固定大小,也是为了方便文件映射

sendFile机制运行

主要是通过java.nio.channels.FileChannel的transferTo方法完成

早期的sendFile机制其实还是依靠CPU进行页缓存与socket缓存区之间的数据拷贝；但是在后期不断改进过程中，sendfile优化了实现机制

在拷贝过程中，并不直接拷贝文件的内容，而是只拷贝一个带有文件位置和长度等信息的文件描述符FD，这样就大大减少了需要传递的数据；而真实的数据内容，会交由DMA控制器，从缓存页中打包异步发送到socket中

顺序写加速文件写入磁盘

通常应用程序往磁盘写文件时，由于磁盘空间不是连续的，会有很多碎片。所以我们去写一个文件时，也就无法把一个文件写在一块连续的磁盘空间中，而需要在磁盘多个扇区之间进行大量的随机写。这个过程中有大量的寻址操作，会严重影响写数据的性能。而顺序写机制是在磁盘中提前申请一块连续的磁盘空间，每次写数据时，就可以避免这些寻址操作，直接在之前写入的地址后面接着写就行

Kafka官方详细分析过顺序写的性能提升问题。Kafka官方曾说明，顺序写的性能基本能够达到内存级别。而如果配备固态硬盘，顺序写的性能甚至有可能超过写内存。而RocketMQ很大程度上借鉴了Kafka的这种思想

org.apache.rocketmq.store.CommitLog#DefaultAppendMessageCallback中的doAppend方法。在这个方法中，会以追加的方式将消息先写入到一个堆外内存byteBuffer中，然后再通过fileChannel写入到磁盘

刷盘机制保证消息不丢失

在操作系统层面，当应用程序写入一个文件时，文件内容并不会直接写入到硬件当中，而是会先写入到操作系统中的一个缓存PageCache中。PageCache缓存以4K大小为单位，缓存文件的具体内容

这些写入PageCache中的文件,在应用程序看来,是已经完全落盘保存好了的，可以修改，复制等等

但是，本质上，PageCache依然是内存状态，所以一断电就会丢失。因此，需要将内存状态的数据写入到磁盘当中，这样数据才能真正完成持久化，断电也不会丢失。这个过程就称为刷盘

PageCache是源源不断产生的，而Linux操作系统显然不可能时时刻刻往硬盘写文件。所以，操作系统只会在某些特定的时刻将PageCache写入到磁盘。例如当我们正常关机时，就会完成PageCache刷盘。另外，在Linux中，对于有数据修改的PageCache，会标记为Dirty(脏页)状态。当Dirty Page的比例达到一定的阈值时，就会触发一次刷盘操作。例如在Linux操作系统中，可以通过/proc/meminfo文件查看到Page Cache的状态

但是操作系统的刷盘不是时时刻刻执行的，那么对于用户态的应用程序来说，那就避免不了非正常宕机时的数据丢失问题。因此，操作系统也提供了一个系统调用，应用程序可以自行调用这个系统调用，完成page cache的强制刷盘

RocketMQ对何时刷盘也提供了两种刷盘机制,同步刷盘和异步刷盘

• 同步刷盘： 在返回成功状态前,消息被写入磁盘;具体流程是，消息写入内存的PAGECACHE后，立刻通知刷盘线程刷盘， 然后等待刷盘完成，刷盘线程执行完成后唤醒等待的线程，返回消息写 成功的状态
• 异步刷盘: 在返回写成功状态时，消息可能只是被写入了内存的PAGECACHE，写操作的返回快，吞吐量大；当内存里的消息量积累到一定程度时，统一触发写磁盘动作，快速写入
• 配置方式： borker配置文件里的flushDiskType参数设置的,这个参数被配置成 SYNC_FLUSH , ASYNC_FLUSH 中的一个

同步刷盘机制会更频繁的调用fsync，所以吞吐量相比异步刷盘会降低，但是数据的安全性会得到提高

🤗 总结归纳

📎 参考文章

• 官网地址： https://rocketmq.apache.org/

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
Hadoop: 海量数据的存储和海量数据的分析计算
Spark是一种基于内存的快速,通用,可扩展的大数据分析引擎

📝 Spark基础概念

基本概念

Spark是一种基于内存的快速和通用,可扩展的大数据分析计算引擎

hadoop MR 框架溢出写磁盘次数多,不合适迭代算,只适合一次计算;Spark框架计算块的原因是中间结果不罗盘,spark的shuffle也是要罗盘的

基础模块

• Spark Core : 实现了Spark的基本功能,包含了任务调度,内存管理,错误恢复,与存储系统交互等模块.Spark Core中还包含了对弹性分布式数据集(Resilient Distrubuted DataSet,简称RDD)的API定义
• Spark SQL : Spark用来操作结构化数据的程序包,通过Spark SQL,我们可以使用SQL或者Hive版本的HQL来查询数据;SparkSQL支持多种数据源,比如Hive表,Parquet及Join等
• Spakr Streaming : Spark提供的对实时的数据进行流式计算组件,提供了用来操作数据流的API,并且与Spark Core中的RDD API高度对应
• Spark MLlib : 提供常见的机器学习功能的程序库。包括分类、回归、聚类、协同过滤等，还提供了模型评估、数据 导入等额外的支持功能
• Spark GraphX : 主要用于图形并行计算和图挖掘系统的组件

运行模式

Local : 本地

SparkSubmit常用参数

📝 Spark RDD

基本概念

RDD是弹性分布式数据集,RDD代表弹性,可分区,不可变,元素可并行计算的计算

• 一组分区列表: RDD是分布式的,会根据文件切片划分分区,由多少切片就有多少分区
• 作用在每个分区上的计算函数: RDD每个分区处理不同的切片数据,每个分区计算逻辑是一样
• 对其他RDD的依赖关系: RDD会记录父RDD,后续如果RDD分区数据丢失可以根据依赖关系重新计算得到数据
• 分区器[可选]: RDD的分区分布在不同的机器上,后续如果想要将key相同的数据聚在一起,此时必须使用分区器规划key的数据在shuffle之后续落在RDD哪个分区上
• 优先位置: spark在分配task的时候会考虑将计算逻辑分配在数据所在的位置,避免计算的时候通过网络拉取数据影响效率

分区

通过本地集合创建RDD分区数:

如果有设置numSlices参数,此时RDD分区数 = 设置numSlices参数

如果没有设置numSlices参数,此时RDD分区数 = defaultParallelism:

1. 如果在sparkConf中有设置spark.default.parallelism参数的值,此时defaultParallelism=spark.default.parallelism参数值
2. 如果没有在sparkconf中设置spark.default.parallelism参数的值

• master=local,此时defaultParallelism=1
• master=local[N],此时defaultParallelism=N
• master=local[*],此时defaultParallelism=本地cpu个数
• master=spark://…,此时defaultParallelism = max( 所有executor总核数,2 )

通过读取文件创建RDD分区数

1. 如果有指定minPartition参数值,此时RDD分区数 ≥ 指定minPartition参数值
2. 如果没有指定minPartition参数值,此时RDD分区数 ≥ min(defaultParallelism,2)

通过其它RDD衍生出的新RDD的分区数 = 依赖第一个父RDD的分区数

算子

Spark的算子分为两类: Transformation转换算子(生成的是新RDD,不会触发任务计算);Action行动算子(没有返回值或者返回scala数据类型,会触发任务的计算)

📝 Spark优化

根据木桶效应,最短的木板决定了木桶的容量,因此,对于一只有短板的木桶,其它木板调节得再高也无济于事,最短的木板才是木桶容量的瓶颈

Spark UI提供了丰富的面板,来展示DAG,Stages划分,执行计划,Executor负载均衡情况,GC时间,内存缓存消耗等等详尽的运行时状态数据;对于硬件消耗资源,可利用监控应用进行查看

性能调优目的: 所有参数计算的硬件资源之间寻求协调与平衡,让硬件资源达到一种平衡,无瓶颈的状态

📝 Spark参数

🤗 总结归纳

📎 参考文章

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
分库分表

📝 分库分表要解决的问题

1. 解决B+树设计上本身的瓶颈问题(数据过多, 以及内存不够放索引,需要发生IO之类的问题)
2. 解决技术问题之后,要考虑业务的拆分情况,尽可能的减少业务代码的改动逻辑
3. 分库分表的本质就是把B+树的设计瓶颈重新拆散,变成无瓶颈

📔 垂直切分

通过将不同业务的数据，放到不同的数据库中，实现不同业务之间数据库层面的隔离

📔 水平切分

可以按照某种规则将某些字段分散到多个库中，每个表中只包含一部分数据 ,字段是一样的(比如日期字段，用户id字段，区域字字段等，比较理想的切分字段)

📔 如何实施

1. 先评估是否需要拆分

能不能有其他更好的优化方案，分库分表的开发周期比较长，一般只作为兜底方案去执行

2. 定制拆分的详细方案

1. 选择合适的分表策略
2. 再通知可能要更改的下游
3. 尽量做好设计，避免分库分表带来的常见问题

3. 目的评估

1. 评估：拆成几个表，几个库
2. 目标：读写能力提升多少，负载降低多少，容量支持未来N年的发展

举个例子：

当前30亿数据，如何拆分

解答：

找一个合理的拆分情况，比如按区域，按门店去拆分，不影响原来的业务，并且颗粒度细致到足够未来N年的发展就可以了

4. 拆分完成后防止问题兜底方案

**作用：**保证切换数据源之后，正常的增量数据也同步写入一份到旧数据源，这样能保证新数据发生不可短时间解决的问题的时候，避免回滚可以通过开关配置切换到旧数据源上正常执行业务

方案：

1. 同步双写：同步写新、旧数据源（代码层面上直接改）
2. 异步双写：通过监听binlog的方式去写旧数据源
3. 中间件同步工具：通过中间件工具去实施同步数据

注意点：做好补偿机制， 因为可能写其中一个库失败，需要做好最终一致性问题

5.存量数据的迁移问题

作用：迁移旧数据源的数据同步到新的数据源上，保证原有业务的正常CRUD

方案：

1. 自己写job开发，查询旧数据源，写入新库

2.用中间件去同步

3.交给DBA去同步

注意点：一定要校验数据的准确性，因为这是分库分表后的最后一步，一定要再三确认数据的一致性校验问题，并且要有相关的job做好补偿方案

分库分表后存在的问题

分布式id问题

1. 雪花算法，
2. 全局的自增id，
3. 美团分布式id方案

跨表查询问题

1. 从设计上解决跨表查询的情况，设计上基本能解决95%以上的问题，比如冗余字段，拆分的时候按业务隔离性去拆分
2. 分开查询，通过java代码去组合数据
3. 同一个线程需要跨库的，可以通过JDBC的方式去查询
4. 用ES等查询工具查询出主要信息，再组装数据

分布式事务问题

1. 做好补偿方案
2. 最大努力通知（使用MQ）
3. 人工兜底补偿 - 保底

📔 切分策略

🤗 总结归纳

📎 参考文章

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
HDFS来存储海量数据,MapReduce来对海量数据进行分布式并行计算,yarn来实现资源管理和作业调度
开发人员需要编写MR来对数据进行统计分析难度极大,效率极低,并且对开发者的java功底要求
Hive可以帮助人员来完成这些苦活(将SQL语句转化MapReduce在yarn上跑)

📝 Hive架构模块

Client

Cli: command-line interface

JDBC/ODBC: jdbc访问hive

Metastore

元数据: 表命,表所属的数据库(默认是default),表的拥有者,列/分区字段,表的类型(是否是外部表),表的数据所在的目录

Hadoop

使用hadoop进行存储,使用MapReduce进行计算

驱动器

• SQL Parse(解析器): 将SQL字符串转换成抽象语法树AST(第三方工具);对AST进行语法分析,比如表是否存在,字段是否存在,SQL语义是否错误
• Physical Plan(编译器): 将AST编译生成逻辑执行计划
• Query Optimizer(优化器): 对逻辑执行计划进行优化
  • Execution(执行器): 把逻辑执行计划转换成可以运行的屋里计划,对于Hive来说,就是MR/Spark

优缺点

Hive 3.x版本之上是可以支持acid的

📝 Hive数据类型

类型转换

📝 Hive语句

数据库语句

CREATE DATABASE [IF NOT EXISTS] database_name
[COMMENT database_comment]
[LOCATION hdfs_path]
[WITH DBPROPERTIES (property_name=property_value, ...)];

避免要创建的数据库已经存在错误,增加if nof exists判断

create database if not exists bigdata;

查询数据库的信息

-- 过滤显示查询的数据库
show databases like 'bigdata*';

-- 显示数据库信息
desc database bigdata;

操作数据库

-- bigdata2可能不存在,加 ifx exists 进行判断
drop database if exists bigdata2;

-- 如果数据库不为空,可以使用 cascade 强制删除
drop database bigdata cascade;

表语句

创建表

CREATE [EXTERNAL] TABLE [IF NOT EXISTS] table_name 
[(col_name data_type [COMMENT col_comment], ...)] 
[COMMENT table_comment] 
[PARTITIONED BY (col_name data_type [COMMENT col_comment], ...)] 
[CLUSTERED BY (col_name, col_name, ...) 
[SORTED BY (col_name [ASC|DESC], ...)] INTO num_buckets BUCKETS] 
[ROW FORMAT row_format] 
[STORED AS file_format] 
[LOCATION hdfs_path]
[TBLPROPERTIES (property_name=property_value, ...)]
[AS select_statement]
[LIKES existing_table_or_view_name]

-- 修改表
ALTER TABLE table_name RENAME TO new_table_name

-- 更新列
ALTER TABLE table_name CHANGE [COLUMN] col_old_name col_new_name column_type [COMMENT col_comment] [FIRST|AFTER column_name]

-- 增删除列
ALTER TABLE table_name ADD|REPLACE COLUMNS (col_name data_type [COMMENT col_comment], ...)

删除表

清除表中数据（Truncate） : Truncate只能删除管理表，不能删除外部表中数据

drop table test2;

DML语句

load语句

load data [local] inpath '数据的path' [overwrite] into table table_name [partition (partcol1=val1,…)];

-- 创建表时,通过Location指定加载数据路径
create external table if not exists student5(
              id int,
              name string
)
row format delimited fields terminated by '\t'
location '/input/student';

分区表

分区表

• 分区表实际上就是对应一个HDFS文件系统上的独立的文件夹
• 该文件夹下是该分区所有的数据文件
• Hive中的分区就是分目录，把一个大的数据集根据业务需要分割成小的数据集
• 在查询时通过WHERE子句中的表达式选择查询所需要的指定的分区，这样的查询效率会提高很多

分区操作

创建表指定分区字段 : 在查询时通过WHERE子句中的表达式选择查询所需要的指定的分区，这样的查询效率会提高很多

增加分区 : alter table dept_partition add partition(day=’20200404’)

删除分区 : alter table dept_partition drop partition (day=’20200406’)

二级分区

创建表指定分区字段 : partitioned by (day string, hour string)

hdfs存储的路径 : /user/hive/warehouse/mydb.db/dept_partition2/day=20200401/hour=14;

动态分区

对分区表insert数据时候,数据库自动会根据分区字段的值,将数据插入到相应的分区中

设置开启动态分区 : set hive.exec.dynamic.partition=true;

设置为非严格模式 : set hive.exec.dynamic.partition.mode=nonstrict

整个MR Job中,最大可以创建多少个HDFS文件,默认是100000; set hive.exec.max.created.files=100000;

在每个执行MR的节点上,最大可以创建多少个动态分区: set hive.exec.max.dynamic.partitions.pernode=100;

在所有执行MR的节点上,最大一共可以创建多少个动态分区,默认是1000; set hive.exec.max.dynamic.partitions=1000;

动态分区的模式,默认strict,表示必须指定至少一个分区为静态分区,nonstrict模式表示许所有的分区字段都可以使用动态分区

当有空分区生成时,是否抛出异常;一般不需要设置,默认false; set hive.error.on.empty.partition=false;

分桶表

分桶是将数据集分解成更容易管理的若干部分的另一种技术

分区针对的是数据存储路径(细分文件夹);分桶针对的是数据文件(按规则多文件放一起)

创建分桶表

要想将表创建为4个桶,需要将hive中mapreduce.job.reduces参数设置为 ≥ 4或设置为 -1

create table stu_bucket(id int, name string)
clustered by(id) 
into 4 buckets
row format delimited fields terminated by '\t';

分桶规则: Hive的分桶采用对分桶字段的值进行哈希(hash),然后除以桶的个数求余的方 式决定该条记录存放在哪个桶当中

mapreduce.job.reduces=-1,让Job自行决定需要用多少个reduce或者将reduce的个数设置为大于等于分桶表的桶数

📝 Hive函数

内置函数

show function: 查询系统自带的函数

desc function 函数名: 显示自带的函数的用法

desc function extended 函数名: 展开详细说明

窗口函数（开窗函数）

为每行数据进行一次计算,返回一个值

灵活运用窗口函数可以解决很多复杂的问题,如去重,排名,同步以及环比,连续登录等

自定义函数

• UDF(User-Defined-Function) : 一进一出
• UDAF(User-Defined-Aggregation Function): 聚合函数,多进一出,类似:max,count,min
• UDTF(User-Defined Table-Generating Functions): 炸裂函数,一进多出

引入过程:

1. 添加jar: add jar linux_jar_path
2. 创建function: function [dbname.]function_name AS class_name;
3. 在hive的命令行窗口删除函数: drop [temporary] function [if exists] [dbname.]function_name;

创建临时函数

create temporary function my_len as “com.atguigu.hive. MyStringLength”;

临时函数只和会话有关系,跟库没有关系,只要创建临时函数的会话不断,再当前会话下,任意一个库都可以使用,其它会话全部不能使用

📝 Hive优化

执行计划

Explain : EXPLAIN [EXTENDED | DEPENDENCY | AUTHORIZATION] query

查看执行语句运行时的信息/详细信息

Hive建表优化

分区表: 先用where过滤缩小查询范围,减小数据量

分桶表: 提供一个隔离数据和优化查询的便利方式

合格的文件格式: 采用压缩: 输入端/map输出端/reduce输出端

HQl语法优化

🤗 总结归纳

📎 参考文章

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
MySql 执行一条 upate,select等语句期间发生了什么

📝 执行一条Select语句

可以看到， MySQL 的架构共分为两层：Server 层和存储引擎层，

• Server 层负责建立连接、分析和执行 SQL。MySQL 大多数的核心功能模块都在这实现，主要包括连接器，查询缓存、解析器、预处理器、优化器、执行器等。另外，所有的内置函数（如日期、时间、数学和加密函数等）和所有跨存储引擎的功能（如存储过程、触发器、视图等。）都在 Server 层实现。
• 存储引擎层负责数据的存储和提取。支持 InnoDB、MyISAM、Memory 等多个存储引擎，不同的存储引擎共用一个 Server 层。现在最常用的存储引擎是 InnoDB，从 MySQL 5.5 版本开始， InnoDB 成为了 MySQL 的默认存储引擎。我们常说的索引数据结构，就是由存储引擎层实现的，不同的存储引擎支持的索引类型也不相同，比如 InnoDB 支持索引类型是 B+树 ，且是默认使用，也就是说在数据表中创建的主键索引和二级索引默认使用的是 B+ 树索引

连接器

连接的过程需要先经过 TCP 三次握手，因为 MySQL 是基于 TCP 协议进行传输的，如果 MySQL 服务并没有启动，则会收到如下的报错：

如果 MySQL 服务正常运行，完成 TCP 连接的建立后，连接器就要开始验证你的用户名和密码，如果用户名或密码不对，就收到一个”Access denied for user”的错误，然后客户端程序结束执行:

查询缓存

连接器得工作完成后，客户端就可以向 MySQL 服务发送 SQL 语句了，MySQL 服务收到 SQL 语句后，就会解析出 SQL 语句的第一个字段，看看是什么类型的语句。
如果 SQL 是查询语句（select 语句），MySQL 就会先去查询缓存（ Query Cache ）里查找缓存数据，看看之前有没有执行过这一条命令，这个查询缓存是以 key-value 形式保存在内存中的，key 为 SQL 查询语句，value 为 SQL 语句查询的结果。
如果查询的语句命中查询缓存，那么就会直接返回 value 给客户端。如果查询的语句没有命中查询缓存中，那么就要往下继续执行，等执行完后，查询的结果就会被存入查询缓存中。
这么看，查询缓存还挺有用，但是其实查询缓存挺鸡肋的。
对于更新比较频繁的表，查询缓存的命中率很低的，因为只要一个表有更新操作，那么这个表的查询缓存就会被清空。如果刚缓存了一个查询结果很大的数据，还没被使用的时候，刚好这个表有更新操作，查询缓冲就被清空了，相当于缓存了个寂寞。
所以，MySQL 8.0 版本直接将查询缓存删掉了，也就是说 MySQL 8.0 开始，执行一条 SQL 查询语句，不会再走到查询缓存这个阶段了。
对于 MySQL 8.0 之前的版本，如果想关闭查询缓存，我们可以通过将参数 query_cache_type 设置成 DEMAND。
TIP
这里说的查询缓存是 server 层的，也就是 MySQL 8.0 版本移除的是 server 层的查询缓存，并不是 Innodb 存储引擎中的 buffer poo

解析SQL

在正式执行 SQL 查询语句之前， MySQL 会先对 SQL 语句做解析，这个工作交由「解析器」来完成

解析器

执行SQL

经过解析器后，接着就要进入执行 SQL 查询语句的流程了，每条SELECT 查询语句流程主要可以分为下面这三个阶段：

• prepare 阶段，也就是预处理阶段；
• optimize 阶段，也就是优化阶段；
• execute 阶段，也就是执行阶段

预处理器

优化器

经过预处理阶段后，还需要为 SQL 查询语句先制定一个执行计划，这个工作交由「优化器」来完成的。

优化器主要负责将 SQL 查询语句的执行方案确定下来，比如在表里面有多个索引的时候，优化器会基于查询成本的考虑，来决定选择使用哪个索引。

当然，我们本次的查询语句（select * from product where id = 1）很简单，就是选择使用主键索引。

要想知道优化器选择了哪个索引，我们可以在查询语句最前面加个 explain 命令，这样就会输出这条 SQL 语句的执行计划，然后执行计划中的 key 就表示执行过程中使用了哪个索引，比如下图的 key 为 PRIMARY 就是使用了主键索引。

如果查询语句的执行计划里的 key 为 null 说明没有使用索引，那就会全表扫描（type = ALL），这种查询扫描的方式是效率最低档次的，如下图：

这张 product 表只有一个索引就是主键，现在我在表中将 name 设置为普通索引（二级索引）。

这时 product 表就有主键索引（id）和普通索引（name）。假设执行了这条查询语句：

select id from product where id > 1  and name like 'i%';

这条查询语句的结果既可以使用主键索引，也可以使用普通索引，但是执行的效率会不同。这时，就需要优化器来决定使用哪个索引了。
很显然这条查询语句是覆盖索引，直接在二级索引就能查找到结果（因为二级索引的 B+ 树的叶子节点的数据存储的是主键值），就没必要在主键索引查找了，因为查询主键索引的 B+ 树的成本会比查询二级索引的 B+ 的成本大，优化器基于查询成本的考虑，会选择查询代价小的普通索引。
在下图中执行计划，我们可以看到，执行过程中使用了普通索引（name），Exta 为 Using index，这就是表明使用了覆盖索引优化。

一条Update语句

🤗 总结归纳

总结文章的内容

📎 参考文章

• https://xiaolincoding.com/mysql/

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
HA : High Availablity,高可用
高可用最关键的策略是 消除单点故障

📝 HA

同时出现两个 active 状态,namenode的术语叫脑裂

问题记录

怎么保证三台namenode的数据一致:

1. Fsimages : 让一台 nn 生成数据，让其它机器nn同步
2. Edits: 需要引进新的模块JournalNode来保证edits的文件和数据一致性

怎么让同时只有一台nn是active,其它的都是standby

• 手动分配
• 自动分配

2nn在ha架构中并不存在，定期合并fsimage和edtis的活谁来干

由standby的nn来干

如果nn真的发生了问题，怎么让其他的nn上位干活

• 手动故障转移
• 自动故障转移

YARN HA

🤗 总结归纳

📎 参考文章

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
hadoop基础知识学习概念
大数据的特点: volume大量;velcity高速;variety多样;value低价值密度

📝 hadoop框架组件

Hdfs

Hadoop Distributed File System:分布式文件系统

• NameNode: 存储文件的元数据
• DataNode: 存储文件的块数据,以及校验和
• Secondary NameNode: 每隔一段时间备份元数据

Yarn

Yet Another Resource Negotiator: 另一种资源协调者;hadoop的资源管理器

• Resource: 管理整个集群资源
• DataManager: 单个节点资源管理器的老大
• Application Master: 单个运行任务的老大
• Container: 容器,封装了一个任务运行所需的资源

MapReduce

Map阶段并行处理输入数据

Reduce阶段对Map结果进行汇总

📝 HDFS

一种系统来管理多台机器上的文件,分布式文件管理;适合一次写入,多次读出的场景

NameNode

管理hdfs的名称空间,配置副本策略,管理数据块映射信息,处理客户端的读写请求

DataNode

存储实际块;NameNode发出命令,DataNode执行客户端的读写指令

一个数据块在DataNode上以文件形式存储在磁盘上,包括两个文件,一个是数据本身,一个是元数据包括数据块的长度,块数据的检验以及时间戳

DataNode启动后向NameNode注册,通过后,周期性(6小时)向NameNode上报所有的快信息;心跳是每3秒一次,心跳返回结果带有NameNode给该DataNode的命令如复制块数据到另一台机器,或删除某个数据块;如果超过10分钟+30s没有收到某个DataNode的心跳,则认为该节点不可用

块大小的设置,最好根据磁盘的传输速度来决定

Yarn

Yarn是一个资源调度平台,负责为程序提供服务器运行资源;相当于一个分布式操作系统平台;而MapReduce等运行程序则相当于运行于操作系统之上的应用程序

resourceManager

• 集群资源的分配和调度
• 管理nodeManager
• 管理/启动AppMaster
• 处理客户端请求

nodeManager

• 处理resoureManager命令
• 处理AppMaster命令
• 管理单个节点上的资源调配

AppMaster

• 管理单个任务的资源申请和分配
• 对任务的监控和容错

Container

• 封装某个节点上的资源,cpu,ram,rom等

调度器和调度算法

• 先进先出调度器(FIFO): 单队列,根据作业提交的顺序,先来先处理;不支持多队列,紧急的job无法插队
• 容量调度器(Capacity Scheduler): 多队列,每个队列采用fifo策略,分配一定的资源;容量可进行设置;多租户,支持多用户共享集群,多任务并行防止同一用户作业占据所有资源
• 公平调度器(Fair Scheduler): 优先资源缺额比较大的;fifo,fair,drf(同时考虑不同资源将不同资源按比例分配)

一个作业流程

yarn工作机制

1. MR程序提交到客户端所在节点
2. YarnRunner向ResourceManager申请一个Application
3. RM将该应用程序的资源路径返回YarnRunner
4. 该程序运行所需要资源提交到HDFS上
5. 程序资源提交完毕后,申请运行mrAppMaster
6. RM将用户的请求初始化成一个Task
7. 其中一个NodeManager领取到Task任务
8. 该NodeManager创建容器Container,并产生MRAppmaster
9. Container从HDFS上拷贝资源到本地
10. MRAppMaster向RM申请运行MapTask资源
11. RM将运行MapTask任务分配给另外两个NodeManager,另两个NodeManager分别领取任务并创建容器
12. MR向两个接受到任务的NodeManager发送程序启动脚本,这两个NodeManager分别启动MapTask,MapTask对数据分区排序
13. MrAppMaster等待所有MapTask运行完毕后,向RM申请容器,运行ReduceTask
14. ReduceTask向MapTask获取相应分区的数据
15. 程序运行完毕后,MR会向RM申请注销自己

Secondary NameNode

辅助NameNode,定期合并fsimages和edits,并推送给nn;紧急情况辅助恢复NameNode

HDFS写流程

📝 HA模式

HA集群中包含的进程职业各不同,为了使主节点和备用节点的状态一致,采用了Quorum Journal Manager(QJM)方案解决了主备节点共享存储问题

• Active NameNode: 负责执行整个文件系统中命名空间的所有操作;维护着数据的元数据,包括文件名,副本数,文件的blockId以及Block块所对应的节点信息;另外还接受Client端读写请求和DataNode汇报Block信息
• Standby NameNode: 它是Active NameNode的备用节点,一旦主节点宕机,备节点会切换成主节点对外提供服务.它主要是监听JournalNode Cluster上editlog变化,以保证当前命名空间尽可能的与主节点同步。
• JouranlNode Cluster: 用于主备节点共享editlog日志文件的共享存储系统;它负责存储editlog日志文件,当Active Node执行了修改命名空间操作时,它会定期将执行的操作记录在editlog中,并写入journalNode Cluster中;Standby NameNode会一直监听JournalNode Cluster上editlog的变化;如果发现editlog有改动,备用主节点会读取journalNode上的editlog并于自己当前的命名空间合并,从而实现了主备节点的数据一致
• ZKFailoverController: ZKFC以独立进程进行,每个ZKFC都监控自己负责的NameNode,它可以实现NameNode自动故障切换:即当前主节点的ZKFC则会断开与Zookeeper的连接,释放分布式锁;监控备用节点的ZKFC进程会去释放,同步把备用NameNode切换成主NameNode
• Zookeeper: 为ZKFC进行实现自动故障转移提供统一协调服务;通过Zookeeper中Watcher监听机制,通知ZKFC异常NameNode下线;保证同一时刻只有一个主节点

Fsimage

让一个NameNode生成数据,让其它机器NameNode同步

Edits

需要引进新的模块JournalNode来保证edits的文件数据一致性

🤗 总结归纳

📎 参考文章

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~

😀 这里写文章的前言：
Redis的主从,哨兵,集群

📝 主从复制

主从复制是Redis分布式基石，也是Redis高可用的保障

被复制的服务器称为主服务器（Master）

对主服务器进行复制的服务器称为从服务器(Slave)

1个master节点，多个slave节点

master 节点负责写(可读可写)

slave 节点负责读(只读)，分担压力，slave接受master节点的同步信息一直保持同步

配置redis.config

多个redis.config配置, 配置不同的端口启动, 从节点 slave 主节点. 需要手动配置

3种方式

replicaof（Redis 5.0 之前使用 slaveof）

• 在 slave 直接执行命令：replicaof
• 在 slave 配置文件中加入：replicaof
• 使用启动命令：–replicaof

主节点不需要修改配置,从节点需要配置 replica of master ip poid

原理

• 2.8版本以前,从服务器对主服务器的同步需要从服务器向主服务器发送sync命令来完成，主从服务器需要占用的资源：每次都执行一次RDB持久化

• 2.8版本以后,减少全量同步(full resynchronizaztion)的发生，尽可能使用增量同(partial resynchronization). 使用psync命令代替了sync命令来执行同步操作;psync命令同时具备全量同步和增量同步的功能

主从复制过程

1. 主从之间建立链接，由于从节点皮质了replica of主ip，此时是知道主节点ip地址的
2. 从节点发送一个psync ？ -1 的命令给主节点，主节点接受到后执行bgsave，发送给从节点，psync包括二个参数： 主服务器的runID和复制进度offset;第一次同步时，其值为-1,主节点响应的fullersync代表全量复制
3. 从节点接收到rdb文件，清空自己的数据，执行全量同步，后续有新的数据，通过replication Buffer进行增量同步
4. 加入主从之间的差距还是过大，还是会进行全量同步，buffer超过了大小限制，也会触发一次全量同步

哨兵模式

主从模式都是手动处理的，假设出了问题大部分不能第一时间解决主从故障等问题，哨兵模式可以很好的解决自动化监听并且处理主从故障的问题(保证服务的高可用);推选出新的master，并且将旧的master退级为slave

监控

哨兵会每隔1秒给所有的主从节点发送PING命令，当主从节点受到PING命令后，会发送一个响应命令给哨兵，这样就可以判断它们是否正常运行

发现故障

• 如果主节点或者从节点没有在规定的时间内响应哨兵，哨兵就会将它们标记为 [主观下线]
• 并且告知其他哨兵，ping该节点，超过半数确认是否 [客观下线]

故障转移

1.选出leader哨兵

为了更加“客观”的判断主节点故障了，一般不会只由单个哨兵的检测结果来判断，而是多个哨兵一起判断，这样可以减少误判概率，所以哨兵是以哨兵集群的方式存在的

需要在哨兵集群中选出一个leader，让leader来执行主从切换;选举leader的过程其实是一个投票的过程，在投票开始前，肯定得有个 [候选者]

举个栗子：假设有三个哨兵;当哨兵B先判断到主节点[主管下线后],就会给其他实例发送is-master-down-by-addr命令;接着，其他哨兵会根据自己和主节点的网络连接情况,做出赞成投票或者拒绝投票的响应

当哨兵 B 收到赞成票数达到哨兵配置文件中的 quorum 配置项设定的值后，就会将主节点标记为「客观下线」，此时的哨兵 B 就是一个Leader 候选者

候选者会向其他哨兵发送命令，表明希望成为Leader来执行主从切换，让其他哨兵对它投票

每个哨兵只有一次投票机会，如果用完了就不能参与投票，可以投给自己或投给别人，但是只有候选者才能把票投给自己

那么在投票的过程中，任何一个 候选者 ， 要满足两个条件：

• 第一，拿到半数以上的赞成票
• 第二，拿到的票数同时还需要大于等于哨兵配置文件中的quorum值

2.选举新节点

3.从节点指向新主节点

当新主节点出现之后，哨兵 leader 下一步要做的就是，让已下线主节点属下的所有「从节点」指向「新主节点」，这一动作可以通过向「从节点」发送 SLAVEOF 命令来实现

所有从节点指向新主节点后的拓扑图如下：

4.通知客户端的主节点已更换

经过前面三步，哨兵集群终于完成主从节点切换的工作，那么新节点的信息如何通知给客户端呢？

这主要通过 Redis 的发布者/订阅者机制来实现的。每个哨兵节点提供发布者/订阅者机制，客户端可以从哨兵订阅消息

客户端和哨兵建立连接后，客户端会订阅哨兵提供的频道

主从切换完成后,哨兵就会向 +switch-master 频道发布新主节点的ip地址和端口信息，这个时候客户端就可以接收到这条信息，然后用这里面的新主节点的ip地址和端口进行通信

5.将旧主节点变为从节点

故障转移操作最后要做的是，继续监视旧主节点，当旧主节点重新上线时，哨兵集群就会向它发送 SLAVEOF 命令，让它成为新主节点的从节点，如下图

哨兵集群如何工作

前面提到了 Redis 的发布者/订阅者机制，那就不得不提一下哨兵集群的组成方式，因为它也用到了这个技术

在我第一次搭建哨兵集群的时候，当时觉得很诧异。因为在配置哨兵的信息时，竟然只需要填下面这几个参数，设置主节点名字、主节点的 IP 地址和端口号以及 quorum 值

sentinel monitor <master-name> <ip> <redis-port> <quorum>

不需要填其他哨兵节点信息，是如何感知对方的，又是如何组成哨兵集群的？

哨兵节点之间通过redis的发布者/订阅者机制来互相发现的

在主从集群中，主节点上有一个名为__sentinel__:hello的频道，不同哨兵就是通过它来相互发现，实现互相通信的

在下图中，哨兵 A 把自己的 IP 地址和端口的信息发布到__sentinel__:hello 频道上，哨兵 B 和 C 订阅了该频道。那么此时，哨兵 B 和 C 就可以从这个频道直接获取哨兵 A 的 IP 地址和端口号。然后，哨兵 B、C 可以和哨兵 A 建立网络连接

通过这个方式，哨兵 B 和 C 也可以建立网络连接，这样一来，哨兵集群就形成了

脑裂问题

旧的master出了问题，有一些还没同步到redis上，从redis通过选举成为一个新的master，有新的master起来后，由于一些问题，哨兵通知不到旧的master，导致2个master，就出现了脑裂

本质是2个master，新master是可以接受写入数据的， 但是有一些数据写到旧的mater上了, 但是从redis 只会同步新的mater, 当旧mater的恢复正常后, 哨兵会把旧的mater降级为从, 降级是要清除数据的,清了数据 之前写在旧mater上的数据还没同步的也就没了

问题出在,当从升级为master的时候，有2个master，并且2个都在接受写入数据;旧的 新的master都在写入数据，但是从的只同步了新的master，写进旧的master的数据没同步，并且随着自己的降级也没了，丢失了

# master 须要有至少 x 个副本连接。
min-slaves-to-write x
# 数据复制和同步的延迟不能超过 x 秒。
min-slaves-max-lag x

# min-replicas-to-write x
# min-replicas-max-lag x

CAP理论认为，一个分布式系统不可能同时满足一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance）这三个基本需求，最多只能同时满足其中两项。

在Redis哨兵模式下出现脑裂问题时，主从节点之间的分区容错性得以保证，但同时需要在一致性和可用性之间做出取舍。

首先，由于数据复制和同步的延迟可能会导致主从节点之间的数据不一致，因此在Redis的哨兵模式中，我们需要配置 min-slaves-to-write 和 min-slaves-max-lag 这两个参数，以保证数据的一致性。

其次，在节点出现脑裂时，如果旧的主节点和新的主节点都在接受写入数据，那么可能会出现数据写入不一致的情况。为了解决这个问题，我们可以在哨兵模式中配置 min-replicas-to-write 和 min-replicas-max-lag 这两个参数，以保证数据的一致性和可用性。

但是需要注意的是，以上的配置都只能减少发生脑裂的可能性，而不能完全避免。因此，对于Redis的哨兵模式来说，我们需要在一致性和可用性之间做出取舍，根据具体的业务需求来设置合理的参数。

• redis集群是可以让脑裂存在的,其实是一种高可用的特性，但不保证数据一致
• redis通过设置两个参数，一定程度上其实是降低可用性，以提供数据一致性
• 为什么愿意降低可用性？因为那部分的数据会因为主从切换而丢失，所以宁愿不可用

Cluster集群

哨兵模式最大的缺点就是所有的数据都放在同一台服务器上，无法较好的进行水平扩展

为了解决哨兵模式存在的问题，集群模式应运而生。在高可用上，集群基本是直接复用的哨兵模式的逻辑，并且针对水平扩展进行了优化

Redis Cluster集群模式具备的特点如下:

1. 采取去中心化的集群模式，将数据按照槽存储分布在多个redis节点上。集群共有16382槽，每个节点负责处理部分槽
2. 使用CRC16算法来计算key所属的槽，CRC16（key,key len） &16383
3. 所有Redis节点批次互联，通过PING-PONG机制来节点间的心跳检测
4. 分片内采用一主多从保证高可用，并提供复制和故障恢复功能。在实际中，通过会将主从分布在不同的机房，避免机房出现故障导致整个分片出问题
5. 客户端与Redis节点直连，不需要中间代理层(Proxy);客户端不需要连接集群所有节点，连接集群中任何一个可用的节点即可

目前redis的分区规则是： hash分区，分成了 16384 个哈希槽

RedisCluster采用了哈希分区的“虚拟槽分区”方式（哈希分区分节点取余，一致性哈希分区和虚拟槽分区）

故障发现

1. Redis Cluster通过ping/pong消息实现故障发现：不需要sentinel
2. ping/pong不仅能传递节点与槽的对应消息，也能传递其他状态，比如：节点主从状态，节点故障等
3. 故障发现就是通过这种模式来实现，分为主观下线和客观下线

主观下线

• 某个节点认为宁外一个节点不可用，‘偏见’，只代表一个节点对另外一个节点的判断，不是所有节点的认知
• 如果节点1发现与节点2最后通信时间超过node-timeout，则把节点2标识为pfail状态

客观下线

1. 当半数以上持有槽的主节点都标记某节点主观下线时，可以保证判断的公平性
2. 集群模式下，只有主节点(master)才有读写权限和集群槽的维护权限，从节点(slave)只有复制的权限
3. 客观下线流程:

1.某个节点接收到其他节点发送的ping消息，如果接收到的ping消息中包含了其他pfail节点，这个节点会将主观下线的消息内容添加到自身的故障列表中，故障列表中包含了当前节点接收到的每一个节点对其他节点的状态信息

2.当前节点把主观下线的消息内容添加到自身的故障列表之后，会尝试对故障节点进行客观下线操作

准备选举时间

使偏移量最大的从节点具备优先级成为主节点的条件

替换主节点

当前从节点取消复制变成离节点(slave of no one)
执行cluster del slot撤销故障主节点负责的槽，并执行cluster add slot把这些槽分配给自己
向集群广播自己的pong消息，表明已经替换了故障从节点

集群选举流程

故障转移的第一步就是选举出新的主节点，以下是集群选举新的主节点的方法：

1）当从节点发现自己正在复制的主节点进入已下线状态时，会发起一次选举：将 currentEpoch（配置纪元）加1，然后向集群广播一条 CLUSTERMSG_TYPE_FAILOVER_AUTH_REQUEST 消息，要求所有收到这条消息、并且具有投票权的主节点向这个从节点投票。

2）其他节点收到消息后，会判断是否要给发送消息的节点投票，判断流程如下：

1. 当前节点是 slave，或者当前节点是 master，但是不负责处理槽，则当前节点没有投票权，直接返回。
2. 请求节点的 currentEpoch 小于当前节点的 currentEpoch，校验失败返回。因为发送者的状态与当前集群状态不一致，可能是长时间下线的节点刚刚上线，这种情况下，直接返回即可。
3. 当前节点在该 currentEpoch 已经投过票，校验失败返回。
4. 请求节点是 master，校验失败返回。
5. 请求节点的 master 为空，校验失败返回。
6. 请求节点的 master 没有故障，并且不是手动故障转移，校验失败返回。因为手动故障转移是可以在 master 正常的情况下直接发起的。
7. 上一次为该master的投票时间，在cluster_node_timeout的2倍范围内，校验失败返回。这个用于使获胜从节点有时间将其成为新主节点的消息通知给其他从节点，从而避免另一个从节点发起新一轮选举又进行一次没必要的故障转移
8. 请求节点宣称要负责的槽位，是否比之前负责这些槽位的节点，具有相等或更大的 configEpoch，如果不是，校验失败返回。

如果通过以上所有校验，那么主节点将向要求投票的从节点返回一条 CLUSTERMSG_TYPE_FAILOVER_AUTH_ACK 消息，表示这个主节点支持从节点成为新的主节点。

3）每个参与选举的从节点都会接收 CLUSTERMSG_TYPE_FAILOVER_AUTH_ACK 消息，并根据自己收到了多少条这种消息来统计自己获得了多少个主节点的支持。

4）如果集群里有N个具有投票权的主节点，那么当一个从节点收集到大于等于N/2+1 张支持票时，这个从节点就会当选为新的主节点。因为在每一个配置纪元里面，每个具有投票权的主节点只能投一次票，所以如果有 N个主节点进行投票，那么具有大于等于 N/2+1 张支持票的从节点只会有一个，这确保了新的主节点只会有一个。

5）如果在一个配置纪元里面没有从节点能收集到足够多的支持票，那么集群进入一个新的配置纪元，并再次进行选举，直到选出新的主节点为止。

这个选举新主节点的方法和选举领头 Sentinel 的方法非常相似，因为两者都是基于 Raft 算法的领头选举（leader election）方法来实现的

ASK错误

当redis正在对集群进行扩容和缩容时，需要对槽及槽中数据进行迁移

当客户端向某个节点发送命令，节点向客户端返回moved异常，告诉客户端数据对应的槽的节点信息

如果此时正在进行集群扩展或者缩空操作，当客户端向正确的节点发送命令时，槽及槽中数据已经被迁移到别的节点了，就会返回ask，这就是ask重定向机制

moved重定向

是路由层面的，直接修改迁移之后的槽映射关系，不用像ask错误一样，返回错误再重新路由

集群不可用时机

• 挂掉的master没有对应的slave，即有任一slot不可用，集群都不可用
• 超过半数master都挂掉了，不管有没有slave，都将不可用

🤗 总结归纳

📎 参考文章

• https://juejin.cn/post/7017017990667304973
• https://www.xiaolincoding.com/redis/cluster/sentinel.html

💡 有关文章的问题，欢迎您在底部评论区留言，一起交流~