MySQL 和 Elasticsearch 是两种不同的数据管理系统，它们各有优劣，适用于不同的场景。本文将从以下几个方面对它们进行比较和分析：

• 数据模型


• 查询语言


• 索引和搜索


• 分布式和高可用


• 性能和扩展性


• 使用场景

数据模型

MySQL 是一个关系型数据库管理系统（RDBMS），它使用表（table）来存储结构化的数据，每个表由多个行（row）和列（column）组成，每个列有一个预定义的数据类型，例如整数、字符串、日期等。MySQL 支持主键、外键、约束、触发器等关系型数据库的特性，以保证数据的完整性和一致性。

Elasticsearch 是一个基于 Lucene 的搜索引擎，它使用文档（document）来存储半结构化或非结构化的数据，每个文档由多个字段（field）组成，每个字段可以有不同的数据类型，例如文本、数字、布尔、数组等。Elasticsearch 支持动态映射（dynamic mapping），可以根据数据自动推断字段的类型和索引方式。

MySQL 和 Elasticsearch 的数据模型有以下几点区别：

• MySQL 的数据模型是严格的，需要事先定义好表的结构和约束，而 Elasticsearch 的数据模型是灵活的，可以随时添加或修改字段。


• MySQL 的数据模型是二维的，每个表只有行和列两个维度，而 Elasticsearch 的数据模型是多维的，每个文档可以有嵌套的对象或数组。


• MySQL 的数据模型是关系型的，可以通过连接（join）多个表来查询相关的数据，而 Elasticsearch 的数据模型是非关系型的，不支持连接操作，需要通过嵌套文档或父子文档来实现关联查询。

推荐博主开源的 H5 商城项目waynboot-mall，这是一套全部开源的微商城项目，包含三个项目：运营后台、H5 商城前台和服务端接口。实现了商城所需的首页展示、商品分类、商品详情、商品 sku、分词搜索、购物车、结算下单、支付宝/微信支付、收单评论以及完善的后台管理等一系列功能。 技术上基于最新得 Springboot3.0、jdk17，整合了 MySql、Redis、RabbitMQ、ElasticSearch 等常用中间件。分模块设计、简洁易维护，欢迎大家点个 star、关注博主。

github 地址：github.com/wayn111/way…

查询语言

MySQL 使用标准的 SQL 语言来查询和操作数据，SQL 语言是一种声明式的语言，可以通过简洁的语法来表达复杂的逻辑。SQL 语言支持多种查询类型，例如选择（select）、插入（insert）、更新（update）、删除（delete）、聚合（aggregate）、排序（order by）、分组（gr0up by）、过滤（where）、连接（join）等。

Elasticsearch 使用 JSON 格式的查询 DSL（Domain Specific Language）来查询和操作数据，查询 DSL 是一种基于 Lucene 查询语法的语言，可以通过嵌套的 JSON 对象来构建复杂的查询。查询 DSL 支持多种查询类型，例如全文检索（full-text search）、结构化检索（structured search）、地理位置检索（geo search）、度量检索（metric search）等。

MySQL 和 Elasticsearch 的查询语言有以下几点区别：

• MySQL 的查询语言是通用的，可以用于任何关系型数据库系统，而 Elasticsearch 的查询语言是专用的，只能用于 Elasticsearch 系统。


• MySQL 的查询语言是字符串形式的，需要拼接或转义特殊字符，而 Elasticsearch 的查询语言是 JSON 形式的，可以直接使用对象或数组表示。


• MySQL 的查询语言是基于集合论和代数运算的，可以进行集合操作和数学运算，而 Elasticsearch 的查询语言是基于倒排索引和相关度评分的，可以进行全文匹配和相似度计算。

索引和搜索

MySQL 使用 B+树作为主要的索引结构，B+树是一种平衡多路搜索树，它可以有效地存储和检索有序的数据。MySQL 支持主键索引、唯一索引、普通索引、全文索引等多种索引类型，以加速不同类型的查询。MySQL 也支持外部存储引擎，例如 InnoDB、MyISAM、Memory 等，不同的存储引擎有不同的索引和锁机制。

Elasticsearch 使用倒排索引作为主要的索引结构，倒排索引是一种将文档中的词和文档的映射关系存储的数据结构，它可以有效地支持全文检索。Elasticsearch 支持多种分词器（analyzer）和分词过滤器（token filter），以对不同语言和场景的文本进行分词和处理。Elasticsearch 也支持多种搜索类型，例如布尔搜索（boolean search）、短语搜索（phrase search）、模糊搜索（fuzzy search）、通配符搜索（wildcard search）等，以实现不同精度和召回率的检索。

MySQL 和 Elasticsearch 的索引和搜索有以下几点区别：

• MySQL 的索引是基于数据的值的，可以精确地定位数据的位置，而 Elasticsearch 的索引是基于数据的内容的，可以近似地匹配数据的含义。


• MySQL 的索引是辅助的，需要手动创建和维护，而 Elasticsearch 的索引是主要的，自动创建和更新。


• MySQL 的索引是局部的，只针对单个表或列，而 Elasticsearch 的索引是全局的，涵盖所有文档和字段。

分布式和高可用

MySQL 是一个单机数据库系统，它只能运行在一台服务器上，如果服务器出现故障或负载过高，就会影响数据库的可用性和性能。为了解决这个问题，MySQL 提供了多种复制（replication）和集群（cluster）方案，例如主从复制（master-slave replication）、双主复制（master-master replication）、MySQL Cluster、MySQL Fabric 等，以实现数据的冗余和负载均衡。

Elasticsearch 是一个分布式数据库系统，它可以运行在多台服务器上，形成一个集群（cluster）。每个集群由多个节点（node）组成，每个节点可以承担不同的角色，例如主节点（master node）、数据节点（data node）、协调节点（coordinating node）等。每个节点可以存储多个索引（index），每个索引可以划分为多个分片（shard），每个分片可以有多个副本（replica）。Elasticsearch 通过一致性哈希算法（consistent hashing algorithm）来分配分片到不同的节点上，并通过心跳检测（heartbeat check）来监控节点的状态。如果某个节点出现故障或加入集群，Elasticsearch 会自动进行分片的重新分配和平衡。

MySQL 和 Elasticsearch 的分布式和高可用有以下几点区别：

• MySQL 的分布式和高可用是可选的，需要额外配置和管理，而 Elasticsearch 的分布式和高可用是内置的，无需额外操作。


• MySQL 的分布式和高可用是基于复制或共享存储的，需要保证数据一致性或可用性之间的权衡，而 Elasticsearch 的分布式和高可用是基于分片和副本的，可以根据需求调整数据冗余度或容错能力。


• MySQL 的分布式和高可用是静态的，需要手动扩展或缩容集群规模，而 Elasticsearch 的分布式和高可用是动态的，可以自动适应集群变化。

性能和扩展性

MySQL 是一个面向事务（transaction）的数据库系统，它支持 ACID 特性（原子性、一致性、隔离性、持久性），以保证数据操作的正确性和完整性。MySQL 使用锁机制来实现事务隔离级别（isolation level），不同的隔离级别有不同的并发性能和一致性保证。MySQL 也使用缓冲池（buffer pool）来缓存数据和索引，以提高查询效率。MySQL 的性能主要取决于硬件资源、存储引擎、索引设计、查询优化等因素。

Elasticsearch 是一个面向搜索（search）的数据库系统，它支持近实时（near real-time）的索引和查询，以保证数据操作的及时性和灵活性。Elasticsearch 使用分片和副本来实现数据的分布式存储和并行处理，不同的分片数和副本数有不同的写入吞吐量和读取延迟。Elasticsearch 也使用缓存（cache）和内存映射文件（memory-mapped file）来加速数据和索引的访问，以提高搜索效率。Elasticsearch 的性能主要取决于集群规模、分片策略、文档结构、查询复杂度等因素。

MySQL 和 Elasticsearch 的性能和扩展性有以下几点区别：

• MySQL 的性能和扩展性是有限的，它受到单机资源、锁竞争、复制延迟等因素的限制，而 Elasticsearch 的性能和扩展性是无限的，它可以通过增加节点、分片、副本等方式来水平扩展集群。


• MySQL 的性能和扩展性是以牺牲搜索能力为代价的，它不能支持复杂的全文检索和相关度评分，而 Elasticsearch 的性能和扩展性是以牺牲事务能力为代价的，它不能保证数据操作的原子性和一致性。


• MySQL 的性能和扩展性是以提高写入速度为目标的，它优化了数据插入和更新的效率，而 Elasticsearch 的性能和扩展性是以提高读取速度为目标的，它优化了数据检索和分析的效率。

使用场景

MySQL 和 Elasticsearch 适用于不同的使用场景，根据不同的业务需求，可以选择合适的数据库系统或组合使用两者。以下是一些常见的使用场景：

• 如果需要存储结构化或半结构化的数据，并且需要保证数据操作的正确性和完整性，可以选择 MySQL 作为主要数据库系统。例如，电商网站、社交网络、博客平台等。


• 如果需要存储非结构化或多样化的数据，并且需要支持复杂的全文检索和相关度评分，可以选择 Elasticsearch 作为主要数据库系统。例如搜索引擎、日志分析、推荐系统等。


• 如果需要存储和分析大量的时序数据，并且需要支持实时的聚合和可视化，可以选择Elasticsearch作为主要数据库系统。例如，物联网、监控系统、金融市场等。


• 如果需要同时满足上述两种需求，并且可以容忍一定程度的数据不一致或延迟，可以将 MySQL 作为主数据库系统，并将部分数据同步到 Elasticsearch 作为辅助数据库系统。例如新闻网站、电影网站、招聘网站等。

自此本文讲解内容到此结束，感谢您的阅读，希望本文对您有所帮助。

0. 引言

es的java客户端不太友好的语法一直饱受诟病，书写一个查询语句可能需要书写一大串的代码，如果能像mybatis--plus一样，支持比较灵活方便的语句生成器那就好了。

于是为elasticsearch而生的ORM框架Easy-Es诞生了，使用及其方便快捷，今天我们就一起来学习easy-es，对比看看原生java-client方便之处在哪儿。

1. Easy-Es简介

Easy-Es是以elasticsearch官方提供的RestHighLevelClient为基础，而开发的一款针对es的ORM框架，类似于es版的mybatis-plus，可以让开发者无需掌握es复杂的DSL语句，只要会mysql语法即可使用es，快速实现es客户端语法

官方文档：http://www.easy-es.cn/

2. Easy-Es使用

1、引入依赖

<!-- 引入easy-es最新版本的依赖-->

        <dependency>

            <groupId>org.dromara.easy-es</groupId>

            <artifactId>easy-es-boot-starter</artifactId>

            <version>2.0.0-beta3</version>

        </dependency>



        <!-- 排除springboot中内置的es依赖,以防和easy-es中的依赖冲突-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

            <exclusions>

                <exclusion>

                    <groupId>org.elasticsearch.client</groupId>

                    <artifactId>elasticsearch-rest-high-level-client</artifactId>

                </exclusion>

                <exclusion>

                    <groupId>org.elasticsearch</groupId>

                    <artifactId>elasticsearch</artifactId>

                </exclusion>

            </exclusions>

        </dependency>

        <dependency>

            <groupId>org.elasticsearch.client</groupId>

            <artifactId>elasticsearch-rest-high-level-client</artifactId>

            <version>7.14.0</version>

        </dependency>

        <dependency>

            <groupId>org.elasticsearch</groupId>

            <artifactId>elasticsearch</artifactId>

            <version>7.14.0</version>

        </dependency>

2、添加配置项，这里只配置了几个基本的配置项，更多配置可参考官网文档：easy-es 配置介绍

easy-es: 

  # es地址、账号密码

  address: 192.168.244.11:9200

  username: elastic

  password: elastic

3、在启动类中添加es mapper文件的扫描路径

@EsMapperScan("com.example.easyesdemo.mapper")

4、创建实体类，通过@IndexName注解申明索引名称及分片数， @IndexField注解申明字段名、数据类型、分词器等，更多介绍参考官方文档：essy-es 注解介绍

@IndexName(value = "user_easy_es")

@Data

public class UserEasyEs {



    @IndexId(type = IdType.CUSTOMIZE)

    private Long id;



    private String name;



    private Integer age;



    private Integer sex;



    @IndexField(fieldType = FieldType.TEXT, analyzer = Analyzer.IK_SMART, searchAnalyzer = Analyzer.IK_SMART)

    private String address;



    @IndexField(fieldType = FieldType.DATE, dateFormat = "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis")

    private Date createTime;



    private String createUser;



}

5、创建mapper类，继承BaseEsMapper类，注意这里的mapper一定要创建到第3步中设置的mapper扫描路径下com.example.easyesdemo.mapper

public interface UserEsMapper extends BaseEsMapper<UserEasyEs> {

}

6、创建controller，书写创建索引、新增、修改、查询的接口

@RestController

@RequestMapping("es")

@AllArgsConstructor

public class UserEsController {



    private final UserEsMapper userEsMapper;



    /**

     * 创建索引

     * @return

     */

    @GetMapping("create")

    public Boolean createIndex(){

        return userEsMapper.createIndex();

    }



    @GetMapping("save")

    public Integer save(Long id){

        UserEasyEs user = new UserEasyEs();

        user.setId(id);

        user.setName("用户"+id);

        user.setAddress("江苏省无锡市滨湖区");

        user.setAge(30);

        user.setSex(1);

        user.setCreateUser("admin");

        user.setCreateTime(new Date());

        Long count = userEsMapper.selectCount(EsWrappers.lambdaQuery(UserEasyEs.class).eq(UserEasyEs::getId, id));

        if(count > 0){

            return userEsMapper.updateById(user);

        }else{

            return userEsMapper.insert(user);

        }

    }



    @GetMapping("search")

    public List<UserEasyEs> search(String name, String address){

        List<UserEasyEs> userEasyEs = userEsMapper.selectList(

                EsWrappers.lambdaQuery(UserEasyEs.class)

                        .eq(UserEasyEs::getName, name)

                        .match(UserEasyEs::getAddress, address)

                );

        return userEasyEs;

    }



}

7、分别调用几个接口

• 创建索引
  
  kibana中查询索引，发现创建成功
  


• 新增接口
  这里新增了4笔
  
  数据新增成功
  


• 数据查询

如上便是针对easy-es的简单使用，这里的用法都与mp类似，上手相当简单，不用再写那些复杂的DSL语句了

3. 拓展介绍

• 条件构造器

上述演示，我们构造查询条件时，使用了EsWrappers来构造条件，用法与mp及其类型，大家根据提示就可以推导出方法如何书写，更详细的使用说明可以查看官方文档：easy-es 条件构造器介绍

• 索引托管

如果想要自动根据创建的es实体类来创建对应的索引，那么只需要调整索引的托管模式为非手动模式即可，因为这里我不需要自动同步数据，所以选择非平滑模式

easy-es:

  global-config:

    process_index_mode: not_smoothly

其中三种模式的区别为：
平滑模式：smoothly，索引的创建、数据更新迁移等都由easy-es自动完成
非平滑模式：not_smoothly，索引自动创建，但不会自动迁移数据
手动模式：manual，全部操作由用户手动完成，默认模式

• 数据同步

如果数据源是来自mysql, 那么建议使用canal来进行同步，canal的使用可在我主页搜索。
其次还有DataX, Logstash等同步工具，当然你也可以使用easy-es提供的CRUD接口，来手动同步数据

• 日志打印

通过开启日志，可以在控制台打印执行的DSL语句，更加方便我们在开发阶段进行问题排查

logging:

  level:

   tracer: trace # 开启trace级别日志,在开发时可以开启此配置,则控制台可以打印es全部请求信息及DSL语句,为了避免重复,开启此项配置后,可以将EE的print-dsl设置为false.

• 聚合查询
  easy-es实现的聚合查询，只要是针对gr0up by这类聚合，也就是es中的Terms aggregation，以及最大值、最小值、平均值、求和，而对于其他类型的聚合，还在不断更新中，但这里大家也需要了解，es的聚合和mysql的聚合完全是不一样的维度和复杂度，es支持非常多的聚合查询，所以其他类型的实现还需要借助RestHighLevelClient来实现

我们利用easy-es来实现下之前书写的聚合案例

@RestController

@AllArgsConstructor

@RequestMapping("order")

public class OrderEsController {



    private final OrderTestEsMapper orderEsMapper;



    @GetMapping("search")

    public String search(){

        SearchResponse search = orderEsMapper.search(EsWrappers.lambdaQuery(OrderTest.class).groupBy(OrderTest::getStatus));



        // 包装查询结果

        Aggregations aggregations = search.getAggregations();

        Terms terms = (Terms)aggregations.asList().get(0);

        List<? extends Terms.Bucket> buckets = terms.getBuckets();

        HashMap<String,Long> statusRes = new HashMap<>();

        buckets.forEach(bucket -> {

            statusRes.put(bucket.getKeyAsString(),bucket.getDocCount());

        });

        System.out.println("---聚合结果---");

        System.out.println(statusRes);

        return statusRes.toString();

    }

}

可以看到实际上的查询语句就一行，而其他的都是对返回结果的封装，因为es本身返回的数据是封装到嵌套的对象中的，所以我们需要对其进行包装

对比原始的查询语句，其易用性上的提升还是很明显的

4. 总结

至此对easy-es的介绍就结束了，可以看到如果是针对es实现CRUD上，easy-es表现出非常好的便捷性，而在复杂的聚合查询中，仍然还有进步空间，目前还需要借助RestHighLevelClient，但easy-es的出现，为未来提供更好用的ES ORM框架，提供了希望和方向

文中演示代码见：gitee.com/wuhanxue/wu…

MySQL 高级（进阶）SQL 语句

1. MySQL SQL 语句

1.1 常用查询

常用查询简单来说就是 增、删、改、查

对 MySQL 数据库的查询，除了基本的查询外，有时候需要对查询的结果集进行处理。 例如只取 10 条数据、对查询结果进行排序或分组等等

1、按关键字排序
PS:类比于windows 任务管理器
使用 SELECT 语句可以将需要的数据从 MySQL 数据库中查询出来，如果对查询的结果进行排序，可以使用 ORDER BY 语句来对语句实现排序，并最终将排序后的结果返回给用户。这个语句的排序不光可以针对某一个字段，也可以针对多个字段

（1）语法
SELECT column1, column2, … FROM table_name ORDER BY column1, column2, …

ASC|DESC
ASC 是按照升序进行排序的，是默认的排序方式，即 ASC 可以省略。SELECT 语句中如果没有指定具体的排序方式，则默认按 ASC方式进行排序。

DESC 是按降序方式进 行排列。当然 ORDER BY 前面也可以使用 WHERE 子句对查询结果进一步过滤。

准备工作：

create database k1;

use k1;

create table location (Region char(20),Store_Name char(20));

insert int0 location values('East','Boston');

insert int0 location values('East','New York');

insert int0 location values('West','Los Angeles');

insert int0 location values('West','Houston');

create table store_info (Store_Name char(20),Sales int(10),Date char(10));

insert int0 store_info values('Los Angeles','1500','2020-12-05');

insert int0 store_info values('Houston','250','2020-12-07');

insert int0 store_info values('Los Angeles','300','2020-12-08');

insert int0 store_info values('Boston','700','2020-12-08');

1.2 SELECT

显示表格中一个或数个字段的所有数据记录 语法：SELECT "字段" FROM "表名";

SELECT Store_Name FROM location;

SELECT Store_Name FROM Store_Info;

1.3 DISTINCT

不显示重复的数据记录

语法：SELECT DISTINCT "字段" FROM "表名";

SELECT DISTINCT Store_Name FROM Store_Info;

1.4 AND OR

且 或

语法：SELECT "字段" FROM "表名" WHERE "条件1" {[AND|OR] "条件2"}+ ;

1.5 in

显示已知的值的数据记录

语法：SELECT "字段" FROM "表名" WHERE "字段" IN ('值1', '值2', ...);

SELECT * FROM store_info WHERE Store_Name IN ('Los Angeles', 'Houston');

1.6 BETWEEN

显示两个值范围内的数据记录

语法：SELECT "字段" FROM "表名" WHERE "字段" BETWEEN '值1' AND '值2';

2. 通配符 —— 通常与 LIKE 搭配 一起使用

% ：百分号表示零个、一个或多个字符

_ ：下划线表示单个字符

'A_Z'：所有以 'A' 起头，另一个任何值的字符，且以 'Z' 为结尾的字符串。例如，'ABZ' 和 'A2Z' 都符合这一个模式，而 'AKKZ' 并不符合 (因为在 A 和 Z 之间有两个字符，而不是一个字符)。

'ABC%': 所有以 'ABC' 起头的字符串。例如，'ABCD' 和 'ABCABC' 都符合这个模式。 '%XYZ': 所有以 'XYZ' 结尾的字符串。例如，'WXYZ' 和 'ZZXYZ' 都符合这个模式。

'%AN%': 所有含有 'AN'这个模式的字符串。例如，'LOS ANGELES' 和 'SAN FRANCISCO' 都符合这个模式。

'_AN%'：所有第二个字母为 'A' 和第三个字母为 'N' 的字符串。例如，'SAN FRANCISCO' 符合这个模式，而 'LOS ANGELES' 则不符合这个模式。

2.1 LIKE

匹配一个模式来找出我们要的数据记录

语法：SELECT "字段" FROM "表名" WHERE "字段" LIKE {模式};

SELECT * FROM store_info WHERE Store_Name like '%os%';

2.2 ORDER BY

按关键字排序

语法：SELECT "字段" FROM "表名" [WHERE "条件"] ORDER BY "字段" [ASC, DESC];

注意：ASC 是按照升序进行排序的，是默认的排序方式。 DESC 是按降序方式进行排序

SELECT Store_Name,Sales,Date FROM store_info ORDER BY Sales DESC;

3. 函数

3.1数学函数

SELECT abs(-1), rand(), mod(5,3), power(2,3), round(1.89);

SELECT round(1.8937,3), truncate(1.235,2), ceil(5.2), floor(2.1), least(1.89,3,6.1,2.1);

3.2 聚合函数

SELECT avg(Sales) FROM store_info;



SELECT count(Store_Name) FROM store_info;

SELECT count(DISTINCT Store_Name) FROM store_info;



SELECT max(Sales) FROM store_info;

SELECT min(Sales) FROM store_info;



SELECT sum(Sales) FROM store_info;

3.3 字符串函数

如 sql_mode 开启了 PIPES_AS_CONCAT，"||" 视为字符串的连接操作符而非或运算符，和字符串的拼接函数Concat相类似，这和Oracle数据库使用方法一样的

SELECT Region || ' ' || Store_Name FROM location WHERE Store_Name = 'Boston';

SELECT substr(Store_Name,3) FROM location WHERE Store_Name = 'Los Angeles';

SELECT substr(Store_Name,2,4) FROM location WHERE Store_Name = 'New York'

SELECT TRIM ([ [位置] [要移除的字符串] FROM ] 字符串);

**[位置]：的值可以为 LEADING (起头), TRAILING (结尾), BOTH (起头及结尾)。 **

[要移除的字符串]：从字串的起头、结尾，或起头及结尾移除的字符串。缺省时为空格。

SELECT TRIM(LEADING 'Ne' FROM 'New York');

 

SELECT Region,length(Store_Name) FROM location;

 

SELECT REPLACE(Region,'ast','astern')FROM location;

4. GR0UP BY

对GR0UP BY后面的字段的查询结果进行汇总分组，通常是结合聚合函数一起使用的

GR0UP BY 有一个原则

• 凡是在 GR0UP BY 后面出现的字段，必须在 SELECT 后面出现；


• 凡是在 SELECT 后面出现的、且未在聚合函数中出现的字段，必须出现在 GR0UP BY 后面

语法：SELECT "字段1", SUM("字段2") FROM "表名" GR0UP BY "字段1";

SELECT Store_Name, SUM(Sales) FROM store_info GR0UP BY Store_Name ORDER BY sales desc;

5. 别名

字段別名 表格別名

语法：SELECT "表格別名"."字段1" [AS] "字段別名" FROM "表格名" [AS] "表格別名";

SELECT A.Store_Name Store, SUM(A.Sales) "Total Sales" FROM store_info A GR0UP BY A.Store_Name;

6. 子查询

子查询也被称作内查询或者嵌套查询，是指在一个查询语句里面还嵌套着另一个查询语 句。子查询语句是先于主查询语句被执行的，其结果作为外层的条件返回给主查询进行下一 步的查询过滤

连接表格，在WHERE 子句或 HAVING 子句中插入另一个 SQL 语句

语法：SELECT "字段1" FROM "表格1" WHERE "字段2" [比较运算符] #外查询 (SELECT "字段1" FROM "表格2" WHERE "条件"); #内查询

[比较运算符]

可以是符号的运算符，例如 =、>、<、>=、<= ；也可以是文字的运算符，例如 LIKE、IN、BETWEEN

SELECT SUM(Sales) FROM store_info WHERE Store_Name IN

(SELECT Store_Name FROM location WHERE Region = 'West');



SELECT SUM(A.Sales) FROM store_info A WHERE A.Store_Name IN

(SELECT Store_Name FROM location B WHERE B.Store_Name = A.Store_Name);

7. EXISTS

用来测试内查询有没有产生任何结果，类似布尔值是否为真 #如果有的话，系统就会执行外查询中的SQL语句。若是没有的话，那整个 SQL 语句就不会产生任何结果。

语法：SELECT "字段1" FROM "表格1" WHERE EXISTS (SELECT \* FROM "表格2" WHERE "条件");

SELECT SUM(Sales) FROM store_info WHERE EXISTS (SELECT * FROM location WHERE Region = 'West');

8. 连接查询

准备工作

create database k1;

use k1;

create table location (Region char(20),Store_Name char(20));

insert int0 location values('East','Boston');

insert int0 location values('East','New York');

insert int0 location values('West','Los Angeles');

insert int0 location values('West','Houston');

create table store_info (Store_Name char(20),Sales int(10),Date char(10));

insert int0 store_info values('Los Angeles','1500','2020-12-05');

insert int0 store_info values('Houston','250','2020-12-07');

insert int0 store_info values('Los Angeles','300','2020-12-08');

insert int0 store_info values('Boston','700','2020-12-08');

UPDATE store_info SET store_name='Washington' WHERE sales=300;

inner join(内连接)：只返回两个表中联结字段相等的行

left join(左连接)：返回包括左表中的所有记录和右表中联结字段相等的记录

right join(右连接)：返回包括右表中的所有记录和左表中联结字段相等的记录

8.1 内连接

MySQL 中的内连接就是两张或多张表中同时符合某种条件的数据记录的组合。通常在 FROM 子句中使用关键字 INNER JOIN 来连接多张表，并使用 ON 子句设置连接条件，内连接是系统默认的表连接，所以在 FROM 子句后可以省略 INNER 关键字，只使用 关键字 JOIN。同时有多个表时，也可以连续使用 INNER JOIN 来实现多表的内连接，不过为了更好的性能，建议最好不要超过三个表

(1) 语法 求交集

SELECT column_name(s)FROM table1 INNER JOIN table2 ON table1.column_name = table2.column_name;

SELECT * FROM location A INNER JOIN store_info B on A.Store_Name = B.Store_Name ;

内连查询：通过inner join 的方式将两张表指定的相同字段的记录行输出出来

8.2 左连接

左连接也可以被称为左外连接，在 FROM 子句中使用 LEFT JOIN 或者 LEFT OUTER JOIN 关键字来表示。左连接以左侧表为基础表，接收左表的所有行，并用这些行与右侧参 考表中的记录进行匹配，也就是说匹配左表中的所有行以及右表中符合条件的行。

SELECT * FROM location A LEFT JOIN store_info B on A.Store_Name = B.Store_Name ;

左连接中左表的记录将会全部表示出来，而右表只会显示符合搜索条件的记录，右表记录不足的地方均为 NULL

8.3 右连接

右连接也被称为右外连接，在 FROM 子句中使用 RIGHT JOIN 或者 RIGHT OUTER JOIN 关键字来表示。右连接跟左连接正好相反，它是以右表为基础表，用于接收右表中的所有行，并用这些记录与左表中的行进行匹配

SELECT * FROM location A RIGHT JOIN store_info B on A.Store_Name = B.Store_Name ;

9. UNION ----联集

将两个SQL语句的结果合并起来，两个SQL语句所产生的字段需要是同样的数据记录种类

UNION ：生成结果的数据记录值将没有重复，且按照字段的顺序进行排序

语法：[SELECT 语句 1] UNION [SELECT 语句 2];

SELECT Store_Name FROM location UNION SELECT Store_Name FROM store_info;

UNION ALL ：将生成结果的数据记录值都列出来，无论有无重复

语法：[SELECT 语句 1] UNION ALL [SELECT 语句 2];

SELECT Store_Name FROM location UNION ALL SELECT Store_Name FROM store_info;

9.1 交集值

取两个SQL语句结果的交集

SELECT A.Store_Name FROM location A INNER JOIN store_info B ON A.Store_Name = B.Store_Name;



SELECT A.Store_Name FROM location A INNER JOIN store_info B USING(Store_Name);

取两个SQL语句结果的交集，且没有重复

SELECT DISTINCT A.Store_Name FROM location A INNER JOIN store_info B USING(Store_Name);



SELECT DISTINCT Store_Name FROM location WHERE (Store_Name) IN (SELECT Store_Name FROM store_info);



SELECT DISTINCT A.Store_Name FROM location A LEFT JOIN store_info B USING(Store_Name) WHERE B.Store_Name IS NOT NULL;



SELECT A.Store_Name FROM (SELECT B.Store_Name FROM location B INNER JOIN store_info C ON B.Store_Name = C.Store_Name) A 

GR0UP BY A.Store_Name;



SELECT A.Store_Name FROM 

(SELECT DISTINCT Store_Name FROM location UNION ALL SELECT DISTINCT Store_Name FROM store_info) A 

GR0UP BY A.Store_Name HAVING COUNT(*) > 1;

9.2 无交集值

显示第一个SQL语句的结果，且与第二个SQL语句没有交集的结果，且没有重复

SELECT DISTINCT Store_Name FROM location WHERE (Store_Name) NOT IN (SELECT Store_Name FROM store_info);



SELECT DISTINCT A.Store_Name FROM location A LEFT JOIN store_info B USING(Store_Name) WHERE B.Store_Name IS NULL;



SELECT A.Store_Name FROM 

(SELECT DISTINCT Store_Name FROM location UNION ALL SELECT DISTINCT Store_Name FROM store_info) A 

GR0UP BY A.Store_Name HAVING COUNT(*) = 1;

10. case

是 SQL 用来做为 IF-THEN-ELSE 之类逻辑的关键字

语法：

SELECT CASE ("字段名")

  WHEN "条件1" THEN "结果1"

  WHEN "条件2" THEN "结果2"

  ...

  [ELSE "结果N"]

  END

FROM "表名";

"条件" 可以是一个数值或是公式。 ELSE 子句则并不是必须的。

SELECT Store_Name, CASE Store_Name 

  WHEN 'Los Angeles' THEN Sales * 2 

  WHEN 'Boston' THEN 2000

  ELSE Sales 

  END 

"New Sales",Date 

FROM store_info;



#"New Sales" 是用于 CASE 那个字段的字段名。

11. 正则表达式

语法：SELECT "字段" FROM "表名" WHERE "字段" REGEXP {模式};

SELECT * FROM store_info WHERE Store_Name REGEXP 'os';

SELECT * FROM store_info WHERE Store_Name REGEXP '^[A-G]';

SELECT * FROM store_info WHERE Store_Name REGEXP 'Ho|Bo';

12. 存储过程

存储过程是一组为了完成特定功能的SQL语句集合。

存储过程在使用过程中是将常用或者复杂的工作预先使用SQL语句写好并用一个指定的名称存储起来，这个过程经编译和优化后存储在数据库服务器中。当需要使用该存储过程时，只需要调用它即可。存储过程在执行上比传统SQL速度更快、执行效率更高。

存储过程的优点：

1、执行一次后，会将生成的二进制代码驻留缓冲区，提高执行效率

2、SQL语句加上控制语句的集合，灵活性高

3、在服务器端存储，客户端调用时，降低网络负载

4、可多次重复被调用，可随时修改，不影响客户端调用

5、可完成所有的数据库操作，也可控制数据库的信息访问权限

12.1 创建存储过程

DELIMITER $$							#将语句的结束符号从分号;临时改为两个$$(可以是自定义)

CREATE PROCEDURE Proc()					#创建存储过程，过程名为Proc，不带参数

-> BEGIN								#过程体以关键字 BEGIN 开始

-> select * from Store_Info;			#过程体语句

-> END $$								#过程体以关键字 END 结束

DELIMITER ;								#将语句的结束符号恢复为分号

实例

DELIMITER $$							#将语句的结束符号从分号;临时改为两个$$(可以自定义)

CREATE PROCEDURE Proc5()				#创建存储过程，过程名为Proc5，不带参数

-> BEGIN								#过程体以关键字 BEGIN 开始

-> create table user (id int (10), name char(10),score int (10));

-> insert int0 user values (1, 'cyw',70);

-> select * from cyw;			        #过程体语句

-> END $$								#过程体以关键字 END 结束

DELIMITER ;								#将语句的结束符号恢复为分号

12.2 调用存储过程

CALL Proc;

12.3 查看存储过程

SHOW CREATE PROCEDURE [数据库.]存储过程名; #查看某个存储过程的具体信息

SHOW CREATE PROCEDURE Proc;



SHOW PROCEDURE STATUS [LIKE '%Proc%'] \G

12.4 存储过程的参数

**IN 输入参数：**表示调用者向过程传入值（传入值可以是字面量或变量）

**OUT 输出参数：**表示过程向调用者传出值(可以返回多个值)（传出值只能是变量）

**INOUT 输入输出参数：**既表示调用者向过程传入值，又表示过程向调用者传出值（值只能是变量）

DELIMITER $$				

CREATE PROCEDURE Proc6(IN inname CHAR(16))		

-> BEGIN					

-> SELECT * FROM store_info WHERE Store_Name = inname;

-> END $$					

DELIMITER ;					



CALL Proc6('Boston');

12.5 修改存储过程

ALTER PROCEDURE <过程名>[<特征>... ]

ALTER PROCEDURE GetRole MODIFIES SQL DATA SQL SECURITY INVOKER;

MODIFIES sQLDATA:表明子程序包含写数据的语句

SECURITY:安全等级

invoker:当定义为INVOKER时，只要执行者有执行权限，就可以成功执行。

12.6 删除存储过程

存储过程内容的修改方法是通过删除原有存储过程，之后再以相同的名称创建新的存储过程。如果要修改存储过程的名称，可以先删除原存储过程，再以不同的命名创建新的存储过程。

DROP PROCEDURE IF EXISTS Proc;		

#仅当存在时删除，不添加 IF EXISTS 时，如果指定的过程不存在，则产生一个错误

13. 条件语句

if-then-else ···· end if

mysql> delimiter $$

mysql> 

mysql> CREATE PROCEDURE proc8(IN pro int)

    -> 

    -> begin

    -> 

    -> declare var int; 

    -> set var=pro*2;

    -> if var>=10 then 

    -> update t set id=id+1;

    -> else

    -> update t set id=id-1;

    -> end if;

    -> end $$



mysql> delimiter ;

14. 循环语句

while ···· end while

mysql> delimiter $$

mysql> 

mysql> create procedure proc9()

    -> begin 

    -> declare var int(10);  

    -> set var=0;

    -> while var<6 do 

    -> insert int0 t values(var);

    -> set var=var+1;

    -> end while;

    -> end $$ 



mysql> delimiter ;

15. 视图表 create view

15.1 视图表概述

视图，可以被当作是虚拟表或存储查询。

视图跟表格的不同是，表格中有实际储存数据记录，而视图是建立在表格之上的一个架构，它本身并不实际储存数据记录。

临时表在用户退出或同数据库的连接断开后就自动消失了，而视图不会消失。
视图不含有数据，只存储它的定义，它的用途一般可以简化复杂的查询。

比如你要对几个表进行连接查询，而且还要进行统计排序等操作，写sql语句会很麻烦的，用视图将几个表联结起来，然后对这个视图进行查询操作，就和对一个表查询一样，很方便。

15.2 视图表能否修改？

首先我们需要知道，视图表保存的是select语句的定义，所以视图表可不可以修改需要视情况而定。

• 如果 select 语句查询的字段是没有被处理过的源表字段，则可以通过视图表修改源表数据；


• 如果select 语句查询的字段是被 gr0up by语句或 函数 处理过的字段，则不可以直接修改视图表的数据。

create view v_store_info as select store_name,sales from store_info;



update v_store_info set sales=1000 where store_name='Houston';

create view v_sales as select store_name,sum(sales) from store_info gr0up by store_name having sum(sales)>1000;



update v_sales set store_name='xxxx' where store_name='Los Angeles';

15.3 基本语法

15.3.1 创建视图表

语法

create view "视图表名" as "select 语句";

create view v_region_sales as select a.region region,sum(b.sales) sales from location a 

inner join store_info b on a.store_name = b.store_name gr0up by region;

15.4 查看视图表

语法

select * from 视图表名;

select * from v_region_sales;

15.5 删除视图表

语法

drop view 视图表名;

drop view v_region_sales;

15.6 通过视图表求无交集值

将两个表中某个字段的不重复值进行合并

只出现一次（count =1 ） ，即无交集

通过

create view 视图表名 as select distinct 字段 from 左表 union all select distinct 字段 from 右表;



select 字段 from 视图表名 gr0up by 字段 having count(字段)=1;

#先建立视图表

create viem v_union as select distinct store_name from location union all select distinct store_name from store_info;

#再通过视图表求无交集

select store_name from v_union gr0up by store_name having count(*)=1;

大家好，我是三友~~

今天就应某位小伙伴的要求，来讲一讲Nacos作为服务注册中心底层的实现原理

不知你是否跟我一样，在使用Nacos时有以下几点疑问：

• 临时实例和永久实例是什么？有什么区别？


• 服务实例是如何注册到服务端的？


• 服务实例和服务端之间是如何保活的？


• 服务订阅是如何实现的？


• 集群间数据是如何同步的？CP还是AP？


• Nacos的数据模型是什么样的？


• ...

本文就通过探讨上述问题来探秘Nacos服务注册中心核心的底层实现原理。

虽然Nacos最新版本已经到了2.x版本，但是为了照顾那些还在用1.x版本的同学，所以本文我会同时去讲1.x版本和2.x版本的实现

临时实例和永久实例

临时实例和永久实例在Nacos中是一个非常非常重要的概念

之所以说它重要，主要是因为我在读源码的时候发现，临时实例和永久实例在底层的许多实现机制是完全不同的

临时实例

临时实例在注册到注册中心之后仅仅只保存在服务端内部一个缓存中，不会持久化到磁盘

这个服务端内部的缓存在注册中心届一般被称为服务注册表

当服务实例出现异常或者下线之后，就会把这个服务实例从服务注册表中剔除

永久实例

永久服务实例不仅仅会存在服务注册表中，同时也会被持久化到磁盘文件中

当服务实例出现异常或者下线，Nacos只会将服务实例的健康状态设置为不健康，并不会对将其从服务注册表中剔除

所以这个服务实例的信息你还是可以从注册中心看到，只不过处于不健康状态

这是就是两者最最最基本的区别

当然除了上述最基本的区别之外，两者还有很多其它的区别，接下来本文还会提到

这里你可能会有一个疑问

为什么Nacos要将服务实例分为临时实例和永久实例?

主要还是因为应用场景不同

临时实例就比较适合于业务服务，服务下线之后可以不需要在注册中心中查看到

永久实例就比较适合需要运维的服务，这种服务几乎是永久存在的，比如说MySQL、Redis等等

MySQL、Redis等服务实例可以通过SDK手动注册

对于这些服务，我们需要一直看到服务实例的状态，即使出现异常，也需要能够查看时实的状态

所以从这可以看出Nacos跟你印象中的注册中心不太一样，他不仅仅可以注册平时业务中的实例，还可以注册像MySQL、Redis这个服务实例的信息到注册中心

在SpringCloud环境底下，一般其实都是业务服务，所以默认注册服务实例都是临时实例

当然如果你想改成永久实例，可以通过下面这个配置项来完成

spring

  cloud:

    nacos:

      discovery:

        #ephemeral单词是临时的意思，设置成false，就是永久实例了

        ephemeral: false

这里还有一个小细节

在1.x版本中，一个服务中可以既有临时实例也有永久实例，服务实例是永久还是临时是由服务实例本身决定的

但是2.x版本中，一个服务中的所有实例要么都是临时的要么都是永久的，是由服务决定的，而不是具体的服务实例

所以在2.x可以说是临时服务和永久服务

为什么2.x把临时还是永久的属性由实例本身决定改成了由服务决定?

其实很简单，你想想，假设对一个MySQL服务来说，它的每个服务实例肯定都是永久的，不会出现一些是永久的，一些是临时的情况吧

所以临时还是永久的属性由服务本身决定其实就更加合理了

服务注册

作为一个服务注册中心，服务注册肯定是一个非常重要的功能

所谓的服务注册，就是通过注册中心提供的客户端SDK（或者是控制台）将服务本身的一些元信息，比如ip、端口等信息发送到注册中心服务端

服务端在接收到服务之后，会将服务的信息保存到前面提到的服务注册表中

1、1.x版本的实现

在Nacos在1.x版本的时候，服务注册是通过Http接口实现的

代码如下

整个逻辑比较简单，因为Nacos服务端本身就是用SpringBoot写的

但是在2.x版本的实现就比较复杂了

2、2.x版本的实现

2.1、通信协议的改变

2.x版本相比于1.x版本最主要的升级就是客户端和服务端通信协议的改变，由1.x版本的Http改成了2.x版本gRPC

gRPC是谷歌公司开发的一个高性能、开源和通用的RPC框架，Java版本的实现底层也是基于Netty来的

之所以改成了gRPC，主要是因为Http请求会频繁创建和销毁连接，白白浪费资源

所以在2.x版本之后，为了提升性能，就将通信协议改成了gRPC

根据官网显示，整体的效果还是很明显，相比于1.x版本，注册性能总体提升至少2倍

虽然通信方式改成了gRPC，但是2.x版本服务端依然保留了Http注册的接口，所以用1.x的Nacos SDK依然可以注册到2.x版本的服务端

2.2、具体的实现

Nacos客户端在启动的时候，会通过gRPC跟服务端建立长连接

这个连接会一直存在，之后客户端与服务端所有的通信都是基于这个长连接来的

当客户端发起注册的时候，就会通过这个长连接，将服务实例的信息发送给服务端

服务端拿到服务实例，跟1.x一样，也会存到服务注册表

除了注册之外，当注册的是临时实例时，2.x还会将服务实例信息存储到客户端中的一个缓存中，供Redo操作

所谓的Redo操作，其实就是一个补偿机制，本质是个定时任务，默认每3s执行一次

这个定时任务作用是，当客户端与服务端重新建立连接时（因为一些异常原因导致连接断开）

那么之前注册的服务实例肯定还要继续注册服务端（断开连接服务实例就会被剔除服务注册表）

所以这个Redo操作一个很重要的作用就是重连之后的重新注册的作用

除了注册之外，比如服务订阅之类的操作也需要Redo操作，当连接重新建立，之前客户端的操作都需要Redo一下

小总结

1.x版本是通过Http协议来进行服务注册的

2.x由于客户端与服务端的通信改成了gRPC长连接，所以改成通过gRPC长连接来注册

2.x比1.x多个Redo操作，当注册的服务实例是临时实例是，出现网络异常，连接重新建立之后，客户端需要将服务注册、服务订阅之类的操作进行重做

这里你可能会有个疑问

既然2.x有Redo机制保证客户端与服务端通信正常之后重新注册，那么1.x有类似的这种Redo机制么？

当然也会有，接下往下看。

心跳机制

心跳机制，也可以被称为保活机制，它的作用就是服务实例告诉注册中心我这个服务实例还活着

在正常情况下，服务关闭了，那么服务会主动向Nacos服务端发送一个服务下线的请求

Nacos服务端在接收到请求之后，会将这个服务实例从服务注册表中剔除

但是对于异常情况下，比如出现网络问题，可能导致这个注册的服务实例无法提供服务，处于不可用状态，也就是不健康

而此时在没有任何机制的情况下，服务端是无法知道这个服务处于不可用状态

所以为了避免这种情况，一些注册中心，就比如Nacos、Eureka，就会用心跳机制来判断这个服务实例是否能正常

在Nacos中，心跳机制仅仅是针对临时实例来说的，临时实例需要靠心跳机制来保活

心跳机制在1.x和2.x版本的实现也是不一样的

1.x心跳实现

在1.x中，心跳机制实现是通过客户端和服务端各存在的一个定时任务来完成的

在服务注册时，发现是临时实例，客户端会开启一个5s执行一次的定时任务

这个定时任务会构建一个Http请求，携带这个服务实例的信息，然后发送到服务端

在Nacos服务端也会开启一个定时任务，默认也是5s执行一次，去检查这些服务实例最后一次心跳的时间，也就是客户端最后一次发送Http请求的时间

• 当最后一次心跳时间超过15s，但没有超过30s，会把这服务实例标记成不健康


• 当最后一次心跳超过30s，直接把服务从服务注册表中剔除

这就是1.x版本的心跳机制，本质就是两个定时任务

其实1.x的这个心跳还有一个作用，就是跟上一节说的gRPC时Redo操作的作用是一样的

服务在处理心跳的时候，发现心跳携带这个服务实例的信息在注册表中没有，此时就会添加到服务注册表

所以心跳也有Redo的类似效果

2.x心跳实现

在2.x版本之后，由于通信协议改成了gRPC，客户端与服务端保持长连接，所以2.x版本之后它是利用这个gRPC长连接本身的心跳来保活

一旦这个连接断开，服务端就会认为这个连接注册的服务实例不可用，之后就会将这个服务实例从服务注册表中提出剔除

除了连接本身的心跳之外，Nacos还有服务端的一个主动检测机制

Nacos服务端也会启动一个定时任务，默认每隔3s执行一次

这个任务会去检查超过20s没有发送请求数据的连接

一旦发现有连接已经超过20s没发送请求，那么就会向这个连接对应的客户端发送一个请求

如果请求不通或者响应失败，此时服务端也会认为与客户端的这个连接异常，从而将这个客户端注册的服务实例从服务注册表中剔除

所以对于2.x版本，主要是两种机制来进行保活：

• 连接本身的心跳机制，断开就直接剔除服务实例


• Nacos主动检查机制，服务端会对20s没有发送数据的连接进行检查，出现异常时也会主动断开连接，剔除服务实例

小总结

心跳机制仅仅针对临时实例而言

1.x心跳机制是通过客户端和服务端两个定时任务来完成的，客户端定时上报心跳信息，服务端定时检查心跳时间，超过15s标记不健康，超过30s直接剔除

1.x心跳机制还有类似2.x的Redo作用，服务端发现心跳的服务信息不存在会，会将服务信息添加到注册表，相当于重新注册了

2.x是基于gRPC长连接本身的心跳机制和服务端的定时检查机制来的，出现异常直接剔除

健康检查

前面说了，心跳机制仅仅是临时实例用来保护的机制

而对于永久实例来说，一般来说无法主动上报心跳

就比如说MySQL实例，肯定是不会主动上报心跳到Nacos的，所以这就导致无法通过心跳机制来保活

所以针对永久实例的情况，Nacos通过一种叫健康检查的机制去判断服务实例是否活着

健康检查跟心跳机制刚好相反，心跳机制是服务实例向服务端发送请求

而所谓的健康检查就是服务端主动向服务实例发送请求，去探测服务实例是否活着

健康检查机制在1.x和2.x的实现机制是一样的

Nacos服务端在会去创建一个健康检查任务，这个任务每次执行时间间隔会在2000~7000毫秒之间

当任务触发的时候，会根据设置的健康检查的方式执行不同的逻辑，目前主要有以下三种方式：

• TCP


• HTTP


• MySQL

TCP的方式就是根据服务实例的ip和端口去判断是否能连接成功，如果连接成功，就认为健康，反之就任务不健康

HTTP的方式就是向服务实例的ip和端口发送一个Http请求，请求路径是需要设置的，如果能正常请求，说明实例健康，反之就不健康

MySQL的方式是一种特殊的检查方式，他可以执行下面这条Sql来判断数据库是不是主库

默认情况下，都是通过TCP的方式来探测服务实例是否还活着

服务发现

所谓的服务发现就是指当有服务实例注册成功之后，其它服务可以发现这些服务实例

Nacos提供了两种发现方式：

• 主动查询


• 服务订阅

主动查询就是指客户端主动向服务端查询需要关注的服务实例，也就是拉（pull）的模式

服务订阅就是指客户端向服务端发送一个订阅服务的请求，当被订阅的服务有信息变动就会主动将服务实例的信息推送给订阅的客户端，本质就是推（push）模式

在我们平时使用时，一般来说都是选择使用订阅的方式，这样一旦有服务实例数据的变动，客户端能够第一时间感知

并且Nacos在整合SpringCloud的时候，默认就是使用订阅的方式

对于这两种服务发现方式，1.x和2.x版本实现也是不一样

服务查询其实两者实现都很简单

1.x整体就是发送Http请求去查询服务实例，2.x只不过是将Http请求换成了gRPC的请求

服务端对于查询的处理过程都是一样的，从服务注册表中查出符合查询条件的服务实例进行返回

不过对于服务订阅，两者的机制就稍微复杂一点

在Nacos客户端，不论是1.x还是2.x都是通过SDK中的NamingService#subscribe方法来发起订阅的

当有服务实例数据变动的时，客户端就会回调EventListener，就可以拿到最新的服务实例数据了

虽然1.x还是2.x都是同样的方法，但是具体的实现逻辑是不一样的

1.x服务订阅实现

在1.x版本的时候，服务订阅的处理逻辑大致会有以下三步：

第一步，客户端在启动的时候，会去构建一个叫PushReceiver的类

这个类会去创建一个UDP Socket，端口是随机的

其实通过名字就可以知道这个类的作用，就是通过UDP的方式接收服务端推送的数据的

第二步，调用NamingService#subscribe来发起订阅时，会先去服务端查询需要订阅服务的所有实例信息

之后会将所有服务实例数据存到客户端的一个内部缓存中

并且在查询的时候，会将这个UDP Socket的端口作为一个参数传到服务端

服务端接收到这个UDP端口后，后续就通过这个端口给客户端推送服务实例数据

第三步，会为这次订阅开启一个不定时执行的任务

之所以不定时，是因为这个当执行异常的时候，下次执行的时间间隔就会变长，但是最多不超过60s，正常是10s，这个10s是查询服务实例是服务端返回的

这个任务会去从服务端查询订阅的服务实例信息，然后更新内部缓存

这里你可能会有个疑问

既然有了服务变动推送的功能，为什么还要定时去查询更新服务实例信息呢?

其实很简单，那就是因为UDP通信不稳定导致的

虽然有Push，但是由于UDP通信自身的不确定性，有可能会导致客户端接收变动信息失败

所以这里就加了一个定时任务，弥补这种可能性，属于一个兜底的方案。

这就是1.x版本的服务订阅的实现

2.x服务订阅的实现

讲完1.x的版本实现，接下来就讲一讲2.x版本的实现

由于2.x版本换成了gRPC长连接的方式，所以2.x版本服务数据变更推送已经完全抛弃了1.x的UDP做法

当有服务实例变动的时候，服务端直接通过这个长连接将服务信息发送给客户端

客户端拿到最新服务实例数据之后的处理方式就跟1.x是一样了

除了处理方式一样，2.x也继承了1.x的其他的东西

比如客户端依然会有服务实例的缓存

定时对比机制也保留了，只不过这个定时对比的机制默认是关闭状态

之所以默认关闭，主要还是因为长连接还是比较稳定的原因

当客户端出现异常，接收不到请求，那么服务端会直接跟客户端断开连接

当恢复正常，由于有Redo操作，所以还是能拿到最新的实例信息的

所以2.x版本的服务订阅功能的实现大致如下图所示

这里还有个细节需要注意

在1.x版本的时候，任何服务都是可以被订阅的

但是在2.x版本中，只支持订阅临时服务，对于永久服务，已经不支持订阅了

小总结

服务查询1.x是通过Http请求；2.x通过gRPC请求

服务订阅1.x是通过UDP来推送的；2.x就基于gRPC长连接来实现的

1.x和2.x客户端都有服务实例的缓存，也有定时对比机制，只不过1.x会自动开启；2.x提供了一个开个，可以手动选择是否开启，默认不开启

数据一致性

由于Nacos是支持集群模式的，所以一定会涉及到分布式系统中不可避免的数据一致性问题

1、服务实例的责任机制

再说数据一致性问题之前，先来讨论一下服务实例的责任机制

什么是服务实例的责任机制？

比如上面提到的服务注册、心跳管理、监控检查机制，当只有一个Nacos服务时，那么自然而言这个服务会去检查所有的服务实例的心跳时间，执行所有服务实例的健康检查任务

但是当出现Nacos服务出现集群时，为了平衡各Nacos服务的压力，Nacos会根据一定的规则让每个Nacos服务只管理一部分服务实例的

当然每个Nacos服务的注册表还是全部的服务实例数据

这个管理机制我给他起了一个名字，就叫做责任机制，因为我在1.x和2.x都提到了responsible这个单词

本质就是Nacos服务对哪些服务实例负有心跳监测，健康检查的责任。

2、CAP定理和BASE理论

谈到数据一致性问题，一定离不开两个著名分布式理论

• CAP定理


• BASE理论

CAP定理中，三个字母分别代表这些含义：

• C，Consistency单词的缩写，代表一致性，指分布式系统中各个节点的数据保持强一致，也就是每个时刻都必须一样，不一样整个系统就不能对外提供服务


• A，Availability单词的缩写，代表可用性，指整个分布式系统保持对外可用，即使从每个节点获取的数据可能都不一样，只要能获取到就行


• P，Partition tolerance单词的缩写，代表分区容错性。

所谓的CAP定理，就是指在一个分布式系统中，CAP这三个指标，最多同时只能满足其中的两个，不可能三个都同时满足

为什么三者不能同时满足？

对于一个分布式系统，网络分区是一定需要满足的

而所谓分区指的是系统中的服务部署在不同的网络区域中

比如，同一套系统可能同时在北京和上海都有部署，那么他们就处于不同的网络分区，就可能出现无法互相访问的情况

当然，你也可以把所有的服务都放在一个网络分区，但是当网络出现故障时，整个系统都无法对外提供服务，那这还有什么意义呢？

所以分布式系统一定需要满足分区容错性，把系统部署在不同的区域网络中

此时只剩下了一致性和可用性，它们为什么不能同时满足？

其实答案很简单，就因为可能出现网络分区导致的通信失败。

比如说，现在出现了网络分区的问题，上图中的A网络区域和B网络区域无法相互访问

此时假设往上图中的A网络区域发送请求，将服务中的一个值 i 属性设置成 1

如果保证可用性，此时由于A和B网络不通，此时只有A中的服务修改成功，B无法修改成功，此时数据AB区域数据就不一致性，也就没有保证数据一致性

如果保证一致性，此时由于A和B网络不通，所以此时A也不能修改成功，必须修改失败，否则就会导致AB数据不一致

虽然A没修改成功，保证了数据一致性，AB还是之前相同的数据，但是此时整个系统已经没有写可用性了，无法成功写数据了。

所以从上面分析可以看出，在有分区容错性的前提下，可用性和一致性是无法同时保证的。

虽然无法同时一致性和可用性，但是能不能换种思路来思考一下这个问题

首先我们可以先保证系统的可用性，也就是先让系统能够写数据，将A区域服务中的i修改成1

之后当AB区域之间网络恢复之后，将A区域的i值复制给B区域，这样就能够保证AB区域间的数据最终是一致的了

这不就皆大欢喜了么

这种思路其实就是BASE理论的核心要点，优先保证可用性，数据最终达成一致性。

BASE理论主要是包括以下三点：

• 基本可用（Basically Available）：系统出现故障还是能够对外提供服务，不至于直接无法用了


• 软状态（Soft State）：允许各个节点的数据不一致


• 最终一致性，（Eventually Consistent）：虽然允许各个节点的数据不一致，但是在一定时间之后，各个节点的数据最终需要一致的

BASE理论其实就是妥协之后的产物。

3、Nacos的AP和CP

Nacos其实目前是同时支持AP和CP的

具体使用AP还是CP得取决于Nacos内部的具体功能，并不是有的文章说的可以通过一个配置自由切换。

就以服务注册举例来说，对于临时实例来说，Nacos会优先保证可用性，也就是AP

对于永久实例，Nacos会优先保证数据的一致性，也就是CP

接下来我们就来讲一讲Nacos的CP和AP的实现原理

3.1、Nacos的AP实现

对于AP来说，Nacos使用的是阿里自研的Distro协议

在这个协议中，每个服务端节点是一个平等的状态，每个服务端节点正常情况下数据是一样的，每个服务端节点都可以接收来自客户端的读写请求

当某个节点刚启动时，他会向集群中的某个节点发送请求，拉取所有的服务实例数据到自己的服务注册表中

这样其它客户端就可以从这个服务节点中获取到服务实例数据了

当某个服务端节点接收到注册临时服务实例的请求，不仅仅会将这个服务实例存到自身的服务注册表，同时也会向其它所有服务节点发送请求，将这个服务数据同步到其它所有节点

所以此时从任意一个节点都是可以获取到所有的服务实例数据的。

即使数据同步的过程发生异常，服务实例也成功注册到一个Nacos服务中，对外部而言，整个Nacos集群是可用的，也就达到了AP的效果

同时为了满足BASE理论，Nacos也有下面两种机制保证最终节点间数据最终是一致的：

• 失败重试机制


• 定时对比机制

失败重试机制是指当数据同步给其它节点失败时，会每隔3s重试一次，直到成功

定时对比机制就是指，每个Nacos服务节点会定时向所有的其它服务节点发送一些认证的请求

这个请求会告诉每个服务节点自己负责的服务实例的对应的版本号，这个版本号随着服务实例的变动就会变动

如果其它服务节点的数据的版本号跟自己的对不上，那就说明其它服务节点的数据不是最新的

此时这个Nacos服务节点就会将自己负责的服务实例数据发给不是最新数据的节点，这样就保证了每个节点的数据是一样的了。

3.2、Nacos的CP实现

Nacos的CP实现是基于Raft算法来实现的

在1.x版本早期，Nacos是自己手动实现Raft算法

在2.x版本，Nacos移除了手动实现Raft算法，转而拥抱基于蚂蚁开源的JRaft框架

在Raft算法，每个节点主要有三个状态

• Leader，负责所有的读写请求，一个集群只有一个


• Follower，从节点，主要是负责复制Leader的数据，保证数据的一致性


• Candidate，候选节点，最终会变成Leader或者Follower

集群启动时都是节点Follower，经过一段时间会转换成Candidate状态，再经过一系列复杂的选择算法，选出一个Leader

这个选举算法比较复杂，完全值得另写一篇文章，这里就不细说了。不过立个flag，如果本篇文章点赞量超过28个，我连夜爆肝，再来一篇。

当有写请求时，如果请求的节点不是Leader节点时，会将请求转给Leader节点，由Leader节点处理写请求

比如，有个客户端连到的上图中的Nacos服务2节点，之后向Nacos服务2注册服务

Nacos服务2接收到请求之后，会判断自己是不是Leader节点，发现自己不是

此时Nacos服务2就会向Leader节点发送请求，Leader节点接收到请求之后，会处理服务注册的过程

为什么说Raft是保证CP的呢？

主要是因为Raft在处理写的时候有一个判断过程

• 首先，Leader在处理写请求时，不会直接数据应用到自己的系统，而是先向所有的Follower发送请求，让他们先处理这个请求


• 当超过半数的Follower成功处理了这个写请求之后，Leader才会写数据，并返回给客户端请求处理成功


• 如果超过一定时间未收到超过半数处理成功Follower的信号，此时Leader认为这次写数据是失败的，就不会处理写请求，直接返回给客户端请求失败

所以，一旦发生故障，导致接收不到半数的Follower写成功的响应，整个集群就直接写失败，这就很符合CP的概念了。

不过这里还有一个小细节需要注意

Nacos在处理查询服务实例的请求直接时，并不会将请求转发给Leader节点处理，而是直接查当前Nacos服务实例的注册表

这其实就会引发一个问题

如果客户端查询的Follower节点没有及时处理Leader同步过来的写请求（过半响应的节点中不包括这个节点），此时在这个Follower其实是查不到最新的数据的，这就会导致数据的不一致

所以说，虽然Raft协议规定要求从Leader节点查最新的数据，但是Nacos至少在读服务实例数据时并没有遵守这个协议

当然对于其它的一些数据的读写请求有的还是遵守了这个协议。

JRaft对于读请求其实是做了很多优化的，其实从Follower节点通过一定的机制也是能够保证读到最新的数据

数据模型

在Nacos中，一个服务的确定是由三部分信息确定

• 命名空间（Namespace）：多租户隔离用的，默认是public


• 分组（Gr0up）：这个其实可以用来做环境隔离，服务注册时可以指定服务的分组，比如是测试环境或者是开发环境，默认是DEFAULT_GR0UP


• 服务名（ServiceName）：这个就不用多说了

通过上面三者就可以确定同一个服务了

在服务注册和订阅的时候，必须要指定上述三部分信息，如果不指定，Nacos就会提供默认的信息

不过，在Nacos中，在服务里面其实还是有一个集群的概念

在服务注册的时候，可以指定这个服务实例在哪个集体的集群中，默认是在DEFAULT集群下

在SpringCloud环境底下可以通过如下配置去设置

spring

  cloud:

    nacos:

      discovery:

        cluster-name: sanyoujavaCluster

在服务订阅的时候，可以指定订阅哪些集群下的服务实例

当然，也可以不指定，如果不指定话，默认就是订阅这个服务下的所有集群的服务实例

我们日常使用中可以将部署在相同区域的服务划分为同一个集群，比如杭州属于一个集群，上海属于一个集群

这样服务调用的时候，就可以优先使用同一个地区的服务了，比跨区域调用速度更快。

总结

到这，终终终于总算是讲完了Nacos作为注册中心核心的实现原理

1 ELK日志系统

经典的ELK架构或现被称为Elastic Stack。Elastic Stack架构为Elasticsearch + Logstash + Kibana + Beats的组合：

• Beats负责日志的采集


• Logstash负责做日志的聚合和处理


• ES作为日志的存储和搜索系统


• Kibana作为可视化前端展示

整体架构图：

2 EFK日志系统

容器化场景中，尤其k8s环境，用户经常使用EFK架构。F代表Fluent Bit，一个开源多平台的日志处理器和转发器。Fluent Bit可以：

• 让用户从不同来源收集数据/日志


• 统一并发到多个目的地


• 完全兼容Docker和k8s环境

3 PLG日志系统

3.1 Prometheus+k8s日志系统

PLG

Grafana Labs提供的另一个日志解决方案PLG逐渐流行。PLG架构即Promtail + Loki + Grafana的组合：

Grafana，开源的可视化和分析软件，允许用户查询、可视化、警告和探索监控指标。Grafana主要提供时间序列数据的仪表板解决方案，支持超过数十种数据源。

Grafana Loki是一组可以组成一个功能齐全的日志堆栈组件，与其它日志系统不同，Loki只建立日志标签的索引而不索引原始日志消息，而是为日志数据设置一组标签，即Loki运营成本更低，效率还提高几个数量级。

Loki设计理念

Prometheus启发，可实现可水平扩展、高可用的多租户日志系统。Loki整体架构由不同组件协同完成日志收集、索引、存储等。

各组件如下，Loki’s Architecture深入了解。Loki就是like Prometheus, but for logs。

Promtail是一个日志收集的代理，会将本地日志内容发到一个Loki实例，它通常部署到需要监视应用程序的每台机器/容器上。Promtail主要是用来发现目标、将标签附加到日志流以及将日志推送到Loki。截止到目前，Promtail可以跟踪两个来源的日志：本地日志文件和systemd日志（仅支持AMD64架构）。

4 PLG V.S ELK

4.1 ES V.S Loki

ELK/EFK架构确实强，经多年实际环境验证。存储在ES中的日志通常以非结构化JSON对象形式存储在磁盘，且ES为每个对象都建索引，以便全文搜索，然后用户可特定查询语言搜索这些日志数据。

而Loki数据存储解耦：

• 既可在磁盘存储


• 也可用如Amazon S3云存储系统

Loki日志带有一组标签名和值，只有标签对被索引，这种权衡使它比完整索引操作成本更低，但针对基于内容的查询，需通过LogQL再单独查询。

4.2 Fluentd V.S Promtail

相比Fluentd，Promtail专为Loki定制，它可为运行在同一节点的k8s Pods做服务发现，从指定文件夹读取日志。Loki类似Prometheus的标签方式。因此，当与Prometheus部署在同一环境，因为相同的服务发现机制，来自Promtail的日志通常具有与应用程序指标相同的标签，统一标签管理。

4.3 Grafana V.S Kibana

Kibana提供许多可视化工具来进行数据分析，高级功能如异常检测等机器学习功能。Grafana针对Prometheus和Loki等时间序列数据打造，可在同一仪表板上查看日志指标。

参考

• http://www.javaedge.cn/#/special

前言

大家好，我是林三心，用最通俗易懂的话讲最难的知识点是我的座右铭，基础是进阶的前提是我的初心~

ffmpeg

FFmpeg 是一个开源的、跨平台的多媒体框架，它可以用来录制、转换和流式传输音频和视频。它包括了一系列的库和工具，用于处理多媒体内容，比如 libavcodec（一个编解码库），libavformat（一个音视频容器格式库），libavutil（一个实用库），以及 ffmpeg 命令行工具本身。

FFmpeg 被广泛用于各种应用中，包括视频转换、视频编辑、视频压缩、直播流处理等。它支持多种音视频编解码器和容器格式，因此能够处理几乎所有类型的音视频文件。由于其功能强大和灵活性，FFmpeg 成为了许多视频相关软件和服务的底层技术基础。

很多网页都是用 ffmpeg 来进行视频切片，比如一个视频很大，如果通过一个连接去请求整个视频的话，那势必会导致加载时间过长，严重阻碍了用户观感

所以很多视频网站都会通过视频切片的方式来优化用户观感，就是一部分一部分地去加载出来，这样有利于用户的体验

安装 ffmpeg

安装包下载

首先到 ffmpeg 的安装网页：http://www.gyan.dev/ffmpeg/buil…

下载解压后将文件夹改名为 ffmpeg

环境变量配置

环境变量配置是为了能在电脑上使用 ffmpeg 命令行

体验 ffmpeg

先准备一个视频，比如我准备了一个视频，总共 300 多 M

视频切片

并在当前的目录下输入以下的命令

 ffmpeg -i jhys.mkv 

 -c:v libx264 

 -c:a aac 

 -hls_time 60 

 -hls_segment_type mpegts 

 -hls_list_size 0 

 -f hls 

 -max_muxing_queue_size 1024 

 output.m3u8

接着 ffmpeg 会帮你将这个视频进行分片

直到切片步骤执行完毕，我们可以看到视频已经别切成几个片了

在这个命令中：

• -i input_video.mp4 指定了输入视频文件。


• -c:v libx264 -c:a aac 指定了视频和音频的编解码器。


• -hls_time 10 指定了每个 M3U8 片段的时长，单位为秒。在这里，每个片段的时长设置为 10 秒。


• -hls_segment_type mpegts 指定了 M3U8 片段的类型为 MPEG-TS。


• -hls_list_size 0 设置 M3U8 文件中包含的最大片段数。这里设置为 0 表示没有限制。


• -f hls 指定了输出格式为 HLS。


• -max_muxing_queue_size 1024 设置了最大复用队列大小，以确保输出不会超过指定大小。


• 最后输出的文件为 output.m3u8

视频播放

创建一个简单的前端项目

可以看到浏览器会加载所有的视频切片

前言

开发过程中其实有很多小细节要去注意，只有不断去抠细节，写出精益求精的代码，从量变中收获质变。

技术的进步并非一蹴而就，而是通过无数次的量变，才能引发质的飞跃。我们始终坚信，只有对每一个细节保持敏锐的触觉，才能绽放出完美的技术之花。

从一行行代码中，我们品味到了追求卓越的滋味。每一个小小的优化，每一个微妙的改进，都是我们追求技艺的印记。我们知道，只有更多的关注细节，才能真正理解技术的本质，洞察其中的玄机。正是在对细节的把握中，我们得以成就更好的技术人生。

耐心看完，你一定会有所收获。

补充

20230928

针对评论区指出的第14条示例的问题，现已修正。

原来的示例贴在这里，接受大家的批评：

1. 代码风格一致性：

代码风格一致性可以提高代码的可读性和可维护性。例如，使用Java编程中普遍遵循的命名约定（驼峰命名法），使代码更易于理解。

// 不好的代码风格

int g = 10;

String S = "Hello";



// 好的代码风格

int count = 10;

String greeting = "Hello";

2. 使用合适的数据结构和集合：

选择适当的数据结构和集合类可以改进代码的性能和可读性。例如，使用HashSet来存储唯一的元素。

// 不好的例子 - 使用ArrayList存储唯一元素

List<Integer> list = new ArrayList<>();

list.add(1);

list.add(2);

list.add(1); // 重复元素



// 好的例子 - 使用HashSet存储唯一元素

Set<Integer> set = new HashSet<>();

set.add(1);

set.add(2);

set.add(1); // 自动忽略重复元素

3. 避免使用魔法数值：

使用常量或枚举来代替魔法数值可以提高代码的可维护性和易读性。

// 不好的例子 - 魔法数值硬编码

if (status == 1) {

    // 执行某些操作

}



// 好的例子 - 使用常量代替魔法数值

final int STATUS_ACTIVE = 1;

if (status == STATUS_ACTIVE) {

    // 执行某些操作

}

4. 异常处理：

正确处理异常有助于代码的健壮性和容错性，避免不必要的try-catch块可以提高代码性能。

// 不好的例子 - 捕获所有异常，没有具体处理

try {

    // 一些可能抛出异常的操作

} catch (Exception e) {

    // 空的异常处理块

}



// 好的例子 - 捕获并处理特定异常，或向上抛出

try {

    // 一些可能抛出异常的操作

} catch (FileNotFoundException e) {

    // 处理文件未找到异常

} catch (IOException e) {

    // 处理其他IO异常

}

5. 及时关闭资源：

使用完资源后，及时关闭它们可以避免资源泄漏，特别是对于文件流、数据库连接等资源。

更好的处理方式参见第16条，搭配try-with-resources食用最佳

// 不好的例子 - 未及时关闭数据库连接

Connection conn = null;

Statement stmt = null;

try {

    conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD);

    stmt = conn.createStatement();

    // 执行数据库查询操作

} catch (SQLException e) {

    e.printStackTrace();

} finally {

    // 数据库连接未关闭

}



// 好的例子 - 使用try-with-resources确保资源及时关闭，避免了数据库连接资源泄漏的问题

try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD);

    Statement stmt = conn.createStatement()) {

    // 执行数据库查询操作

} catch (SQLException e) {

    e.printStackTrace();

}

6. 避免过度使用全局变量：

过度使用全局变量容易引发意外的副作用和不可预测的结果，建议尽量避免使用全局变量。

// 不好的例子 - 过度使用全局变量

public class MyClass {

    private int count;



    // 省略其他代码

}



// 好的例子 - 使用局部变量或实例变量

public class MyClass {

    public void someMethod() {

        int count = 0;

        // 省略其他代码

    }

}

7. 避免不必要的对象创建：

避免在循环或频繁调用的方法中创建不必要的对象，可以使用对象池、StringBuilder等技术。

// 不好的例子 - 频繁调用方法创建不必要的对象

public String formatData(int year, int month, int day) {

    String formattedDate = String.format("%d-d-d", year, month, day); // 每次调用方法都会创建新的String对象

    return formattedDate;

}



// 好的例子 - 避免频繁调用方法创建不必要的对象

private static final String DATE_FORMAT = "%d-d-d";

public String formatData(int year, int month, int day) {

    return String.format(DATE_FORMAT, year, month, day); // 重复使用同一个String对象

}

8. 避免使用不必要的装箱和拆箱：

避免频繁地在基本类型和其对应的包装类型之间进行转换，可以提高代码的性能和效率。

// 不好的例子

Integer num = 10; // 不好的例子，自动装箱

int result = num + 5; // 不好的例子，自动拆箱



// 好的例子 - 避免装箱和拆箱

int num = 10; // 好的例子，使用基本类型

int result = num + 5; // 好的例子，避免装箱和拆箱

9. 使用foreach循环遍历集合：

使用foreach循环可以简化集合的遍历，并提高代码的可读性。

// 不好的例子 - 可读性不强，并且增加了方法调用的开销

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

for (int i = 0; i < names.size(); i++) {

    System.out.println(names.get(i)); // 不好的例子

}



// 好的例子 - 更加简洁，可读性更好，性能上也更优

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

for (String name : names) {

    System.out.println(name); // 好的例子

}

10. 使用StringBuilder或StringBuffer拼接大量字符串：

在循环中拼接大量字符串时，使用StringBuilder或StringBuffer可以避免产生大量临时对象，提高性能。

// 不好的例子 - 每次循环都产生新的字符串对象

String result = "";

for (int i = 0; i < 1000; i++) {

    result += "Number " + i + ", ";

}



// 好的例子 - StringBuilder不会产生大量临时对象

StringBuilder result = new StringBuilder();

for (int i = 0; i < 1000; i++) {

    result.append("Number ").append(i).append(", ");

}

11. 使用equals方法比较对象的内容：

老生常谈的问题，在比较对象的内容时，使用equals方法而不是==操作符，确保正确比较对象的内容。

// 不好的例子

String name1 = "Alice";

String name2 = new String("Alice");

if (name1 == name2) {

    // 不好的例子，使用==比较对象的引用，而非内容

}



// 好的例子

String name1 = "Alice";

String name2 = new String("Alice");

if (name1.equals(name2)) {

    // 好的例子，使用equals比较对象的内容

}

12. 避免使用多个连续的空格或制表符：

多个连续的空格或制表符会使代码看起来杂乱不堪，建议使用合适的缩进和空格，保持代码的清晰可读。

// 不好的例子

int    a = 10;  // 不好的例子，多个连续的空格和制表符

String   name   =   "John";  // 不好的例子，多个连续的空格和制表符



// 好的例子

int a = 10; // 好的例子，适当的缩进和空格

String name = "John"; // 好的例子，适当的缩进和空格

13. 使用日志框架记录日志：

在代码中使用日志框架（如Log4j、SLF4J）来记录日志，而不是直接使用System.out.println()，可以更灵活地管理日志输出和级别。

// 不好的例子：

System.out.println("Error occurred"); // 不好的例子，直接输出日志到控制台



// 好的例子：

logger.error("Error occurred"); // 好的例子，使用日志框架记录日志

14. 避免在循环中创建对象：

在循环中频繁地创建对象会导致大量的内存分配和垃圾回收，影响性能。尽量在循环外部创建对象，或使用对象池来复用对象，从而减少对象的创建和销毁开销。

// 不好的例子 - 在循环过程中频繁地创建和销毁对象，增加了垃圾回收的负担

for (int i = 0; i < 1000; i++) {

    // 在每次循环迭代中创建新的对象，增加内存分配和垃圾回收的开销

    Person person = new Person("John", 30);

    System.out.println("Name: " + person.getName() + ", Age: " + person.getAge());

}





// 好的例子 - 在循环外部创建对象，减少内存分配和垃圾回收的开销

Person person = new Person("John", 30);

for (int i = 0; i < 1000; i++) {

    System.out.println("Name: " + person.getName() + ", Age: " + person.getAge());



    // 可以根据需要修改 person 对象的属性

    person.setName("Alice");

    person.setAge(25);

}

15. 使用枚举替代常量：

这条其实和第3条一个道理，使用枚举可以更清晰地表示一组相关的常量，并且能够提供更多的类型安全性和功能性。

// 不好的例子 - 使用常量表示颜色

public static final int RED = 1;

public static final int GREEN = 2;

public static final int BLUE = 3;



// 好的例子 - 使用枚举表示颜色

public enum Color {

    RED, GREEN, BLUE

}

16. 使用try-with-resources语句：

在处理需要关闭的资源（如文件、数据库连接等）时，使用try-with-resources语句可以自动关闭资源，避免资源泄漏。

// 不好的例子 - 没有使用try-with-resources

FileReader reader = null;

try {

    reader = new FileReader("file.txt");

    // 执行一些操作

} catch (IOException e) {

    // 处理异常

} finally {

    if (reader != null) {

        try {

            reader.close();

        } catch (IOException e) {

            // 处理关闭异常

        }

    }

}



// 好的例子 - 使用try-with-resources自动关闭资源

try (FileReader reader = new FileReader("file.txt")) {

    // 执行一些操作

} catch (IOException e) {

    // 处理异常

}

总结

这16个小建议，希望对你有所帮助。

技术的路上充满挑战，但要相信，把细节搞好，技术会越来越牛。小小的优化，微小的改进，都能让我们的代码变得更好。

时间飞逝，我们要不断学习，不断努力。每个技术小突破都是我们不懈努力的成果。要用心倾听，用心琢磨，这样才能在技术的道路上越走越远。

从每一次写代码的过程中，我们收获更多。我们要踏实做好每个细节。在代码的世界里，细节是我们的罗盘。

坚持初心，不忘初心！

"Null 很糟糕." - Doug Lea。

Doug Lea 是一位美国的计算机科学家，他是 Java 平台的并发和集合框架的主要设计者之一。他在 2014 年的一篇文章中说过：“Null sucks.”1，意思是 null 很糟糕。他认为 null 是一种不明确的表示，它既可以表示一个值不存在，也可以表示一个值未知，也可以表示一个值无效。这样就会导致很多逻辑错误和空指针异常，给程序员带来很多麻烦。他建议使用 Optional 类来封装可能为空的值，从而提高代码的可读性和健壮性。

"发明 null 引用是我的十亿美元错误。" - Sir C. A. R. Hoare。

Sir C. A. R. Hoare 是一位英国的计算机科学家，他是快速排序算法、Hoare 逻辑和通信顺序进程等重要概念的发明者。他在 2009 年的一个软件会议上道歉说：“I call it my billion-dollar mistake. It was the invention of the null reference in 1965.”，意思是他把 null 引用称为他的十亿美元错误。他说他在 1965 年设计 ALGOL W 语言时，引入了 null 引用的概念，用来表示一个对象变量没有指向任何对象。他当时认为这是一个很简单和自然的想法，但后来发现这是一个非常糟糕的设计，因为它导致了无数的错误、漏洞和系统崩溃。他说他应该使用一个特殊的对象来表示空值，而不是使用 null。

自作者从事 Java 编程一来，就与 null 引用相伴，与 NullPointerException 相遇已经是家常便饭了。

null 引用是一种表示一个对象变量没有指向任何对象的方式，它是 Java 语言中的一个特殊值，也是导致空指针异常（NullPointerException）的主要原因。虽然 null 引用可以用来表示一个值不存在或未知，也可以用来节省内存空间。但是它也不符合面向对象的思想，因为它不是一个对象，不能调用任何方法或属性。

可以看到，null 引用并不好，我们应该尽量避免使用 null，那么我们该怎么避免 null 引用引起的逻辑错误和运行时异常嘞？

其实这个问题 Java 的设计者也知道，于是他们在 Java8 之后设计引入了 Optional 类解决这个问题，本文将给大家详细介绍下 Optional 类的设计目的以及使用方法。

Optional 类是什么？

Optional 类是 java 8 中引入的一个新的类，它的作用是封装一个可能为空的值，从而避免空指针异常（NullPointerException）。Optional 类可以看作是一个容器，它可以包含一个非空的值，也可以为空。Optional 类提供了一些方法，让我们可以更方便地处理可能为空的值，而不需要显式地进行空值检查或者使用 null。

推荐作者开源的 H5 商城项目waynboot-mall，这是一套全部开源的微商城项目，包含三个项目：运营后台、H5 商城前台和服务端接口。实现了商城所需的首页展示、商品分类、商品详情、商品 sku、分词搜索、购物车、结算下单、支付宝/微信支付、收单评论以及完善的后台管理等一系列功能。 技术上基于最新得 Springboot3.0、jdk17，整合了 MySql、Redis、RabbitMQ、ElasticSearch 等常用中间件。分模块设计、简洁易维护，欢迎大家点个 star、关注我。

github 地址：github.com/wayn111/way…

Optional 类的设计

Optional 类的设计是基于函数式编程的思想，它借鉴了 Scala 和 Haskell 等语言中的 Option 类型。Optional 类实现了 java.util.function 包中的 Supplier、Consumer、Predicate、Function 等接口，这使得它可以和 lambda 表达式或者方法引用一起使用，形成更简洁和优雅的代码。

Optional 类被 final 修饰，因此它是一个不可变的类，它有两个静态方法用于创建 Optional 对象。

Optional.empty()

Optional.empty 表示一个空的 Optional 对象，它不包含任何值。

// 创建一个空的 Optional 对象

Optional empty = Optional.empty();

Optional.of(T value)

Optional.of 表示一个非空的 Optional 对象，它包含一个非空的值。

// 创建一个非空的 Optional 对象

Optional hello = Optional.of("Hello");

Optional.ofNullable(T value)

注意，如果我们使用 Optional.of 方法传入一个 null 值，会抛出 NullPointerException。如果我们不确定一个值是否为空，可以使用 Optional.ofNullable 方法，它会根据值是否为空，返回一个相应的 Optional 对象。例如：

// 创建一个可能为空的 Optional 对象

Optional name = Optional.ofNullable("Hello");

Optional 对象的使用方法

Optional 对象提供了一些方法，让我们可以更方便地处理可能为空的值，而不需要显式地进行空值检查或者使用 null。以下是一些常用的方法。

isPresent()

判断 Optional 对象是否包含一个非空的值，返回一个布尔值。

get()

如果 Optional 对象包含一个非空的值，返回该值，否则抛出 NoSuchElementException 异常。

// 使用 isPresent 和 get 方法

Optional name = Optional.ofNullable("tom");

if (name.isPresent()) {

    System.out.println("Hello, " + name.get());

} else {

    System.out.println("Name is not available");

}

// 输出：Hello tom

ifPresent(Consumer action)

如果 Optional 对象包含一个非空的值，执行给定的消费者操作，否则什么也不做。

// 使用 ifPresent(Consumer action)

Optional name = Optional.ofNullable("tom");

name.ifPresent(s -> {

    System.out.println("Hello, " + name.get());

});

// 输出：Hello tom

orElse(T other)

如果 Optional 对象包含一个非空的值，返回该值，否则返回给定的默认值。

// 使用 orElse(T other)

Optional name = Optional.ofNullable(null);

String greeting = "Hello, " + name.orElse("Guest");

System.out.println(greeting);

// 输出：Hello Guest

orElseGet(Supplier supplier)

如果 Optional 对象包含一个非空的值，返回该值，否则返回由给定的供应者操作生成的值。

// 使用 orElseGet(Supplier supplier)

Optional name = Optional.ofNullable(null);

String greeting = "Hello, " + name.orElseGet(() -> "Guset");

System.out.println(greeting);

// 输出：Hello Guset

orElseThrow(Supplier exceptionSupplier)

如果 Optional 对象包含一个非空的值，返回该值，否则抛出由给定的异常供应者操作生成的异常。

// 使用 orElseThrow(Supplier exceptionSupplier)

Optional name = Optional.ofNullable(null);

String greeting = "Hello, " + name.orElseThrow(() -> new NullPointerException("null"));

// 抛出 java.lang.NullPointerException: null 异常

map(Function mapper)

如果 Optional 对象包含一个非空的值，对该值应用给定的映射函数，返回一个包含映射结果的 Optional 对象，否则返回一个空的 Optional 对象。

// 使用 map(Function mapper)

Optional name = Optional.ofNullable("tom");

String greeting = "Hello, " + name.map(s -> s.toUpperCase()).get();

System.out.println(greeting);

// 输出：Hello TOM

flatMap(Function> mapper)

如果 Optional 对象包含一个非空的值，对该值进行 mapper 参数操作，返回新的 Optional 对象，否则返回一个空的 Optional 对象。

// 使用 flatMap(Function> mapper)

Optional name = Optional.ofNullable("tom");

String greeting = name.flatMap(s -> Optional.of("Hello " + s)).get();

System.out.println(greeting);

// 输出：Hello tom

filter(Predicate predicate)

如果 Optional 对象包含一个非空的值，并且该值满足给定的谓词条件，返回包含该值的 Optional 对象，否则返回一个空的 Optional 对象。

// filter(Predicate predicate)

Optional name = Optional.ofNullable("tom");

String greeting = "Hello " + name.filter(s -> !s.isEmpty()).get();

System.out.println(greeting);

// 输出：Hello tom

Java 9 中 Optional 改进

Java 9 中 Optional 类有了一些改进，主要是增加了三个新的方法，分别是 stream()、ifPresentOrElse() 和 or()。这些方法可以让我们更方便地处理可能为空的值，以及和流或其他返回 Optional 的方法结合使用。我来详细讲解一下这些方法的作用和用法。

stream()

这个方法可以将一个 Optional 对象转换为一个 Stream 对象，如果 Optional 对象包含一个非空的值，那么返回的 Stream 对象就包含这个值，否则返回一个空的 Stream 对象。这样我们就可以利用 Stream 的各种操作来处理 Optional 的值，而不需要显式地判断是否为空。我们可以用 stream() 方法来过滤一个包含 Optional 的列表，只保留非空的值，如下所示：

List> list = Arrays.asList(

        Optional.empty(),

        Optional.of("A"),

        Optional.empty(),

        Optional.of("B")

);



// 使用 stream() 方法过滤列表，只保留非空的值

List filteredList = list.stream()

        .flatMap(Optional::stream)

        .collect(Collectors.toList());



System.out.println(filteredList);

// 输出 [A, B]

ifPresentOrElse(Consumer action, Runnable emptyAction)

这个方法可以让我们在 Optional 对象包含值或者为空时，执行不同的操作。它接受两个参数，一个是 Consumer 类型的 action，一个是 Runnable 类型的 emptyAction。如果 Optional 对象包含一个非空的值，那么就执行 action.accept(value)，如果 Optional 对象为空，那么就执行 emptyAction.run()。这样我们就可以避免使用 if-else 语句来判断 Optional 是否为空，而是使用函数式编程的方式来处理不同的情况。我们可以用 ifPresentOrElse() 方法来打印 Optional 的值，或者提示不可用，如下所示 ：

Optional optional = Optional.of(1);

optional.ifPresentOrElse(

    x -> System.out.println("Value: " + x),

    () -> System.out.println("Not Present.")

);



optional = Optional.empty();

optional.ifPresentOrElse(

    x -> System.out.println("Value: " + x),

    () -> System.out.println("Not Present.")

);



// 输出：Value: 1

// 输出：Not Present.

or(Supplier> supplier)

这个方法可以让我们在 Optional 对象为空时，返回一个预设的值。它接受一个 Supplier 类型的 supplier，如果 Optional 对象包含一个非空的值，那么就返回这个 Optional 对象本身，如果 Optional 对象为空，那么就返回 supplier.get() 返回的 Optional 对象。这样我们就可以避免使用三元运算符或者其他方式来设置默认值，而是使用函数式编程的方式来提供备选值。我们可以用 or() 方法来设置 Optional 的默认值，如下所示：

Optional optional = Optional.of("Hello ");

Supplier> supplier = () -> Optional.of("tom");

optional = optional.or(supplier);

optional.ifPresent(x -> System.out.println(x));



optional = Optional.empty();

optional = optional.or(supplier);

optional.ifPresent(x -> System.out.println(x));



// 输出：Hello 

// 输出：tom

为什么我推荐你使用 Optional 类

最后我总结一下使用 Optional 类的几个好处：

总之，Optional 类是一个非常有用的类，它可以帮助我们更好地处理可能为空的值，提高代码的质量和效率。所以我强烈推荐你在 Java 开发中使用 Optional 类，你会发现它的魅力和好处。

大家好，我是哪吒。

在开发中，我们经常会遇到这样的需求，将Excel的数据导入数据库中。

一、一般我会这样做：

操作起来，如果文件比较多，数据量都很大的时候，会非常慢。

访问之后，感觉没什么反应，实际上已经在读取 + 入库了，只是比较慢而已。

读取一个10万行的Excel，居然用了191s，我还以为它卡死了呢！

private void readXls(String filePath, String filename) throws Exception {

    @SuppressWarnings("resource")

    XSSFWorkbook xssfWorkbook = new XSSFWorkbook(new FileInputStream(filePath));

    // 读取第一个工作表

    XSSFSheet sheet = xssfWorkbook.getSheetAt(0);

    // 总行数

    int maxRow = sheet.getLastRowNum();



    StringBuilder insertBuilder = new StringBuilder();



    insertBuilder.append("insert int0 ").append(filename).append(" ( UUID,");



    XSSFRow row = sheet.getRow(0);

    for (int i = 0; i < row.getPhysicalNumberOfCells(); i++) {

        insertBuilder.append(row.getCell(i)).append(",");

    }



    insertBuilder.deleteCharAt(insertBuilder.length() - 1);

    insertBuilder.append(" ) values ( ");



    StringBuilder stringBuilder = new StringBuilder();

    for (int i = 1; i <= maxRow; i++) {

        XSSFRow xssfRow = sheet.getRow(i);

        String id = "";

        String name = "";

        for (int j = 0; j < row.getPhysicalNumberOfCells(); j++) {

            if (j == 0) {

                id = xssfRow.getCell(j) + "";

            } else if (j == 1) {

                name = xssfRow.getCell(j) + "";

            }

        }



        boolean flag = isExisted(id, name);

        if (!flag) {

            stringBuilder.append(insertBuilder);

            stringBuilder.append('\'').append(uuid()).append('\'').append(",");

            for (int j = 0; j < row.getPhysicalNumberOfCells(); j++) {

                stringBuilder.append('\'').append(value).append('\'').append(",");

            }

            stringBuilder.deleteCharAt(stringBuilder.length() - 1);

            stringBuilder.append(" )").append("\n");

        }

    }



    List collect = Arrays.stream(stringBuilder.toString().split("\n")).collect(Collectors.toList());

    int sum = JdbcUtil.executeDML(collect);

}



private static boolean isExisted(String id, String name) {

    String sql = "select count(1) as num from " + static_TABLE + " where ID = '" + id + "' and NAME = '" + name + "'";

    String num = JdbcUtil.executeSelect(sql, "num");

    return Integer.valueOf(num) > 0;

}



private static String uuid() {

    return UUID.randomUUID().toString().replace("-", "");

}

二、谁写的？拖出去，斩了！

优化1：先查询全部数据，缓存到map中，插入前再进行判断，速度快了很多。

优化2：如果单个Excel文件过大，可以采用 异步 + 多线程 读取若干行，分批入库。

优化3：如果文件数量过多，可以采一个Excel一个异步，形成完美的双异步读取插入。

使用双异步后，从 191s 优化到 2s，你敢信？

下面贴出异步读取Excel文件、并分批读取大Excel文件的关键代码。

1、readExcelCacheAsync控制类

@RequestMapping(value = "/readExcelCacheAsync", method = RequestMethod.POST)

@ResponseBody

public String readExcelCacheAsync() {

    String path = "G:\\测试\\data\\";

    try {

		// 在读取Excel之前，缓存所有数据

        USER_INFO_SET = getUserInfo();



        File file = new File(path);

        String[] xlsxArr = file.list();

        for (int i = 0; i < xlsxArr.length; i++) {

            File fileTemp = new File(path + "\\" + xlsxArr[i]);

            String filename = fileTemp.getName().replace(".xlsx", "");

            readExcelCacheAsyncService.readXls(path + filename + ".xlsx", filename);

        }

    } catch (Exception e) {

        logger.error("|#ReadDBCsv|#异常: ", e);

        return "error";

    }

    return "success";

}

2、分批读取超大Excel文件

@Async("async-executor")

public void readXls(String filePath, String filename) throws Exception {

    @SuppressWarnings("resource")

    XSSFWorkbook xssfWorkbook = new XSSFWorkbook(new FileInputStream(filePath));

    // 读取第一个工作表

    XSSFSheet sheet = xssfWorkbook.getSheetAt(0);

    // 总行数

    int maxRow = sheet.getLastRowNum();

    logger.info(filename + ".xlsx，一共" + maxRow + "行数据！");

    StringBuilder insertBuilder = new StringBuilder();



    insertBuilder.append("insert int0 ").append(filename).append(" ( UUID,");



    XSSFRow row = sheet.getRow(0);

    for (int i = 0; i < row.getPhysicalNumberOfCells(); i++) {

        insertBuilder.append(row.getCell(i)).append(",");

    }



    insertBuilder.deleteCharAt(insertBuilder.length() - 1);

    insertBuilder.append(" ) values ( ");



    int times = maxRow / STEP + 1;

    //logger.info("将" + maxRow + "行数据分" + times + "次插入数据库！");

    for (int time = 0; time < times; time++) {

        int start = STEP * time + 1;

        int end = STEP * time + STEP;



        if (time == times - 1) {

            end = maxRow;

        }



        if(end + 1 - start > 0){

            //logger.info("第" + (time + 1) + "次插入数据库！" + "准备插入" + (end + 1 - start) + "条数据！");

            //readExcelDataAsyncService.readXlsCacheAsync(sheet, row, start, end, insertBuilder);

            readExcelDataAsyncService.readXlsCacheAsyncMybatis(sheet, row, start, end, insertBuilder);

        }

    }

}

3、异步批量入库

@Async("async-executor")

public void readXlsCacheAsync(XSSFSheet sheet, XSSFRow row, int start, int end, StringBuilder insertBuilder) {

    StringBuilder stringBuilder = new StringBuilder();

    for (int i = start; i <= end; i++) {

        XSSFRow xssfRow = sheet.getRow(i);

        String id = "";

        String name = "";

        for (int j = 0; j < row.getPhysicalNumberOfCells(); j++) {

            if (j == 0) {

                id = xssfRow.getCell(j) + "";

            } else if (j == 1) {

                name = xssfRow.getCell(j) + "";

            }

        }



		// 先在读取Excel之前，缓存所有数据，再做判断

        boolean flag = isExisted(id, name);

        if (!flag) {

            stringBuilder.append(insertBuilder);

            stringBuilder.append('\'').append(uuid()).append('\'').append(",");

            for (int j = 0; j < row.getPhysicalNumberOfCells(); j++) {

                stringBuilder.append('\'').append(value).append('\'').append(",");

            }

            stringBuilder.deleteCharAt(stringBuilder.length() - 1);

            stringBuilder.append(" )").append("\n");

        }

    }



    List collect = Arrays.stream(stringBuilder.toString().split("\n")).collect(Collectors.toList());

    if (collect != null && collect.size() > 0) {

        int sum = JdbcUtil.executeDML(collect);

    }

}



private boolean isExisted(String id, String name) {

    return ReadExcelCacheAsyncController.USER_INFO_SET.contains(id + "," + name);

}

4、异步线程池工具类

@Async的作用就是异步处理任务。

在使用@Async时，如果不指定线程池的名称，也就是不自定义线程池，@Async是有默认线程池的，使用的是Spring默认的线程池SimpleAsyncTaskExecutor。

默认线程池的默认配置如下：

从最大线程数可以看出，在并发情况下，会无限制的创建线程，我勒个吗啊。

也可以通过yml重新配置：

spring:

  task:

    execution:

      pool:

        max-size: 10

        core-size: 5

        keep-alive: 3s

        queue-capacity: 1000

        thread-name-prefix: my-executor

也可以自定义线程池，下面通过简单的代码来实现以下@Async自定义线程池。

@EnableAsync// 支持异步操作

@Configuration

public class AsyncTaskConfig {



    /**

     * com.google.guava中的线程池

     * @return

     */

    @Bean("my-executor")

    public Executor firstExecutor() {

        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("my-executor").build();

        // 获取CPU的处理器数量

        int curSystemThreads = Runtime.getRuntime().availableProcessors() * 2;

        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(curSystemThreads, 100,

                200, TimeUnit.SECONDS,

                new LinkedBlockingQueue<>(), threadFactory);

        threadPool.allowsCoreThreadTimeOut();

        return threadPool;

    }



    /**

     * Spring线程池

     * @return

     */

    @Bean("async-executor")

    public Executor asyncExecutor() {

        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();

        // 核心线程数

        taskExecutor.setCorePoolSize(24);

        // 线程池维护线程的最大数量，只有在缓冲队列满了之后才会申请超过核心线程数的线程

        taskExecutor.setMaxPoolSize(200);

        // 缓存队列

        taskExecutor.setQueueCapacity(50);

        // 空闲时间，当超过了核心线程数之外的线程在空闲时间到达之后会被销毁

        taskExecutor.setKeepAliveSeconds(200);

        // 异步方法内部线程名称

        taskExecutor.setThreadNamePrefix("");



        /**

         * 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略

         * 通常有以下四种策略：

         * ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。

         * ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。

         * ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）

         * ThreadPoolExecutor.CallerRunsPolicy：重试添加当前的任务，自动重复调用 execute() 方法，直到成功

         */

        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        taskExecutor.initialize();

        return taskExecutor;

    }

}

5、异步失效的原因

三、线程池中的核心线程数设置问题

有一个问题，一直没时间摸索，线程池中的核心线程数CorePoolSize、最大线程数MaxPoolSize，设置成多少，最合适，效率最高。

借着这个机会，测试一下。

1、我记得有这样一个说法，CPU的处理器数量

将核心线程数CorePoolSize设置成CPU的处理器数量，是不是效率最高的？

// 获取CPU的处理器数量

int curSystemThreads = Runtime.getRuntime().availableProcessors() * 2;

Runtime.getRuntime().availableProcessors()获取的是CPU核心线程数，也就是计算资源。

• CPU密集型，线程池大小设置为N，也就是和cpu的线程数相同，可以尽可能地避免线程间上下文切换，但在实际开发中，一般会设置为N+1，为了防止意外情况出现线程阻塞，如果出现阻塞，多出来的线程会继续执行任务，保证CPU的利用效率。


• IO密集型，线程池大小设置为2N，这个数是根据业务压测出来的，如果不涉及业务就使用推荐。

在实际中，需要对具体的线程池大小进行调整，可以通过压测及机器设备现状，进行调整大小。

如果线程池太大，则会造成CPU不断的切换，对整个系统性能也不会有太大的提升，反而会导致系统缓慢。

我的电脑的CPU的处理器数量是24。

那么一次读取多少行最合适呢？

测试的Excel中含有10万条数据，10万/24 = 4166，那么我设置成4200，是不是效率最佳呢？

测试的过程中发现，好像真的是这样的。

2、我记得大家都习惯性的将核心线程数CorePoolSize和最大线程数MaxPoolSize设置成一样的，都爱设置成200。

是随便写的，还是经验而为之？

测试发现，当你将核心线程数CorePoolSize和最大线程数MaxPoolSize都设置为200的时候，第一次它会同时开启150个线程，来进行工作。

这个是为什么？

3、经过数十次的测试

四、通过EasyExcel读取并插入数据库

EasyExcel的方式，我就不写双异步优化了，大家切记陷入低水平勤奋的怪圈。

1、ReadEasyExcelController

@RequestMapping(value = "/readEasyExcel", method = RequestMethod.POST)

@ResponseBody

public String readEasyExcel() {

    try {

        String path = "G:\\测试\\data\\";

        String[] xlsxArr = new File(path).list();

        for (int i = 0; i < xlsxArr.length; i++) {

            String filePath = path + xlsxArr[i];

            File fileTemp = new File(path + xlsxArr[i]);

            String fileName = fileTemp.getName().replace(".xlsx", "");

            List list = new ArrayList<>();

            EasyExcel.read(filePath, UserInfo.class, new ReadEasyExeclAsyncListener(readEasyExeclService, fileName, batchCount, list)).sheet().doRead();

        }

    }catch (Exception e){

        logger.error("readEasyExcel 异常：",e);

        return "error";

    }

    return "suceess";

}

2、ReadEasyExeclAsyncListener

public ReadEasyExeclService readEasyExeclService;

	// 表名

    public String TABLE_NAME;

    // 批量插入阈值

    private int BATCH_COUNT;

    // 数据集合

    private List LIST;



    public ReadEasyExeclAsyncListener(ReadEasyExeclService readEasyExeclService, String tableName, int batchCount, List list) {

        this.readEasyExeclService = readEasyExeclService;

        this.TABLE_NAME = tableName;

        this.BATCH_COUNT = batchCount;

        this.LIST = list;

    }



    @Override

    public void invoke(UserInfo data, AnalysisContext analysisContext) {

        data.setUuid(uuid());

        data.setTableName(TABLE_NAME);

        LIST.add(data);

        if(LIST.size() >= BATCH_COUNT){

            // 批量入库

            readEasyExeclService.saveDataBatch(LIST);

        }

    }



    @Override

    public void doAfterAllAnalysed(AnalysisContext analysisContext) {

        if(LIST.size() > 0){

        	// 最后一批入库

            readEasyExeclService.saveDataBatch(LIST);

        }

    }



    public static String uuid() {

        return UUID.randomUUID().toString().replace("-", "");

    }

}

3、ReadEasyExeclServiceImpl

@Service

public class ReadEasyExeclServiceImpl implements ReadEasyExeclService {



    @Resource

    private ReadEasyExeclMapper readEasyExeclMapper;



    @Override

    public void saveDataBatch(List list) {

    	// 通过mybatis入库

        readEasyExeclMapper.saveDataBatch(list);

        // 通过JDBC入库

        // insertByJdbc(list);

        list.clear();

    }

    

    private void insertByJdbc(List list){

        List sqlList = new ArrayList<>();

        for (UserInfo u : list){

            StringBuilder sqlBuilder = new StringBuilder();

            sqlBuilder.append("insert int0 ").append(u.getTableName()).append(" ( UUID,ID,NAME,AGE,ADDRESS,PHONE,OP_TIME ) values ( ");

            sqlBuilder.append("'").append(ReadEasyExeclAsyncListener.uuid()).append("',")

                            .append("'").append(u.getId()).append("',")

                            .append("'").append(u.getName()).append("',")

                            .append("'").append(u.getAge()).append("',")

                            .append("'").append(u.getAddress()).append("',")

                            .append("'").append(u.getPhone()).append("',")

                            .append("sysdate )");

            sqlList.add(sqlBuilder.toString());

        }



        JdbcUtil.executeDML(sqlList);

    }

}

4、UserInfo

@Data

public class UserInfo {



    private String tableName;



    private String uuid;



    @ExcelProperty(value = "ID")

    private String id;



    @ExcelProperty(value = "NAME")

    private String name;



    @ExcelProperty(value = "AGE")

    private String age;



    @ExcelProperty(value = "ADDRESS")

    private String address;



    @ExcelProperty(value = "PHONE")

    private String phone;

}

引言

在开发Spring Boot应用时，我们经常面临着不同的控制器方法需要处理各种不同类型的响应结果，以及在代码中分散处理异常可能导致项目难以维护的问题。你是否曾经遇到过在不同地方编写相似的返回格式，或者在处理异常时感到有些混乱？这些看似小问题的积累，实际上可能对项目产生深远的影响。统一结果返回和统一异常处理并非只是为了规范代码，更是为了提高团队的协作效率、降低项目维护的难度，并使代码更易于理解和扩展。

本文的目的是帮助你更好地理解和应用Spring Boot中的统一结果返回和统一异常处理。通过详细的讨论和实例演示，我们将为你提供一套清晰的指南，让你能够在自己的项目中轻松应用这些技术，提高代码质量，减轻开发压力。

统一结果返回

统一结果返回是一种通过定义通用的返回格式，使所有的响应结果都符合同一标准的方法。这有助于提高代码的一致性，减少重复代码的编写，以及使客户端更容易理解和处理API的响应。统一结果返回不仅规范了代码结构，还能提高团队协作效率，降低项目维护的难度。

接下来让我们一起看看在SpringBoot中如何实现统一结果返回。

1. 定义通用的响应对象

当实现统一结果返回时，需要创建一个通用的响应对象，定义成功和失败的返回情况，并确保在接口中使用这个通用返回对象。

@Setter  

@Getter  

public class ResultResponse<T> implements Serializable {  

    private static final long serialVersionUID = -1133637474601003587L;  



    /**  

     * 接口响应状态码  

     */  

    private Integer code;  



    /**  

     * 接口响应信息  

     */  

    private String msg;  



    /**  

     * 接口响应的数据  

     */  

    private T data;

}    

2. 定义接口响应状态码

统一结果返回的关键之一是规定一套通用的状态码。这有助于客户端更容易地理解和处理 API 的响应，同时也为开发者提供了一致的标准。通常，一些 HTTP 状态码已经被广泛接受，如：

• 200 OK：表示成功处理请求。


• 201 Created：表示成功创建资源。


• 204 No Content：表示成功处理请求，但没有返回任何内容。

对于错误情况，也可以使用常见的 HTTP 状态码，如：

• 400 Bad Request：客户端请求错误。


• 401 Unauthorized：未授权访问。


• 404 Not Found：请求资源不存在。


• 500 Internal Server Error：服务器内部错误。

除了 HTTP 状态码外，你还可以定义自己的应用程序特定状态码，以表示更具体的情况。确保文档中清晰地说明了每个状态码所代表的含义，使开发者能够正确地解释和处理它们。

public enum StatusEnum {  

    SUCCESS(200 ,"请求处理成功"),  

    UNAUTHORIZED(401 ,"用户认证失败"),  

    FORBIDDEN(403 ,"权限不足"),  

    SERVICE_ERROR(500, "服务器去旅行了，请稍后重试"),  

    PARAM_INVALID(1000, "无效的参数"),  

    ;  

    public final Integer code;  



    public final String message;  



    StatusEnum(Integer code, String message) {  

        this.code = code;  

        this.message = message;  

    }  



}

3. 定义统一的成功和失败的处理方法

定义统一的成功和失败的响应方法有助于保持代码一致性和规范性，简化控制器逻辑，提高代码复用性，降低维护成本，提高可读性，促进团队协作，以及更便于进行测试。

/**  

 * 封装成功响应的方法  

 * @param data 响应数据  

 * @return reponse  

 * @param <T> 响应数据类型  

 */  

public static <T> ResultResponse<T> success(T data) {  



    ResultResponse<T> response = new ResultResponse<>();  

    response.setData(data);  

    response.setCode(StatusEnum.SUCCESS.code);  

    return response;  

}  



/**  

 * 封装error的响应  

 * @param statusEnum error响应的状态值  

 * @return  

 * @param <T>  

 */  

public static <T> ResultResponse<T> error(StatusEnum statusEnum) {  

   return error(statusEnum, statusEnum.message);  

}  



/**  

 * 封装error的响应  可自定义错误信息

 * @param statusEnum error响应的状态值  

 * @return  

 * @param <T>  

 */  

public static <T> ResultResponse<T> error(StatusEnum statusEnum, String errorMsg) {  

    ResultResponse<T> response = new ResultResponse<>();  

    response.setCode(statusEnum.code);  

    response.setMsg(errorMsg);  

    return response;  

}

4. web层统一响应结果

在web层使用统一结果返回的目的是将业务逻辑的处理结果按照预定的通用格式进行封装，以提高代码的一致性和可读性。

@RestController  

@RequestMapping("user")  

@Validated  

@Slf4j  

public class UserController {  



    private IUserService userService;  



    /**  

     * 创建用户  

     * @param requestVO  

     * @return  

     */  

    @PostMapping("create")  

    public ResultResponse<Void> createUser(@Validated @RequestBody UserCreateRequestVO requestVO){  

        return ResultResponse.success(null);  

    }



    /**  

     * 根据用户ID获取用户信息  

     * @param userId 用户id  

     * @return 用户信息  

     */  

    @GetMapping("info")  

    public ResultResponse<UserInfoResponseVO> getUser(@NotBlank(message = "请选择用户") String userId){  

        final UserInfoResponseVO responseVO = userService.getUserInfoById(userId);  

        return ResultResponse.success(responseVO);  

    }  



    @Autowired  

    public void setUserService(IUserService userService) {  

        this.userService = userService;  

    }  

}

调用接口，响应的信息统一为：

{

    "code": 200,

    "msg": null,

    "data": null

}

{

    "code": 200,

    "msg": null,

    "data": {

        "userId": "121",

        "userName": "码农Academy"

    }

}

统一结果返回通过定义通用的返回格式、成功和失败的返回情况，以及在控制器中使用这一模式，旨在提高代码的一致性、可读性和可维护性。采用统一的响应格式简化了业务逻辑处理流程，使得开发者更容易处理成功和失败的情况，同时客户端也更容易理解和处理 API 的响应。这一实践有助于降低维护成本、提高团队协作效率，并促进代码的规范化。

统一异常处理

统一异常处理的必要性体现在保持代码的一致性、提供更清晰的错误信息、以及更容易排查问题。通过定义统一的异常处理方式，确保在整个应用中对异常的处理保持一致，减少了重复编写相似异常处理逻辑的工作，同时提供友好的错误信息帮助开发者和维护人员更快地定位和解决问题，最终提高了应用的可维护性和可读性。

1.定义统一的异常类

我们需要定义服务中可能抛出的自定义异常类。这些异常类可以继承自RuntimeException，并携带有关异常的相关信息。即可理解为局部异常，用于特定的业务处理中异常。手动埋点抛出。

@Getter  

public class ServiceException extends RuntimeException{  



    private static final long serialVersionUID = -3303518302920463234L;  



    private final StatusEnum status;  



    public ServiceException(StatusEnum status, String message) {  

        super(message);  

        this.status = status;  

    }  



    public ServiceException(StatusEnum status) {  

        this(status, status.message);  

    }  

}

2.异常处理器

创建一个全局的异常处理器，使用@ControllerAdvice 或者 @RestControllerAdvice注解和@ExceptionHandler注解来捕获不同类型的异常，并定义处理逻辑。

2.1 @ControllerAdvice注解

用于声明一个全局控制器建言（Advice），相当于把@ExceptionHandler、@InitBinder和@ModelAttribute注解的方法集中到一个地方。常放在一个特定的类上，这个类被认为是全局异常处理器，可以跨足多个控制器。

当时用@ControllerAdvice时，我们需要在异常处理方法上加上@ResponseBody，同理我们的web接口。但是如果我们使用@RestControllerAdvice 就可以不用加，同理也是web定义的接口

2.2 @ExceptionHandler注解

用于定义异常处理方法，处理特定类型的异常。放在全局异常处理器类中的具体方法上。

通过这两个注解的配合，可以实现全局的异常处理。当控制器中抛出异常时，Spring Boot会自动调用匹配的@ExceptionHandler方法来处理异常，并返回定义的响应。

@Slf4j  

@ControllerAdvice  

public class ExceptionAdvice {  



    /**  

     * 处理ServiceException  

     * @param serviceException ServiceException  

     * @param request 请求参数  

     * @return 接口响应  

     */  

    @ExceptionHandler(ServiceException.class)  

    @ResponseBody  

    public ResultResponse<Void> handleServiceException(ServiceException serviceException, HttpServletRequest request) {  

        log.warn("request {} throw ServiceException \n", request, serviceException);  

        return ResultResponse.error(serviceException.getStatus(), serviceException.getMessage());  

    }  



    /**  

     * 其他异常拦截  

     * @param ex 异常  

     * @param request 请求参数  

     * @return 接口响应  

     */  

    @ExceptionHandler(Exception.class)  

    @ResponseBody  

    public ResultResponse<Void> handleException(Exception ex, HttpServletRequest request) {  

        log.error("request {} throw unExpectException \n", request, ex);  

        return ResultResponse.error(StatusEnum.SERVICE_ERROR);  

    }

}    

3.异常统一处理使用

在业务开发过程中，我们可以在service层处理业务时，可以手动抛出业务异常。由全局异常处理器进行统一处理。

@Service  

@Slf4j  

public class UserServiceImpl implements IUserService {  



    private IUserManager userManager;



    /**  

     * 创建用户  

     *  

     * @param requestVO 请求参数  

     */  

    @Override  

    public void createUser(UserCreateRequestVO requestVO) {  

        final UserDO userDO = userManager.selectUserByName(requestVO.getUserName());  

        if (userDO != null){  

            throw new ServiceException(StatusEnum.PARAM_INVALID, "用户名已存在");  

        }  

    }



    @Autowired  

    public void setUserManager(IUserManager userManager) {  

        this.userManager = userManager;  

    }  

}

@RestController  

@RequestMapping("user")  

@Validated  

@Slf4j  

public class UserController {  



    private IUserService userService;  



    /**  

     * 创建用户  

     * @param requestVO  

     * @return  

     */  

    @PostMapping("create")  

    public ResultResponse<Void> createUser(@Validated @RequestBody UserCreateRequestVO requestVO){  

        userService.createUser(requestVO);  

        return ResultResponse.success(null);  

    }



    @Autowired  

    public void setUserService(IUserService userService) {  

        this.userService = userService;  

    }  

}

当我们请求接口时，假如用户名称已存在，接口就会响应：

{

    "code": 1000,

    "msg": "用户名已存在",

    "data": null

}

统一异常处理带来的好处包括提供一致的异常响应格式，简化异常处理逻辑，记录更好的错误日志，以及更容易排查和解决问题。通过统一处理异常，我们确保在整个应用中对异常的处理方式一致，减少了重复性代码的编写，提高了代码的规范性。简化的异常处理逻辑降低了开发者的工作负担，而更好的错误日志有助于更迅速地定位和解决问题，最终提高了应用的可维护性和稳定性。

其他类型的异常处理

在项目开发过程中，我们还有一些常见的特定异常类型，比如MethodArgumentNotValidException和UnexpectedTypeException等，并为它们定义相应的异常处理逻辑。这些特定异常可能由于请求参数校验失败或意外的数据类型问题而引起，因此有必要为它们单独处理，以提供更具体和友好的异常响应。

1.MethodArgumentNotValidException

由于请求参数校验失败引起的异常，通常涉及到使用@Valid注解或者@Validated进行请求参数校验。我们可以在异常处理器中编写@ExceptionHandler方法，捕获并处理MethodArgumentNotValidException，提取校验错误信息，并返回详细的错误响应。

/**  

 * 参数非法校验  

 * @param ex  

 * @return  

 */  

@ExceptionHandler(MethodArgumentNotValidException.class)  

@ResponseBody  

public ResultResponse<Void> handleMethodArgumentNotValidException(MethodArgumentNotValidException ex) {  

    try {  

        List<ObjectError> errors = ex.getBindingResult().getAllErrors();  

        String message = errors.stream().map(ObjectError::getDefaultMessage).collect(Collectors.joining(","));  

        log.error("param illegal: {}", message);  

        return ResultResponse.error(StatusEnum.PARAM_INVALID, message);  

    } catch (Exception e) {  

        return ResultResponse.error(StatusEnum.SERVICE_ERROR);  

    }  

}

当我们使用@Valid注解或者@Validated进行请求参数校验不通过时，响应结果为：

{

    "code": 1000,

    "msg": "请输入地址信息,用户年龄必须小于60岁,请输入你的兴趣爱好",

    "data": null

}

关于@Valid注解或者@Validated进行参数校验的功能请参考：SpringBoot优雅校验参数

2.UnexpectedTypeException

意外的数据类型异常，通常表示程序运行时发生了不符合预期的数据类型问题。一个常见的使用场景是在数据转换或类型处理的过程中。例如，在使用 Spring 表单绑定或数据绑定时，如果尝试将一个不符合预期类型的值转换为目标类型，就可能抛出 UnexpectedTypeException。这通常会发生在将字符串转换为数字、日期等类型时，如果字符串的格式不符合目标类型的要求。

我们可以在异常处理器中编写@ExceptionHandler方法，捕获并处理UnexpectedTypeException，提供适当的处理方式，例如记录错误日志，并返回合适的错误响应。

@ExceptionHandler(UnexpectedTypeException.class)  

@ResponseBody  

public ResultResponse<Void> handleUnexpectedTypeException(UnexpectedTypeException ex,  

                                                        HttpServletRequest request) {  

    log.error("catch UnexpectedTypeException, errorMessage: \n", ex);  

    return ResultResponse.error(StatusEnum.PARAM_INVALID, ex.getMessage());  

}

当发生异常时，接口会响应：

{

    "code": 500,

    "msg": "服务器去旅行了，请稍后重试",

    "data": null

}

3.ConstraintViolationException

javax.validation.ConstraintViolationException 是 Java Bean Validation（JSR 380）中的一种异常。它通常在使用 Bean Validation 进行数据校验时，如果校验失败就会抛出这个异常。即我们在使用自定义校验注解时，如果不满足校验规则，就会抛出这个错误。

@ExceptionHandler(ConstraintViolationException.class)  

@ResponseBody  

public ResultResponse<Void> handlerConstraintViolationException(ConstraintViolationException ex, HttpServletRequest request) {  

    log.error("request {} throw ConstraintViolationException \n", request, ex);  

    return ResultResponse.error(StatusEnum.PARAM_INVALID, ex.getMessage());  

}

案例请参考：SpringBoot优雅校验参数，注册ConstraintValidator示例中的@UniqueUser校验。

4.HttpMessageNotReadableException

表示无法读取HTTP消息的异常，通常由于请求体不合法或不可解析。

@ResponseBody  

@ResponseStatus(HttpStatus.BAD_REQUEST)  

@ExceptionHandler(HttpMessageNotReadableException.class)  

public ResultResponse<Void> handleHttpMessageNotReadableException(HttpMessageNotReadableException ex,  

HttpServletRequest request) {  

    log.error("request {} throw ucManagerException \n", request, ex);  

    return ResultResponse.error(StatusEnum.SERVICE_ERROR);  

}

5.HttpRequestMethodNotSupportedException