一文带你搞懂为什么大家都推荐count*而不是countid

发表于 2020-04-24 更新于 2025-01-26 分类于 mysql 阅读次数： Valine：

一文带你搞懂为什么大家都推荐count(*)而不是count(id)

在开发中，我们经常用到count这个函数来计算行数，尤其是后台列表展示。

那么究竟应该使用count()还是count(id)呢？很多人，很多书籍都推荐使用count()。

count(*)

在每个引擎里面其实是不一样的，比如myisam引擎，会把总行数存起来，如果你需要总行数，那么直接返回，那速度嗖嗖嗖的。

我们常用的innoDB引擎呢，他就真的是一行行计数了。

那为什么一行行计数还推荐count(*)呢？

innoDB是索引树组织表，不仅有主键索引树还有其他索引树，而count(*)反正是要全表扫描，那么优化器会去遍历最小的索引树，普通索引树的叶子节点只有id，当然要更小一些。

执行这个的时候innoDB遍历全表，但不取值，并且不判断，因为count(*)肯定不是null，直接累加。

count(id)

执行这个的时候innoDB遍历全表，把每一行数据的id值取出来返回给mysql，mysql拿到数据以后判断不为空则+1。累加后返回。

count(1)

执行这个的时候innoDB遍历全表，但不取值，直接返回给mysql，mysql收到返回值，给返回值赋值1，然后判断，累加。

count(字段)

这个和count(id)类似，只不过如果允许为空的话，需要把值取出来做个判断，多个判断。如果不允许为空，那就一样了。

这么一对比，就看出来了，显然count()更快，这也是因为mysql对count()这个语句专门做了优化。所以更推荐count(*)

count(字段) 慢于 count(id) 慢于 count(1) 慢于 count(*)

除了这些我们同样可以自己实现计数。

我们可以使用缓存系统，将计数放入缓存，然后持久化。比如redis。

我们也可以直接创建一个计数的表，把计数字段放入表里。

mysql索引详解-你的数据库用对索引了嘛

mysql的索引一般分为主键索引，唯一索引，普通索引，联合索引，覆盖索引等。

索引这么多，到底该怎么用，用哪个索引适合，需不需要索引呢？

innoDB的索引

innoDB里面一般采用b+树索引模型，当然还有其它比如哈希索引，全文索引，空间索引。但是常用的还是b+树索引。

B+树是一个N叉平衡树。为什么不用二叉平衡树呢，因为二叉平衡树高度太高了，n叉平衡树可以控制树的高度，大概在3-4的高度，而树的根节点一般存在内存中，这样只需要做2-3次磁盘操作就可以了。大量的减少了磁盘操作。

主键索引

主键索引是一种聚簇索引，什么是聚簇索引呢，就是和数据放在一起的。b+树的叶子节点存放的是页，每个页的默认大小是16kb。主键索引树的叶子节点存放的是主键id和数据。一般我们都会用id做为主键。如果一个表不指定主键，Innodb会使用row id作为主键。

我们使用主键查询数据，来看一下执行计划。

1	explain select * from auth_users where id = 1;

可以看到里面key列显示的是primary，表示使用了主键索引。row列是1，表示扫描了一行。通过树搜索的方式快速定位了主键id的位置并且取出数据进行了返回。

为什么主键推荐使用递增id呢，这是因为对索引树的增删改查要更加快速。所以一般使用自增主键。也避免了插入引起的页分裂和删除引起的页合并。

如果现在表里有id=4,5,6的数据，你插入了一条id=3的数据。这时候存放id=4,5,6数据的数据页满了，就需要页分裂，变成两个数据页。

页合并就是相邻的两个数据页的数据都挺少的，可以合并到一起，那么就会页合并。

使用自增主键则只需要不断往后写入就可以了，不需要担心中间的插入。而且自增主键占用的空间同样相对较小。

二级索引

二级索引也是非聚簇索引。包括唯一索引和普通索引。他们同样是b+树的方式存放，只是他们的叶子节点中存放的并不是真正的数据，而是主键id。那么通过这种索引怎么找到数据呢，其实是先找到对应的主键id，再去主键索引树中通过主键id找到对应的数据，也叫回表。

唯一索引和普通索引的区别在于查询的时候，唯一索引查询到条件对应的数据后不会接着查询了，而普通索引会接着查询，直到不满足条件为止。

覆盖索引

覆盖索引是一种优化的手段。覆盖索引也是一种联合索引。

比如我们查询用户信息的时候，如果需要根据用户名查询用户名和密码。我们在用户名字段创建了一个索引。那么查询的时候就会走索引，但是查到的是id，还需要再去主键中找到数据，取出用户名和密码两个字段。

如果我们在用户名的索引树中不仅存了id，还存了我们需要的密码字段，不就不需要再去回表了吗？那我们就需要创建一个用户名和密码的联合索引。这样我们就不需要再回表了，这也就是覆盖索引。覆盖了我们要查询的字段。当然，你通过索引查询的时候，执行计划显示的行数还是1.这是因为回表这个操作是在innoDB里面做的，mysql是感觉不到的。

索引下推

索引下推也是一种优化。比如我们要查询用户名是张三，密码是123456的用户。

1	select * from users where name = '张三' and pwd = '123456'

在mysql5.6以前，只能查询到张三这个数据以后回表找到数据在判断密码。

而mysqll5.6增加索引下推的优化之后，可以在索引遍历过程中，对name和pwd两个字段同时做判断。

唯一索引和普通索引

这两个索引到底该怎么选择，比如用户名字段，用户名当然是不能重复的了。那么它应该使用唯一索引还是普通索引呢？

一般用户注册的时候我们会判断用户名是否重复。所以用户名字段加唯一索引的价值并不大，我们的业务已经能保证它不重复了。

我们在上面说过，查询的时候，唯一索引查询到数据直接就返回了，显然要比普通索引快一些。

但是真的也就快了那么一点，因为InnoDB引擎在读取的时候，是读取一个数据页的数据。它会先把一个数据页读取到内存中，然后查询，那么在内存中多查一次其实没啥感觉。

在看一下更新的时候。

数据在内存里面

如果数据在内存中，那么唯一索引会判断更新后是否会破坏唯一性，如果不破坏则更新。

普通索引则直接更新。

这里显示普通索引更好，不用判断。但是这个影响页很小，和上面一样，在内存中操作的。

数据不在内存中

如果数据不在内存中，那么唯一索引就需要从磁盘读取数据，然后判断，更新。

普通索引则直接写入change buffer，然后就完成了，而change buffer则是在内存中，内存操作，少了磁盘操作。

整体来看，普通索引貌似比唯一索引更友好，唯一索引为了唯一性牺牲了插入和修改的性能。

change buffer

这个是一块内存中的空间，顾名思义，他就是为了修改而生的，如果你修改了数据，不需要直接更新磁盘，而是放入change buffer.change buffer满了，或者一定时间，或者当出现查询操作的时候，会merge数据，比如你更新了手机号，然后要查询这个用户的手机号。那么这时候内存中没有这个数据，从磁盘查询，磁盘查询到的是以前的手机号，因为数据没有更新到磁盘。这时候change buffer就会把更新数据合并到内存中的数据，使得查询到的是最新数据。

那么为什么唯一索引不适用change buffer，因为他需要判断唯一性。

但是向刚才举得例子，更新完立即查询，其实和唯一索引的更新没有啥区别了，反而因为change buffer还麻烦了。所以，change buffer更适合更新完不立即查询的场景。

mysql事务详解-4种事务隔离界别该怎么选择

发表于 2020-04-22 更新于 2025-01-26 分类于 mysql 阅读次数： Valine：

mysql事务详解-4种事务隔离级别该怎么选择

事务要保证ACID,其中就有隔离性。

当我们有多个事务在执行的时候，如果保证每个事务都是隔离的，而不是数据混乱的呢？sql标准的四种隔离级别如下：

读未提交 RU(Read Uncommitted),在这个级别下，是所有数据共享的，A事务在执行的任何操作，B事务都能看见，不管有没有提交。
读已提交 RC(Read Committed),在这个级别下，只有A事务提交的数据，B事务才能看见。提交前的数据对其他事务是不可见的。
可重复读 RR(Repeatable Read),在这个级别下，一个事务内读取的数据都是重复的，也就是都是一致的，就算别的事务提交了数据，你读取的还是原来的数据。
串行化 (serializable)，对于同一行记录，写会加写锁，读会加读锁。

事务隔离的原理

这些是怎么做到的呢？因为事务是具备回滚功能的，如果一旦事务出错就会回滚整个事务。

用过github的应该都知道，github上的代码是具备回滚功能的，如果上线之后发现bug，会回滚到上一个版本，github就是基于版本控制的。

事务同样是基于版本控制的。有一个undo log回滚日志来记录这些版本。比如对于一行用户数据：

{id: 1, name: 张三, mobile:13245678976, pwd: 123456}

事务1进行了修改手机号操作,这时候还没有提交。数据库就会有两个版本的数据。这些都记录在undo log里面，这也就是所谓的MVCC的概念。

{id: 1, name: 张三, mobile:13245678976, pwd: 123456} 原始版本
{id: 1, name: 张三, mobile:12322223333, pwd: 123456} 事务1版本

事务2同时启动，但是稍后进行查询操作，获取用户信息，如果你是读未提交级别，那么读取的是事务1版本数据：

{id: 1, name: 张三, mobile:12322223333, pwd: 123456} 事务1版本

如果你是其他级别，那么你读取的是原始版本数据：

{id: 1, name: 张三, mobile:13245678976, pwd: 123456} 原始版本

如果事务1已经提交了修改，那么事务2在读已提交级别下获取的也是事务1版本数据。

这个是怎么判断的呢？

每个事务有自己的事务id，这个id是单调递增的。在每行数据的版本上会记录事务id。在事务启动的时候，会维护一个已经启动但没有提交的事务的有序数组。有序也就是从小到大，排好序了。如果事务id小于这个数组中第一个id，那么这个事务一定是一个已经提交的事务。如果事务id大于这个数组，那么这个事务是在我之后启动的事务。如果事务id在这个数组中，那么他在我启动的时候一定是未提交的。

拿上面的数据举例，原始版本的事务id为100，事务1的事务id为101，事务2的事务id为102。

{id: 1, name: 张三, mobile:13245678976, pwd: 123456} 原始版本 100
{id: 1, name: 张三, mobile:12322223333, pwd: 123456} 事务1版本 101

当事务2启动后，事务数组为[101]，假设这时候事务1未提交。

如果是可重复读级别下，那么当查询到最新版本事务id=101,在数组中，那么不可见，接着查询上一个版本，上一个版本事务id = 100，发现小于数组最小值，那么这个值是正确的，取出这个版本的数据。

这样就算后面有事务提交，但是它提交后的版本的事务id不满足要求，那么查看到的数据永远都是同一个版本的数据，这也就是一致性读。

但是如果你在事务2中先更新了密码再执行查询，那么就会有三个版本的数据

{id: 1, name: 张三, mobile:13245678976, pwd: 123456} 原始版本 100
{id: 1, name: 张三, mobile:12322223333, pwd: 123456} 事务1版本 101
{id: 1, name: 张三, mobile:12322223333, pwd: 123456789} 事务2版本 102

这时候查询，事务数组为[101,102]。

再可重复读级别下，查询到最新数据事务id=102，发现和自己的一样，那么是可见的。因为是自己修改的，自己修改的不能不让自己看到啊，所以这时候查询到的数据会是最新数据。这也就是当前读。

可重复读级别和读已提交级别的区别如下：

可重复读是再事务开始时候创建一致性视图，数组，这些东西，它只认事务启动前提交的数据。
读已提交级别则是每次执行sql语句的时候创建一致性视图，数组，这些东西，它认的是语句启动前提交的数据。

这四个隔离级别，常用的就是读已提交和可重复读两个级别。

mysql事务怎么实现的，什么是两阶段提交

发表于 2020-04-17 更新于 2025-01-26 分类于 mysql 阅读次数： Valine：

mysql事务怎么实现的，什么是两阶段提交

我们都知道使用mysql的事务，准确来说是innoDB引擎的事务，可以保证数据的一致性，原子性等。那么为什么呢？

redo log

innoDB里面用到了一个叫做redo log（重做日志）的东西。

当你进行数据库操作的时候，innoDB并不会直接操作磁盘数据，因为这样很慢很慢。它使用了wal的机制，所有的操作先记录在redo log。等没事干了或者redo log满了再把数据刷到磁盘里面。这样的话他刷盘的时候就是顺序io，避免了使用随机io。redo log的大小我们可以通过参数设置。

缓冲池

在innoDB里面还有一个缓冲池，buffer_pool，这个缓冲池是在内存中的。为啥有缓冲池，因为磁盘的速度太慢了，如果每次都直接操作磁盘，那就完犊子了。就需要用到内存来缓冲一下，提升性能。

从innoDB里面读取数据的时候，实际上读取的是缓冲池，只有当缓冲池中没有记录的时候，才会读取磁盘，并且将记录放入缓冲池方便下次读取。

缓冲池的大小可以通过innodb_buffer_pool_size参数来指定。

缓存池中基本有以下组件：

索引页
数据页
undo页
插入缓冲（insert buffer)
自适应哈希索引
锁信息
数据字典
redo log buffer

缓冲池既然是在内存中，有固定大小，就会有淘汰机制，缓冲池使用的是LRU机制，也就是最近最少使用的会被淘汰掉。

这里面还有一个redo log buffer，这里面存储的就是上面说的redo log的信息了，会先写入这个buffer，然后再刷入redo log里面。有一个参数innodb_log_buffer_size来控制redo log buffer的大小。这个不用太大，因为一般每秒都会把这里面的刷新到redo log。

redo log buffer刷新到redo log的三种情况：

每秒刷新
事务提交时候刷新
当redo log buffer剩余空间少于一半的时候刷新

binlog

redo log是innoDB引擎的日志，那mysql自己同样有日志，就是这个binlog日志。binlog 里面记载了mysql的所有变化，可以用来恢复数据库，创建备库，从库等。可以查看我的mysql读写分离。

那为什么有两个日志呢，这是因为mysql最开始默认使用的是myisam引擎，myisam引擎没有redo log，mysql就有自己的binlog。innoDB引擎是后来加入mysql的。所以他们各自有各自的日志。

这两个日志有什么区别呢？

rodo log是innoDB引擎的，binlog 是mysql的，binlog所有引擎都可以使用。
redo log记录的是“再某个数据页上修改了啥”，binlog记录的是你的sql。
redo log是固定大小，循环写入的，binlog没有大小限制，不断追加。

事务

那一个事务怎么执行的呢，比如更新一个登录时间。

1	update user set login_time = ? where id = 1;

走完了前面的连接器，分析器，优化器，执行器。执行器会去innoDB更新数据了。
他会先取出这条数据，取出id = 1的数据，id是主键索引，和数据在一起。innoDB直接查找主键索引树找到对应数据就返回了。当然，如果数据再缓冲池，那么直接返回了。
执行器拿到以后再修改登陆时间，然后再次调用innoDB引擎的接口。
innoDB把数据更新到内存中，同时更新redo log，把redo log标记成待提交状态。
执行器写入binlog。
执行器调用innoDB引擎的接口，innoDB把redo log标记成提交状态。

这个时候整个更新事务完成。

为什么要这么做呢？

因为有两个日志的原因，所以两个日志都要写入，要保证这两个日志的一致性。那么如果不使用两阶段提交的方式，直接写入redo log然后写入binlog有什么问题呢？

假设，写完redo log，系统挂了。那么重启后innoDB引擎会根据redo log日志来恢复数据库。这时候数据库里面的数据是正确的。但是binlog丢失了啊。如果你有从库，那么从库的数据就错误了。因为从库的数据是通过binlog同步的。

如果把这两个步骤反过来呢，先写入binlog 再写入redo log呢？

那么就会redo log丢失，数据库实际上没有更新。但是从库通过binlog更新了。还是数据不一致。

所以需要两阶段提交来保证数据一致性。如果这时候写完redo log后挂掉了，因为redo log和binlog都没有数据，所以会回滚事务。
如果binlog和redo log都写入了，但是没有提交，那么重启后会提交事务。这样binlog和数据库就都有数据了。

一条mysql语句的奇幻之旅

发表于 2020-04-14 更新于 2025-01-26 分类于 mysql 阅读次数： Valine：

一条mysql语句的奇幻之旅

我们平常都会用到mysql，但是你真的知道sql语句是怎么执行的吗？

比如下面的sql

1	select * from users;

这条sql语句大致会经过下面的阶段：

连接器 – 连接器负责建立，管理mysql的连接，你首先要连接到mysql服务器，才能操作mysql。
分析器 – 分析器会进行词法分析和语法分析，语法错误会在这个阶段被返回。
优化器 – 优化器会自动优化我们的sql语句，如果它发现你的sql语句可以进行优化的话。优化器选择是否使用索引，索引怎么用。优化器还会选择更优的执行计划，最后会输出一个执行计划。
执行器 – 执行器会根据输出的执行计划进行最终的执行。他会调用底层存储引擎的接口，比如innoDB引擎。

当我们最开始连接数据库实例的时候，我们要输入用户名密码，这时候连接器会从数据库的用户信息中判断你是否有权限连接数据库进行操作，有哪些权限。

如果你输入的用户名密码错误或者没有权限，那么你会收到下面的报错信息

1	Access denied for user 'root'@'localhost'(using password: YES)

这里我们要搞清楚一个概念，数据库和数据库实例，我们使用的都是数据库实例，用实例来操作数据库。

连接成功以后开始执行上面的查询语句。分析器会分析这个语句的词法，语法，语义这些信息。通俗来讲就是看到select,update这些关键字，知道你要来干啥，看看你是不是来搞破坏的，来捣蛋的。看看你是查询哪个表啊，有什么条件啊，这些玩意。最后会输出一个词法树。当然了这一步还会分析你的语法有没有错误，比如你把select打错试试。打成elect，会出现下面的报错信息

1	You have an error in your SQL syntax: check the maual that corresponds to your MySQL server version for the right syntax to use near 'elect * from users' at line 1

遇到这种sql语法错误，他会告诉你在哪出现了错误，其实就是分析器往后分析的时候发现，这不对啊，这不是我要的东西啊，你这偷梁换柱啊。

当这一步的考验你也通过了，那么骚年，你离飞升不远了。。。

进入优化器阶段，优化器接过语法树，会调整你的语法，比如他觉得你这么写它执行起来慢，执行的不爽，那么他会换个姿势再来一次。包括你的语法，执行的顺序，使用的索引，连表怎么连。最终优化完成会输出一个执行计划。

这个执行计划我们可以通过explain关键字查看，比如执行下面的语句

1 2	explain select * from users;

他会输出下面的信息。我们可以看到type这一列是all。这代表全表扫描。

我们现在在执行另外一个看看。

1
2
3


explain select * from users where id = 1;

看看这个执行结果。可以看到type这一列是const。这代表是常量。还有key这一列是primary，这代表我们这次使用了主键索引。而主键索引是聚簇索引，他的page页里面存储的就是这一行信息，所以只会查询一次。

上面输出的执行计划会最终由执行器来执行，执行器会调用存储引擎层的接口。

缓存

其实，在这中间还有一个缓存组件。最开始查询的时候会先查询缓存组件的信息，如果没有缓存，才会走到分析器，然后往下走。如果命中缓存，那么直接返回，也就没后面什么事情了。

laravel-react实战打造企业级高并发分布式电商小程序（三）--权限管理的前端

发表于 2020-04-13 更新于 2025-01-26 分类于 laravel+react实战打造企业级高并发分布式电商小程序阅读次数： Valine：

laravel-react实战打造企业级高并发分布式电商小程序（三）–权限管理的前端

react

我们前端使用react来做，我们这个后台基于antd pro。使用npm创建它。

npm create umi

选择 ant-design-pro

Select the boilerplate type (Use arrow keys)
❯ ant-design-pro - Create project with an layout-only ant-design-pro boilerplate, use together with umi block.
app - Create project with a simple boilerplate, support typescript.
block - Create a umi block.
library - Create a library with umi.
plugin - Create a umi plugin.

Ant Design Pro 脚手架将会自动安装。

本地开发

npm install
npm start

启动完成后会自动打开浏览器访问 http://localhost:8000，你看到下面的页面就代表成功了。

vscode无法执行npm等脚本的问题

发表于 2020-04-12 更新于 2025-01-26 分类于工具阅读次数： Valine：

vscode无法执行npm等脚本的问题

这是因为在windows系统上面powershell的执行策略问题。

可以运行下面的命令查看当前执行策略

Get-ExecutionPolicy

使用下面的命令更改执行策略

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

-scope参数是限制在当前用户下面更改策略更改为RemoteSigned策略。

RemoteSigned

Windows服务器计算机的默认执行策略。
脚本可以运行。
需要从可信任的发布者处获得从互联网下载的脚本和配置文件的数字签名，其中包括电子邮件和即时消息传递程序。
不需要在本地计算机上编写且未从Internet下载的脚本上进行数字签名。
如果脚本不受阻碍（例如使用Unblock-Filecmdlet），则运行从Internet下载且未签名的脚本。
可能会运行来自Internet以外的其他来源的未签名脚本和可能有害的已签名脚本。

Restricted

Windows客户端计算机的默认执行策略。
允许使用单个命令，但不允许使用脚本。
阻止运行所有脚本文件，包括格式和配置文件（.ps1xml），模块脚本文件（.psm1）和PowerShell配置文件（.ps1）。

Undefined

当前范围中未设置执行策略。
如果所有作用域中的执行策略均为Undefined，则有效的执行策略为Restricted，这是默认的执行策略。

Unrestricted

非Windows计算机的默认执行策略，不能更改。
未签名的脚本可以运行。有运行恶意脚本的风险。
在运行非本地Intranet区域中的脚本和配置文件之前警告用户。

更多问题可以参考powershell的官方文档

https://docs.microsoft.com/zh-cn/powershell/module/microsoft.powershell.core/about/about_execution_policies?view=powershell-7

laravel+react实战打造企业级高并发分布式电商小程序（一）--基础建设

发表于 2020-04-11 更新于 2025-01-26 分类于 laravel+react实战打造企业级高并发分布式电商小程序阅读次数： Valine：

laravel+react实战打造企业级高并发分布式电商小程序（一）

整体使用laravel7+react打造整个电商小程序。里面会涉及到高并发的知识，mysql的分库分表，主从读写分离的配置，redis集群的使用，缓存系统的使用，队列系统的使用等。

先初始化一个laravel的项目。然后配置好.env文件。

基础建设

我们使用前后端分离就要考虑跨域问题和安全问题。跨域使用cors解决，laravel7里面内置了cors的解决方案，我们只要修改config/cors.php配置文件就好了。

把里面的值更改一下。修改这个值的原因是因为我们会使用jwt传一个token的请求头过来进行验证。这个时候还是报跨域的错误，所以将supports_credentials值修改为true，如果不报错就不需要修改了。

1
2
3


'supports_credentials' => true,

把这个参数的值修改为true。

安全问题使用jwt的解决方案，安装jwt的包。

composer require lcobucci/jwt

在routes/api.php路由文件中增加下面的路由


//获取jwt token
Route::post('/require_token', 'JWT\RequireTokenController@requireToken');

在config下面新建jwt.php文件，里面内容如下


<?php

return [
    'JWT_SECRET' => env('JWT_SECRET','DvYUz+woS7vVJe6ldY+PqWoUbhIyY9rShzM0NAfzxdU='),
    'JWT_EXP_TIME' => env('JWT_EXP_TIME','36000'),
];

在.env中增加下面的内容


# jwt
JWT_SECRET=DvYUz+woS7vVJe6ldY+PqWoUbhIyY9rShzM0NAfzxdU=   
JWT_EXP_TIME=36000  //过期时间

在app/http/middleware中创建中间件jwtCheck.php,内容如下


<?php

namespace App\Http\Middleware;

use App\Models\Sys\ErrorModel;
use Closure;
use \Lcobucci\JWT\Parser;
use \Lcobucci\JWT\Signer\Hmac\Sha256;

class jwtCheck
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle($request, Closure $next)
    {

        $parser = new Parser;
        $signer = new Sha256;
        $secret = config('jwt.JWT_SECRET');

        if($request->hasHeader('Authorization')){
            $token = $request->header('Authorization');
            //解析token
            $parse = $parser->parse($token);
            //验证token合法性
            if (!$parse->verify($signer, $secret)) {
                return response()->json(['code'=>ErrorModel::JWT_ERROR, 'msg'=>'令牌错误！']);
            }

            //验证是否已经过期
            if ($parse->isExpired()) {
                return response()->json(['code'=>ErrorModel::JWT_ERROR, 'msg'=>'令牌过期！']);
            }
        }else{
            return response()->json(['code'=>ErrorModel::JWT_ERROR, 'msg'=>'令牌缺失！']);
        }
        //把token放到参数里面
        request()->offsetSet('token', $token);
        return $next($request);
    }
}

在app/http下面的Kernel.php文件里面的$routeMiddleware变量里面增加下面内容，把中间件注册到系统中。

1 2	'jwtCheck' => \App\Http\Middleware\jwtCheck::class,

控制器

创建控制器

在app/http/controller下面创建jwt文件夹，然后在jwt文件夹里面创建RequireTokenController.php文件。


<?php

namespace App\Http\Controllers\JWT;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use \Lcobucci\JWT\Builder;
use \Lcobucci\JWT\Signer\Hmac\Sha256;
use Illuminate\Support\Facades\Redis;

class RequireTokenController extends Controller
{
    public function requireToken(Builder $builder, Sha256 $signer) {

        $secret = config('jwt.JWT_SECRET');
        $time = time();
        $expTime = config('jwt.JWT_EXP_TIME');

        do {
            //设置header和payload，以下的字段都可以自定义
            $builder->setIssuer("cmp.wliot.com") //发布者
                    ->setAudience("cmp.wliot.com") //接收者
                    ->setId("abc", true) //对当前token设置的标识
                    ->setIssuedAt($time) //token创建时间
                    ->setExpiration($time + $expTime) //过期时间
                    // ->setNotBefore($time + 5) //当前时间在这个时间前，token不能使用
                    ->set('uid', 30061); //自定义数据

            //设置签名
            $builder->sign($signer, $secret);
            //获取加密后的token，转为字符串
            $token = (string)$builder->getToken();
        } while (Redis::exists($token));
        //存入redis
        // Redis::setex($token, $expTime, json_encode([]));

        return $this->success($token);
    }
}

在这里面使用到了$this->success()方法，这个方法来自controller类，我们需要编写这个方法。

在app/http下面创建Utils文件夹，在里面创建Success.php文件。


<?php

namespace App\Http\Utils;

use App\Models\Sys\ErrorModel;

trait Success {

    function success($data = []) {
        $res = ['code'=>'0','msg'=>'请求成功！', 'data'=>$data];
        return response()->json($res);
    }
}

修改app/http/controllers/controller.php文件


use App\Http\Utils\Success;  //引入刚才的文件

class Controller extends BaseController {
    use AuthorizesRequests, DispatchesJobs, ValidatesRequests, Success;  //在这里添加Success 也就是刚才的文件。
}

在这里面使用到了redis，所以我们需要启动你本地的redis服务器。启动之后就可以访问我们上面填写的路由了，使用postman访问你的路由。

可以看到返回了正确的token。

在后面的访问请求中我们需要使用这个token。我们把它加入请求头。在请求头新建一个Authorization的key，他的值就是我们的token。

laravel+react实战打造企业级高并发分布式电商小程序（二）--权限管理

发表于 2020-04-11 更新于 2025-01-26 分类于 laravel+react实战打造企业级高并发分布式电商小程序阅读次数： Valine：

laravel+react实战打造企业级高并发分布式电商小程序（二）

先初始化一个laravel的项目。然后配置好.env文件。

权限管理

既然是电商肯定有后台，要做权限管理这块。

先创建表，这里使用laravel的migration。下面是后台用户表。

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateUsersTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('auth_users', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('name', 100)->unique();
            $table->string('email', 100)->unique();
            $table->timestamp('email_verified_at')->nullable();
            $table->string('password');
            $table->rememberToken();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('auth_users');
    }
}

下面是角色表


<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateRolesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('auth_roles', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('name', 100)->unique();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('auth_roles');
    }
}

下面是权限表

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreatePermissionsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('auth_permissions', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('name',100)->unique();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('auth_permissions');
    }
}

下面是用户角色关联表


<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateUserRolesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('auth_user_roles', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->bigInteger('user_id');
            $table->bigInteger('role_id');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('auth_user_roles');
    }
}

下面是角色和权限关联表


<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateRolePerimissionsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('auth_role_permissions', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->bigInteger('user_id')->default(0);
            $table->bigInteger('role_id');
            $table->bigInteger('perimission_id');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('auth_role_permissions');
    }
}

下面这张是系统错误信息表，这里会返回错误信息，这些错误信息全部存放在这张表里。


<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreateSysErrorsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('sys_errors', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('code',100)->unique()->comment('错误编码');
            $table->string('msg')->comment('错误信息');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('sys_errors');
    }
}

创建完这些执行迁移命令就可以了。

php artisan migrate

当然了，在这之前确保你的.env文件已经配置好了数据库连接。

我们有了后台数据还需要一个管理员账户，使用seed填充。


<?php

use App\Models\Auth\UserModel;
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\Hash;

class UsersTableSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run(UserModel $user)
    {
        $user->name = 'admin';
        $user->email = 'admin@admin.com';
        $user->password = Hash::make('123456');
        $user->save();

    }
}

运行填充命令

php artisan db:seed

控制器

这里我们使用一个laravel的扩展包，使用composer安装他

composer require thepatter/query-common

安装完后查看我的这个文章来使用这个包，根据文章里面做完之后再回来看下面的内容。

https://blog.csdn.net/Thepatterraining/article/details/105408363

接下来使用artisan命令创建我们的控制器。

php artisan make:queryController Auth/UserController

创建完之后在创建model

php artisan make:model Models/Auth/UserModel

修改刚才的Auth/UserModel，在里面增加table属性。


<?php

namespace App\Models\Auth;

use Illuminate\Database\Eloquent\Model;

class UserModel extends Model
{
    //
    protected $table = 'auth_users';
}

修改刚才的Auth/UserController控制器。


<?php

namespace App\Http\Controllers\Auth;

use QueryCommon\QueryController;
use App\Models\Auth\UserModel;
use App\Models\Auth\UserRoleModel;

class UserController extends QueryController
{
    /**
     * 字典数组
     * ['表里的字段名' => '字典code',...]
     */
    protected $dicArr = [];

    /**
     * 字段映射 可选，不填默认转成下划线格式
     * ['搜索字段' => '表字段',...]
     */
    protected $filedsAdapter = [];

    /**
     * 创建时候的字段映射 可选，不填默认转成下划线格式
     * ['输入字段' => '表字段']
     */
    protected $createAdapter = [
        'name' => 'name',
        'email' => 'email',
    ];

    //定义表名 格式: table as t
    protected $shortTableName;


    protected function getModel() {
        $this->model = new UserModel;
        return $this->model;
    }

}

这时候我们对用户的增删改查操作就完成了，是不是超级简单呢。这主要依赖于我们的query-common扩展包。

我们接下来只需要添加对应的路由就可以了。在routes下面创建Api/Auth文件夹。在里面创建index.php路由文件。


<?php
use Illuminate\Support\Facades\Route;


Route::prefix('auth')->namespace('Auth')->group(function () {
    //后台创建用户
    Route::post('user', 'UserController@createInfo');

    //后台查询管理员列表
    Route::get('users', 'UserController@queryList');

    //后台更新管理员信息
    Route::put('user/{id}', 'UserController@updateInfo');

    //后台删除管理员
    Route::delete('user/{id}', 'UserController@deleteInfo');

});

添加完路由文件后我们需要自动加载路由文件，请看我的这篇文章，路由自动加载。

https://blog.csdn.net/Thepatterraining/article/details/105386868

接下来可以使用postman来测试了。

获取用户列表

其他的就不放图了。

角色

有了用户就有角色了，我们的角色表在之前已经创建好了，我们现在同样的方法创建controller和model。

执行下面的命令。-m参数是model，这里指定model后，如果model不存在会自动创建。

php artisan make:queryController Auth/RoleController -m Models/Auth/RoleModel

修改刚才的Auth/RoleModel，在里面增加table属性。


<?php

namespace App\Models\Auth;

use Illuminate\Database\Eloquent\Model;

class RoleModel extends Model
{
    //
    protected $table = 'auth_roles';
}

app/Http/Controllers/Auth/RoleController文件内容如下


<?php

namespace App\Http\Controllers\Auth;

use QueryCommon\QueryController;
use App\Models\Auth\RoleModel;

class RoleController extends QueryController
{
    /**
     * 字典数组
     * ['表里的字段名' => '字典code',...]
     */
    protected $dicArr = [];

    /**
     * 字段映射 可选，不填默认转成下划线格式
     * ['搜索字段' => '表字段',...]
     */
    protected $filedsAdapter = [];

    /**
     * 创建时候的字段映射 可选，不填默认转成下划线格式
     * ['输入字段' => '表字段']
     */
    protected $createAdapter = [];

    //定义表名 格式: table as t
    protected $shortTableName;


    protected function getModel() {
        $this->model = new RoleModel();
        return $this->model;
    }

}

接着在刚才的routes/Api/Auth/index路由文件中增加下面的内容


//后台查询角色列表
    Route::get('roles', 'RoleController@queryList');

    //创建角色
    Route::post('role', 'RoleController@createInfo');

    //更新角色
    Route::put('role/{id}', 'RoleController@updateInfo');

    //删除角色
    Route::delete('role/{id}', 'RoleController@deleteInfo');

增加后是下图这样

同样使用postman测试。

用户和角色关联

有了用户和角色就要把这两个关联起来了，我们通过在创建用户和修改用户的时候关联角色，在这时候就要更改之前的Auth/UserController了。

增加下面的函数。


/**
 * 创建完用户后执行的操作
 */
protected function createAfter($id) {
    $this->userRole($id);
}

//更新完主表之后可以进行的操作
protected function updateAfter($id) {
    //更新完用户信息需要更新用户角色关联
    //先删除所有关联，再重新创建
    UserRoleModel::where('user_id', $id)->delete();

    $this->userRole($id);

}


/**
 * 用户角色操作，先删除用户的所有角色，再创建角色关联
 * @param int $id 用户id
 */
private function userRole($id) {
    $ids = $this->request->input('roleIds');
    //组织数据
    $insertDatas = [];
    foreach ($ids as $roleId) {
        $insertData = [];
        $insertData['user_id'] = $id;
        $insertData['role_id'] = $roleId;
        $insertData['created_at'] = date('Y-m-d H:i:s');
        $insertDatas[] = $insertData;
    }
    //一次性插入
    UserRoleModel::insert($insertDatas);
}

createAfter方法是在创建完用户后执行的，updateAfter方法是更新完用户信息后执行的。传入用户id。我们在这里删除之前的用户和角色关联，把新的循环添加到数组中，一次性插入数据库。因为循环插入会进行多次数据库io操作，而数据库io是比较耗费资源和时间的，所以我们尽可能少进行数据库操作。

在创建和更新时候我们还需要验证参数，我们再添加下面的方法。


/**
 * 在创建之前调用，用来验证参数
 */
protected function createBefore() {
    //检测页码和每页数量
    $rules = [
        'name' => 'required|unique:auth_users,name',
        'email' => 'required|email|unique:auth_users,email',
        'password' => 'required',
        'roleIds' => 'required|array',
    ];
    $messages = [
        'name.required' => '用户名为必填项',
        'name.unique' => '用户已经存在',
        'email.required' => '邮箱为必填项',
        'email.unique' => '邮箱已经存在',
        'email.email' => '请输入正确的邮箱格式',
        'password.required' => '密码为必填项',
        'roleIds.required' => '角色为必填项',
        'roleIds.array' => '角色必须是数组类型',
    ];
    $this->valid($rules, $messages);

    //判断角色数组是不是在数据库都存在
    $roleNum = RoleModel::whereIn('id', $this->request->roleIds)->count();
    if ($roleNum != count($this->request->roleIds)) {
        //角色id不对
        throw new CommonException(ErrorModel::ROLE_NOT_FOUND);
    }
}

/**
 * 在创建之前调用，用来验证参数
 */
protected function updateBefore() {
    //检测页码和每页数量
    $rules = [
        'name' => 'required',
        'email' => 'required|email',
        'roleIds' => 'required|array',
    ];
    $messages = [
        'name.required' => '用户名为必填项',
        'email.required' => '邮箱为必填项',
        'email.email' => '请输入正确的邮箱格式',
        'roleIds.required' => '角色为必填项',
        'roleIds.array' => '角色必须是数组类型',
    ];
    $this->valid($rules, $messages);

    //判断角色数组是不是在数据库都存在
    $roleNum = RoleModel::whereIn('id', $this->request->roleIds)->count();
    if ($roleNum != count($this->request->roleIds)) {
        //角色id不对
        throw new CommonException(ErrorModel::ROLE_NOT_FOUND);
    }
}

createBefore方法在创建用户之前调用，updateBefore方法在更新之前调用，用来验证参数信息。验证角色在数据库中不存在后要返回错误，直接throw抛出异常即可，因为在外部已经用try catch捕获了，这里返回的是一个error code，在Sys/ErrorModel中定义一个错误信息。为了方便管理，所有的错误以常量的方式定义在errorModel里面。真正的错误信息在我们一开始创建的sys_error数据表中。我们在数据表中添加一条错误信息，code是100002的，msg是角色未定义！

1
2
3


const ROLE_NOT_FOUND = '100002'; //角色未定义！

我们可以传一些错误的角色id给到接口中，使用postman来测试一下。因为这个用户已经创建了，所以返回了用户已经存在的错误信息。

权限

我们使用同样的方式创建权限的controller和model。

php artisan make:queryController Auth/PermissionController -m Models/Auth/PermissionModel

和上面一样，修改刚才的Auth/PermissionModel，在里面增加table属性。后面的就不再说这里了。


<?php

namespace App\Models\Auth;

use Illuminate\Database\Eloquent\Model;

class PermissionModel extends Model
{
    //
    protected $table = 'auth_permissions';
}

增加路由。


//后台查询权限列表
Route::get('permissions', 'PermissionController@queryList');

//创建权限
Route::post('permission', 'PermissionController@createInfo');

//更新权限
Route::put('permission/{id}', 'PermissionController@updateInfo');

//删除权限
Route::delete('permission/{id}', 'PermissionController@deleteInfo');

使用postman测试。

现在呢，我们权限管理的后端接口就算做完了，当然了，后面还会根据需要调整。

一文带你搞懂为什么大家都推荐count(*)而不是count(id)

count(*)

count(id)

count(1)

count(字段)

推荐一些学习网站

coursera

edx

优达学城

中国大学mooc

学堂在线

极客时间

mysql索引详解-你的数据库用对索引了嘛

innoDB的索引

主键索引

二级索引

覆盖索引

索引下推

唯一索引和普通索引

数据在内存里面

数据不在内存中

change buffer

mysql事务详解-4种事务隔离级别该怎么选择

事务隔离的原理

mysql事务怎么实现的，什么是两阶段提交

redo log

缓冲池

binlog

事务

一条mysql语句的奇幻之旅

缓存

laravel-react实战打造企业级高并发分布式电商小程序（三）–权限管理的前端

react

本地开发

vscode无法执行npm等脚本的问题

RemoteSigned

Restricted

Undefined

Unrestricted

laravel+react实战打造企业级高并发分布式电商小程序（一）

基础建设

控制器

laravel+react实战打造企业级高并发分布式电商小程序（二）

权限管理

控制器

角色

用户和角色关联

权限