README - 副本.md · 非凡X/demo-shop

# 0.开篇

你好！很高兴你能点开这个教程，相信你对这个教程有了那么一点点兴趣，接下来占用你一点点时间，邀你浏览一下本章内容，希望能够让你更加有兴趣去学完这个教程。

作者我是一名九零后程序员，搬砖了好几年，主要使用`PHP`和`Java`作为开发语言，另外也懂些前端，毕竟刚工作那会写了不少`html`、`css`、`js`，到后面也学习了`vue`。作为一名开发人员，自己喜欢看一些技术文章，也喜欢分享一些东西，这样才能提高自己的技术。

**为什么要写这个教程？**

其实前两年就想写了，可能是因为项目的原因，也可能是自己还没想好写些什么。不过今年还是下定决心要写一下，一来是能够学习和巩固自己的知识，二来也是分享一下自己的经验。

**课程简介**

本教程打算以一个商城项目为例，会实现后台权限管理、会员管理、商品管理、商品团购、抢购……反正是一些常用的功能都给它实现了。

本教程不同于网上的一些视频教程，只是为了实现而实现，说真的网上的一些教程，都是按部就班的实现功能，很少会提及为什么要这样做，这样做的好处是啥，更不用说会踩到什么坑了，因此有些人自学了，效果也好不到哪去。

在这个教程中模块与功能的代码实现是次要的，更重要的是我们是如何去规划、设计这些模块，我们要站在一个架构师的角度实现我们的系统。

**你能学到什么？**

**第一**、进一步掌握`Thinkphp`，让你知道如何阅读文档，让你知道在学习了`thinkphp`后如何快速的掌握其它框架。

**第二**、数据库的设计，如何合理的设计数据表，表设计的越合理，`sql`就会写得越简单，让你轻松应对上千万的数据。

**第三**、如何搭建自己的系统，完善基础架构。

**第四**、在实际工作中是如何处理需求，积累经验。

其实你学到的东西远不止这些，每个模块中所涉及到的知识就很多了。但这些不是重点，重点你是怎么实现的，比如说手机验证码，我要分享的是你要如何阅读第三方的文档，快速提取有效的信息，快速实现手机发送验证码功能。最终的目的是你在掌握了接入阿里云短信功能的同时，自己能够阅读其它第三方短信平台的文档而接入短信发送的功能，例如百度。

总之本教程重在引导。

**适合人群**

工作一两年的，有接触`thinkphp`的同学即可

**最后**

如果说对你有帮助，记得点个赞~~~~

# 1.技术选型

## 1.1环境搭建

|        | 环境  | 版本  |
| ------ | ----- | ----- |
| 语言   | PHP   | 7.3.4 |
| 数据库 | mysql | 5.7   |
| 缓存   | redis | 3.0.5 |

这里推荐使用`phpstudy`集成环境

## 1.2框架选型

到目前为止，国内使用最多的`PHP`框架当属`Thinkphp`和`Laravel`，这两款框架很相似，文档也是比较齐全。作为一个`PHP`程序员至少要掌握其中一个，当然最好都掌握。

本教程的项目使用了`Thinkphp6.1`的版本，是当前最新版本。

官方文档链接：https://www.kancloud.cn/manual/thinkphp6_0/1037479

**安装**

```shell
composer create-project topthink/think demo-shop
```

默认是单应用模式的，这里我们开发的项目是多应用，因此还需执行以下命令

```shell
composer require topthink/think-multi-app
```

> 本项目有后台模块、提供给web端的API模块，因此就需要用到多应用模型、这样有利于我们后期项目的管理和维护

**目录结构**

把框架下载下来后，我们认识一下里面的一些目录，下面是官网给出的目录结构，实际上下载下来的目录比较简洁

```
www  WEB部署目录（或者子目录）
├─app           应用目录
│  ├─app_name           应用目录
│  │  ├─common.php      函数文件
│  │  ├─controller      控制器目录
│  │  ├─model           模型目录
│  │  ├─view            视图目录
│  │  ├─config          配置目录
│  │  ├─route           路由目录
│  │  └─ ...            更多类库目录
│  │
│  ├─common.php         公共函数文件
│  └─event.php          事件定义文件
│
├─config                全局配置目录
│  ├─app.php            应用配置
│  ├─cache.php          缓存配置
│  ├─console.php        控制台配置
│  ├─cookie.php         Cookie配置
│  ├─database.php       数据库配置
│  ├─filesystem.php     文件磁盘配置
│  ├─lang.php           多语言配置
│  ├─log.php            日志配置
│  ├─middleware.php     中间件配置
│  ├─route.php          URL和路由配置
│  ├─session.php        Session配置
│  ├─trace.php          Trace配置
│  └─view.php           视图配置
│
├─public                WEB目录（对外访问目录）
│  ├─index.php          入口文件
│  ├─router.php         快速测试文件
│  └─.htaccess          用于apache的重写
│
├─extend                扩展类库目录
├─runtime               应用的运行时目录（可写，可定制）
├─vendor                Composer类库目录
├─.example.env          环境变量示例文件
├─composer.json         composer 定义文件
├─LICENSE.txt           授权说明文件
├─README.md             README 文件
├─think                 命令行入口文件
```

![](demo-shop-img/1.1.jpg)

稍微留意一下框起来的部分，后面会用到

**URL重写**

重写url主要是为了隐藏入口`index.php`，我们可以发现很多网站的地址并没有带上入口文件，比如说tp的官网

https://www.kancloud.cn/manual/thinkphp6_0/1037479 而不是

https://www.kancloud.cn/index.php/manual/thinkphp6_0/1037479

官网文档里面也提到了，它也给出了重写的规则，但是最后会发现有点问题，因此做了一下调整

```
<IfModule mod_rewrite.c>
  Options +FollowSymlinks -Multiviews
  RewriteEngine On

RewriteCond %{REQUEST_FILENAME} !-d
  RewriteCond %{REQUEST_FILENAME} !-f
#####RewriteRule ^(.*)$ index.php/$1 [QSA,PT,L]  这是官网的
  RewriteRule ^(.*)$ index.php [L,E=PATH_INFO:$1]
</IfModule>
```

注意上面是基于Apache的规则，我们在根目录(入口文件所在的目录)，新建一个` .htaccess `文件，把规则写进里面去即可

# 2.完善架构

我们下载下来的代码结构是非常简单的，对于实际项目，我们需求对框架的某些功能进行一些封装以及开启框架的某些功能。

## 2.1接口的结构

本教程是`php+vue`前后分离的一个项目，因此接下来都会讲接口的实现。

```php
<?php
namespace app\controller;

class User 
{
    public function login()
    {
        return 'login';
    }
}
```

如上面的代码，这就是一个登录接口。对于一个新手来说，可能会把所有逻辑都写在控制器(controller)里面，这种做法对于我来说是绝对禁止的，因为这样做会使你的代码非常臃肿，并且复用性差，因此如何设计代码结构，成为你程序简洁、高效的关键。

本教程的接口的代码结构主要分为三层：控制层、业务层、模型层

**控制层**：接口名的定义，主要负责参数的过滤及结果的返回

**业务层**：实现业务功能的具体核心代码

**模型层**：负责与数据库交互

每个应用都拥有独立的控制层，这个很好理解，因为你总不可能两个不同的应用使用同一个接口。

每个应用也可以拥有独立的业务层，因为不同应用可能业务代码不一样，但不管是哪个应用都离不开对数据库的增删改查，因此我们这里封装一个核心的业务层，只提供增删改查的逻辑，所有应用都可以直接调用它，做到最大程度的复用性

模型层我们可以把它比作数据表，每个应用都可以使用同一个模型

或许你还不理解，不过没关系，有个印象就行，后面具体开发按照这个结构来，你就会明白了

## 2.2基础控制器

在文档中https://www.kancloud.cn/manual/thinkphp6_0/1067000，这里提到了基础控制器，它提供了数据验证功能 ，这里我们后面会讲到。

在`app`目录下我们会发现框架生成的`BaseController.php`基础控制器，我们可以把它当作最底层的控制器。前面我们说过，我们这个项目是一个多应用项目，因此这里为每个应用都建一个基础控制器，让其继承`BaseController.php`，这样每个应用即可使用底层控制器提供的方法，又可以定制开发一些当前应用共用的方法。

在`app`下新建一个`admin`目录，作为后台应用。接着新建`controller-->AdminController.php`，内容如下

```php
<?php
// +----------------------------------------------------------------------
// | 应用基础控制器
// +----------------------------------------------------------------------
namespace app\admin\controller;

use think\App;
use app\BaseController;

class AdminController extends BaseController
{   
    public function __construct(App $app)
    {
        parent::__construct($app);
    }

protected function initialize()
    {
        
    }
}
```

`initialize()`为初始化方法，在`BaseController`构造函数里面调用了它，每次请求都会执行该方法，因此我们可以在这个方法里封装一些公用信息。

## 2.3返回值的封装

在文档https://www.kancloud.cn/manual/thinkphp6_0/1037526中会讲到响应输出

![](demo-shop-img/2.3-01.jpg)

一般来说比较常见的是**渲染模板输出**和 **JSON输出** ，在一些外包公司为了节省开发成本，前后端都是混到一起，他们一般才采用**渲染模板输出**，这也要求后端开发人员要了解`html`，现在随着`vue`前端框架的崛起，后端开发只需把数据以 **JSON输出**返回给前端即可。

返回给前端的数据需要固定的格式，你不能随便返回一些乱七八糟的东西，一般来说会返回给前端下面三个基本字段：

| 响应码 | 描述                             |
| ------ | -------------------------------- |
| code   | 响应码，成功返回200，异常返回500 |
| msg    | 响应信息                         |
| data   | 响应数据                         |

当然你还可以加别的字段，只要统一就行。

另外`Thinkphp`框架为止也提供了一个助手函数 `json()`，一般来说我们是这样使用它的

```php
json(['code'=>200, 'msg'=>'操作成功','data'=>$data]);
json(['code'=>500, 'msg'=>'服务器异常~']);  
json(['code'=>1000, 'msg'=>'请输入用户名!']);
```

不知道你们有没有发现，假如说查询列表数据，每次返回成功，你都要写`'code'=>200, 'msg'=>'操作成功'`，这样很繁琐，因此这里我们简单封装一下。

打开`app`目录下的全局函数文件`common.php`，这里面新增的函数可以全局调用

```php
/**
 * 返回值-成功
 * @param string $code    错误码
 * @param string $msg     提示信息
 */
function success($data = []){
    return json(['code'=>200, 'msg'=>'操作成功','data'=>$data]);
}

/**
 * 返回值-失败
 * @param string $code    错误码
 * @param string $msg     提示信息
 */
function failure($code=201, $msg='操作失败'){
    return json(['code'=>$code, 'msg'=> $msg]);
}

/**
 * 返回值-异常
 * @param string $code    错误码
 * @param string $msg     提示信息
 */
function error(){
    return json(['code'=>500, 'msg'=>'服务器异常~']);
}
```

我们就可以这样调用：

```php
//返回列表数据
return success($data);
//新增一条数据成功
return success();
//新增一条数据失败
return failure();
//新增一条数据，请输入用户名
return failure(1000,'请输入用户名！');
//异常只返回500
return error();
```

这里的话我们还需求做个小小优化，当然很多人在开发过程中并没有这样做，这也是情有可原，毕竟时间紧迫的话就会忽略掉。

一般来说我们定义一些错误码及对应信息的常量，例如本项目会在`app->config`下新建一个`error.php`

```php
return [
    'er1'    =>['code'=>'1000','msg'=>'请输入用户名!'],
];
```

最后我们这样调用

```php
return failure(config('error.er1')['code'],config('error.er1')['msg']);
```

## 2.4表单验证器

前面我们在基础控制器里面提到了验证器，实际上文档中有专门的栏目介绍它https://www.kancloud.cn/manual/thinkphp6_0/1037624

它的主要用途就是新增或修改数据对数据进行合法性验证，一般来说前端会传一些数据给后端接口，比如新增一条管理员数据，那此时就必须验证账号和密码这两个字段，这两个字段不能为空，同时密码还需要满足一定的条件，此时框架提供的验证器就派上用场了。

打开底层控制器`BaseController.php`，我们会发现框架已经给我们创建了一个验证码方法，非常的好用

```php
/**
     * 验证数据
     * @access protected
     * @param  array        $data     数据
     * @param  string|array $validate 验证器名或者验证规则数组
     * @param  array        $message  提示信息
     * @param  bool         $batch    是否批量验证
     * @return array|string|true
     * @throws ValidateException
     */
protected function validate(array $data, $validate, array $message = [], bool $batch = false){
    //内容省略
}
```

接下来看看调用示例

```php
$data = $this->request->post();
//验证规则
$validate = [
    'account' => 'require',
    'password'  => 'require|regex:/^[a-zA-Z0-9_]{8,20}$/',
];
//提示信息
$message = [
    'account.require' => '账号不能为空!',
    'password.require' => '密码不能为空!',
    'password.regex' => '密码长度8~20位，包含字母数字下划线!',
];
$this->validate($data, $validate, $message);
```

如果输入的账号为空，运行这段代码后你会发现抛出以下异常

![](demo-shop-img/2.4-01.jpg)

## 2.5异常接管

上一节讲验证器的时候，抛出了一个账号不能为空的异常，很显然这种提示方式对于前端很不友好，前端无法获取到相应的信息，因此我们要想办法捕抓到这个异常，将提示信息`json`的格式返回给前端

我们打开文档https://www.kancloud.cn/manual/thinkphp6_0/1037615，文档有讲解相关异常的处理。

框架也为我们生成了`app/ExceptionHandle.php`，打开看看里面的内容，其中有这样的一个函数

`render($request, Throwable $e)`，我们在里面新加参数验证码错误的代码

```php
public function render($request, Throwable $e): Response
{
     // 参数验证错误
    if ($e instanceof ValidateException) {
        return failure(1004,$e->getError());
    }
    return parent::render($request, $e);
}
```

这时如果参数验证码错误的话，就会被捕抓到，同时返回`json`格式的数据给前端，如下

```json
{
	"code": 1004,
	"msg": "账号不能为空!"
}
```

同样的我们需要接管其它的异常

```php
// 参数验证错误
if ($e instanceof ValidateException) {
    return failure(1004,$e->getError());
}

// 其它异常
if ($e instanceof RouteNotFoundException || $e instanceof Exception 
    || $e instanceof HttpException || $e instanceof HttpResponseException || $e instanceof ModelNotFoundException
    || $e instanceof DataNotFoundException || $e instanceof RouteNotFoundException) 
{
    return error();
}
```

我们统一返回这样的格式给前端

```json
{
	"code": 500,
	"msg": "服务器异常~"
}
```

**为什么要这样返回？**

因为在生产环境，我们一般不会把系统产生的异常信息返回给用户的，因为这是一种很危险的信号。

**那有些人可能会问，如果都这样提示，那不是不知道哪里出问题了吗？**

别慌，在`app/ExceptionHandle.php`中，开头有这样的一段代码

```php
/**
     * 不需要记录信息（日志）的异常类列表
     * @var array
*/
protected $ignoreReport = [
    // HttpException::class,
    // HttpResponseException::class,
    // ModelNotFoundException::class,
    // DataNotFoundException::class,
    // ValidateException::class,
    // RouteNotFoundException::class,
    // Exception::class,
];
```

我们注释掉它，这样错误信息会被日志记录下来

日志一般记录在runtime下面的log目录里的`xxx.log`文件

```verilog
[2023-11-17T11:21:39+08:00][error] [255]账号不能为空1111
[2023-11-17T11:22:36+08:00][error] [255]账号不能为空1111[F:\phpstudy_pro\WWW\demo.shop\app\common.php:84]
[2023-11-17T11:25:57+08:00][error] [8]未定义变量: c[F:\phpstudy_pro\WWW\demo.shop\app\admin\controller\SysUser.php:172]
```

这样我们就很容易找到问题了

> 生产环境也一样，运维一般会在某个地方输出这些日志，这样我们可以方便的通过浏览器可以看到这些异常信息

## 2.6开启Redis缓存

在文档https://www.kancloud.cn/manual/thinkphp6_0/1037634中介绍了有关缓存的使用，框架默认的缓存是基于本地文件，这里我们只需配置一下，把它改成基于`redis`

打开全局的`config/cache.php`，新增以下内容

```php
'redis' => [
    // 驱动方式
    'type' => 'redis',
    //服务地址
    'host' => env('cache.host'),
    //端口
    'port' => env('cache.port'),
    //密码
    'password' => env('cache.password'),
    //节点
    'select' => env('cache.select'),
    // 缓存前缀
    'prefix' => env('cache.prefix'),
    // 缓存有效期 0表示永久缓存
    'expire' => env('cache.expire')
],
```

打开`.env`，新增以下内容

```
[CACHE]
DRIVER = redis
HOST = 127.0.0.1
PORT = 6379
PASSWORD = 
SELECT = 0
PREFIX = 
EXPIRE = 0
```

一般本地的`redis`配置信息都默认是这样，如果发现你的连接不上，就看看密码是否正确

框架给我们提供了助手函数` cache()`，看看它的使用方式

```php
//设置缓存，且缓存时间是永久,因为配置EXPIRE = 0，标识永久
cache("user_id",1);
//缓存10秒
cache("user_id",1,10);
//获取缓存
cache("user_id");
```

## 2.7路由配置

路由能做的东西很多，文档非常详细的介绍https://www.kancloud.cn/manual/thinkphp6_0/1037495

**为什么要使用路由？个人认为主要是有下面两个好处：**

1. 访问地址写到一个地方，方便管理
2. 使用路由中间件，可以提前过滤接口

打开`config/route.php`,把以下的配置项设置为true，开启强制路由

```php
// 是否强制使用路由
'url_route_must'        => true
```

另外我们在`admin`应用下新建`route/app.php`，每个应用可设置单独的路由，例如

```php
<?php
// +----------------------------------------------------------------------
// | 后台应用路由
// +----------------------------------------------------------------------
// | Author: myh
// +----------------------------------------------------------------------
use think\facade\Route;
//图片验证码
Route::get('login/verify','sysUser/verify');
```

> 使用任何一个框架，做任何一个项目都可以按照这样的思路来开发，做一些开放前的准备工作

# 3.后台管理员模块

我们将后台管理员及权限管理作为这个教程的开端，这一部分的内容非常重要，任何一个后台系统都有权限管理模块，不同的角色拥有不同的权限，可以看到相应权限下的内容。

## 3.1梳理需求

管理员模块核心就两个点：

**第一、登录**

管理后台登录一般都是用户名密码登录，如图

![](demo-shop-img/3.1-01.jpg)

这里验证码的实现可能会有点意思，后面会提到。

**第二、管理员权限**

管理权限，简单来说不同账号看到的菜单栏目不一样。目前比较流行的是基于角色(`RBAC`)的权限控制。如图

![](demo-shop-img/3.1-02.jpg)

上面这个**普通用户**角色拥有系统管理这个几个菜单权限，然后我们在创建管理员的时候只需要把用户关联上这个角色即可

![](demo-shop-img/3.1-03.jpg)

这样“test”用户就可以看到这个角色下面所拥有的菜单。

本章就不对`RBAC`权限管理进一步讲解，如果说想进一步理解`RBAC`权限管理，可以去网上搜索一些教程。

鉴于上面的功能，我们这里设计了3张表：

**第一**、管理员表

**第二**、角色表

**第三**、菜单表

可能接触过甚至做过该功能的同学会问：**不应该有5张表吗，怎么缺少"`管理员跟角色的关联表`"，"`角色和菜单的关联表`"这两张表？**

其实我把这两张表省了，我在管理员表和角色表里面各加了一个字段，分别保存角色ID和菜单ID，这样就关联上。

其实这样设计有好有坏吧，好处是查询的时候没有那么复杂，坏处就是存储菜单ID的字段可能很越来越大，因为有些公司在设计数据表时明确禁止使用text类型。如果说没有限制，不妨可以这样设计，毕竟这几个表数据量不大，对性能影响比较小。

## 3.2设计数据表

我认为建表是整个项目中最关键的一步，表建的合不合理取决于你对业务需求的理解，如果表建的不合理，就会影响到你后面代码的逻辑以及系统的稳定性。如何合理的建表，主要是取决于你对`mysql`优化知识的掌握和自己的工作经验，知识自己可以去学习，经验的话就得靠自己项目的积累了，只有你接触了足够的项目，你才能知道怎么根据需求去设计数据表。

**下面我列出几条建议：**

1. 无论是表名还是字段名，使用小写加下划线方式命名，例如`ds_user`。但注意字名不要以下划线开头 。同时 不建议使用驼峰和中文作为数据表及字段命名。 
2. 合理选择数据类型及长度设置，例如会员性别，我们可以用1表示男，2表示女，我们选择的类型是`tinyint`而不是int。再比如会员登陆密码，一般30个字符以内，因此没必要给到255长度。
3. 字符型字段和整型字段最好给个默认值，例如空字符串、0
4. 新建索引，一般来说根据需求，我们大概会知道有哪些字段需要建立索引，但需要注意的是一张表最好把索引控制在5个以内
5. 每张表自增ID是必须的，同时建议每张表都加上创建人、更新人、创建时间、更新时间这四个字段。

数据库设计的规范远不止这些，但是每家公司的要求可能不尽相同。比如说我的一个同学，在大厂里面管的仓库系统，数据都是亿为单位的，有些表字段超过100个、索引也是加了很多。

好了，话说回来，根据上面的功能需求，我们就开始建表了，`ds_sys_user`、`ds_sys_role`、`ds_sys_menu`

> 建表语句和字段说明查看最后的附录

最后我们在项目中新增数据库的配置，在最外层目录新建一个`.env`，参考其给出的示例`.example.env`，具体内容如下：

```
#数据库配置配置
[DATABASE]
TYPE = mysql
HOSTNAME = 127.0.0.1
DATABASE = demo-shop
USERNAME = root
PASSWORD = 123456
HOSTPORT = 3306
CHARSET = utf8
DEBUG = true
```

## 3.3扩展验证码

`thinkphp`提供的验证码插件是基于`session`，使用起来很简单

```html
<div>{:captcha_img()}</div>
```

但是我们的项目前端使用的是`vue`，它跟后端一般是部署在不同服务器上的，因此无法通过 `Session` 保持会话这状态，这时我们得另想办法了。

当然网上也有一些插件，你可以去下载插件，但本教程会教你一个更巧妙的方法去实现验证码功能。

首先我们安装一下官网提供的验证码插件

```shell
composer require topthink/think-captcha
```

**生成验证码接口**

在`admin/controller`新建`SysUser.php`，内容如下

```php
<?php
namespace app\admin\controller;

use think\captcha\facade\Captcha;
//继承基础控制器AdminController
class SysUser extends AdminController{
    //图片验证码
    public function verify(){
        return AsysUserService::createCaptcha();
    }
}
```

在`app`目录下新建`service`目录，新建`AsysUserService.php`，内容如下

```php
namespace app\admin\service;
use think\captcha\facade\Captcha;

class AsysUserService{
    
    /**
     * 创建图片验证码
     * @return array
     */
    public static function createCaptcha(){
        $uniqid = uniqid(rand(00000,99999)); // 一
        $rs = Captcha::create();             // 二
        $base64_image = "data:image/png;base64," . base64_encode($rs->getData());
        $key = session('captcha.key');       // 三

cache(config('redisKey.ADMIN_LOGIN_VERIFY_').$uniqid,$key); // 四

return success(['uniqid'=>$uniqid,'image'=>$base64_image]); // 五
    }
}
```

我们来重点解释一下这段代码：

**一**、这一步是生产一个唯一码，后面作为`redis`缓存`key`的一部分

**二**、使用`Captcha::create`会得到图片的数据，再通过`base64_encode`加密，前端就可以直接拿到这个数据显	示，而不是链接

三、这个key其实就是那串经过加密的验证码

四、把第三步得到的那串验证码保存到缓存中

五、把唯一码和图片数据返回给前端

返回的格式如下：

```json
{
	"code": 200,
	"msg": "操作成功",
	"data": {
		"uniqid": "52461655736fe1ee19",
		"image": "data:image/png;base64,……………………………………………………………………"
	}
}
```

**判断输入的验证码是否正确**

判断输入验证码是否正确，是在登录那会才实现的，这里我先解释一下这个验证的代码

```php
$data = $this->request->post();
$key = cache(ADMIN_LOGIN_VERIFY_.$data['uniqid']); // 一
if($key && password_verify(mb_strtolower($data['code'], 'UTF-8'), $key)){  // 二
    // 验证通过后，清空验证码缓存
    cache(ADMIN_LOGIN_VERIFY_.$uniqid,null);
}else{
    // 提示验证码输出错误
}
```

一、前端把`uniqid`提交过来，我们通过这个key去缓存中拿到那串验证码

二、使用内置函数去对比输入的验证码跟内存的验证码是否一致

为什么要使用这个函数`password_verify`？而不是像下面这样：

```php
if($key == $data['code'])
```

这是因为我们存在缓存中的验证码是经过加密的。

我们可以看看生成验证码的源码，打开`Captcha.php`，里面有个`generate()`方法，最后有这样的一段代码

```php
$hash = password_hash($key, PASSWORD_BCRYPT, ['cost' => 10]);
$this->session->set('captcha', [
    'key' => $hash,
]);
```

我们可以看到验证码是经过`password_hash`加密的，然后保存在`captcha.key`中。这也是为什么前面我们获取key的时候是这样写的：

```php
$key = session('captcha.key');       // 三
```

我们继续看源码，其中有`check()`这个方法，这个方法文档中也提到，是判断验证码是否正确，我们看看其中的内容

```php
public function check(string $code): bool
{
    if (!$this->session->has('captcha')) {
        return false;
    }
	// 获取key,等同于cache(ADMIN_LOGIN_VERIFY_.$data['uniqid']); // 一
    $key = $this->session->get('captcha.key');
    
    // 判断验证码，等同于password_verify(mb_strtolower($data['code'], 'UTF-8'), $key)
    $code = mb_strtolower($code, 'UTF-8');
    $res = password_verify($code, $key);
    
    if ($res) {
        // 等同于cache(ADMIN_LOGIN_VERIFY_.$uniqid,null);
        $this->session->delete('captcha');
    }
    return $res;
}
```

简单来说我们就是参考框架的源码以及巧妙运用框架的某些方法实现这个验证码，这里的话并没有对源码进行改造，我看网上有些文章是改里面的源码的，真的很不可思议，这是绝对禁止的。

**验证码配置**

框架给我提供了验证码的配置文件`app->config->captcha.php`，我们配置验证码的位数、字符集、是否使用中文或者是算术

```php
return [
    //验证码位数
    'length'   => 4,
    // 验证码字符集合
    'codeSet'  => '123456789',
    // 验证码过期时间
    'expire'   => 1800,
    // 是否使用中文验证码
    'useZh'    => false,
    // 是否使用算术验证码
    'math'     => false,
    // 是否使用背景图
   //	…………………………
];
```

## 3.4Jwt(token)

前后端分离项目，一般来说服务端的代码和前端代码都是放在不同服务器上，有不同的域名，因此前端无法携带与后端服务器对应的cookie，这也就是无法使用session的原因，因此一般情况下都使用`jwt`来保存登录的验证状态

接下来我们说说如何生成`jwt`

文档地址：https://github.com/firebase/php-jwt

**安装**

```shell
composer require firebase/php-jwt
```

**示例**

```php
//用户信息
$user = ['id'=>1,'account'=>'admin'];
//一天后过期
$user['exp'] = time() + 24*3600;

//生成token,config('app.jwt_code_pc')加密字符串
$jwt = JWT::encode($user,config('app.jwt_code_pc'),"HS256");
```

最后生成一窜以下的字符串

```
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6Miwicm9vdCI6MSwiYWNjb3VudCI6ImFkbWluIiwicGFzc3dvcmQiOiIqKioxMWIyYWFiMzcyMWU5NDAyZTJjMWQ1YmNkYmI0ZDI1ZiIsInJlbWFyayI6IiIsInJvbGVzIjpudWxsLCJsb2dpbl90aW1lIjoiMjAyMy0wNi0wMiAyMjozOToxOSIsImxvZ2luX2lwIjoiMTI3LjAuMC4xIiwic3RhdHVzIjoxLCJjcmVhdG9yIjowLCJ1cGRhdG9yIjowLCJjcmVhdGVfdGltZSI6IjIwMjMtMDUtMjUgMTU6MTg6MzYiLCJ1cGRhdGVfdGltZSI6IjIwMjMtMDYtMDIgMjI6Mzk6MTkiLCJkZWxldGVfdGltZSI6bnVsbCwiZXhwIjoxNjg1ODAzMTU5fQ.Nmay9ZTW3LTvRMJLRC1cz0wtvQS014f68epLPrH7IAo
```

下次用户访问后台接口的时候，把`jwt`通过header头传给后端接口，后端接口会对其进行解析，如果能够被解析，则说明`jwt有效`

```php
//解析jwt
JWT::decode(jwt,new Key(config('app.jwt_code_pc'),'HS256'));
```

最后得到用户信息

```php
$user = ['id'=>1,'account'=>'admin'];
```

**注：**

> 无论是生成`jwt`还是解析`jwt`，其中有个非常重要的参数：加密的密钥，这个密钥一旦泄露，那么别人就看可以轻易的解析和伪造`jwt`进行登录

## 3.5模型层的封装

`thinkphp`的模型，我的理解就是跟数据库打交道，我看了文档https://www.kancloud.cn/manual/thinkphp6_0/1037580确实是比较方便，因此整个项目都会用模型。你可以理解为一个模型就是一张表，无论是`pc`端、`app`端、后台的接口都需要操作模型，因此把模型全部放在公共应用`commom`。

新建`commom/model/BaseModel.php`，内容如下

```php
<?php
// +----------------------------------------------------------------------
// | 基础模型
// +----------------------------------------------------------------------
namespace app\common\model;

use think\Model;
use think\model\concern\SoftDelete;

class BaseModel extends Model
{   
    use SoftDelete;
    protected $deleteTime = 'delete_time';
}
```

这是一个基础模型，这里设置了软删除字段，后续会新增分页查询、批量删除等方法

## 3.6管理员登录

前面我们已经做了许多准备了，下面来实现一下管理员登录的逻辑。

再次之前需要在`ds_sys_user`表里面手动新增一条数据，密码是a_123456

```mysql
INSERT INTO `demo-shop`.`ds_sys_user`(`id`, `root`, `account`, `password`, `remark`, `roles`, `login_time`, `login_ip`, `status`, `creator`, `updator`, `create_time`, `update_time`, `delete_time`) VALUES (NULL, 1, 'admin', '***11b2aab3721e9402e2c1d5bcdbb4d25f', '', NULL, '2023-05-25 16:31:22', '127.0.0.1', 1, 0, 1, '2023-05-25 15:18:36', '2023-05-26 11:44:55', NULL);

```

在`common/model`目录下新建一个`SysUserModel.php`，内容如下

```php
<?php
// +----------------------------------------------------------------------
// | 管理员模型
// +----------------------------------------------------------------------
namespace app\common\model;

class SysUserModel extends BaseModel
{   
    protected $table = 'ds_sys_user';
}
```

这里我们继承了基础模型`BaseModel`，如果你不继承它的话，你就得在这里定义软删除字段，因此这也是为啥定义基础模型的原因，它就是把公共的东西抽出来，防止我们重复造轮子。

接下来看看业务层的登录代码是如何实现的，打开`app/service/AsysUserService.php`

```php
public static function login($data){
    $user = SysUserModel::getByAccount($data['account']);
    if(empty($user) || !comparePassword($data['password'],$user['password'])){
        //账号或者密码错误
        return failure(config('error.er11')['code'],config('error.er11')['msg']);
    }

if($user['status'] == 0){
        //账号被禁用
        return failure(config('error.er12')['code'],config('error.er12')['msg']);
    }

//下面是验证成功后的处理逻辑
    //登录成功后更新用户信息
    $user->login_time = date('Y-m-d H:i:s',time());
    $user->login_ip = getClientIp();
    $user->save();

//生成token
    $token = $user->toArray();
    //一天后过期
    $token['exp'] = time() + 24*3600;

$jwt = JWT::encode($token,config('app.jwt_code_admin'),"HS256");

return success(['token' => $jwt]);
}
```

我们看看这段代码的逻辑，根据账号去查找数据表中查找是否存在该账号，如果存在则验证密码是否正确，满足以上两个条件后，还要判断该账号是否处于`启用`状态。以上条件都满足后，更新登录时间和`ip`，然后生成`jwt`返回给前端，作为登录的凭证。

接下来了解一下`comparePassword()`这个密码比较函数，打开`app/common.php`，这里新加了两个函数

```php
/**
 * 密码加密
 * @param string $pw       要加密的原始密码
 * @param string $authCode 加密字符串
 * @return string
 */
function createPassword($pw, $authCode = '')
{
    if (empty($authCode)) {
        $authCode = config('app.authcode');
    }
    $result = "***" . md5(md5($authCode . $pw));
    return $result;
}

/**
 * 密码比较方法,所有涉及密码比较的地方都用这个方法
 * @param string $password     要比较的密码
 * @param string $passwordInDb 数据库保存的已经加密过的密码
 * @return boolean 密码相同，返回true
 */
function comparePassword($password, $passwordInDb)
{
    return createPassword($password) == $passwordInDb;
}
```

看注释应该看得懂了

看完主要的业务核心代码后，我们看看登录的控制器写的是什么代码

打开`SysUser.php`

```php
//登录
public function login(){
    $data = $this->request->post();
    //验证规则
    $validate = [
        'account' => 'require',
        'password'  => 'require',
        'code' => 'require',
        'uniqid' => 'require',
    ];
    //提示信息
    $message = [
        'account.require' => '账号不能为空!',
        'password.require' => '密码不能为空!',
        'code.require' => '验证码不能为空!',
        'uniqid.require' => 'uniqid不能为空!',
    ];

$this->validate($data, $validate, $message);
	
    $key = cache(ADMIN_LOGIN_VERIFY_.$data['uniqid']);
    if($key && password_verify(mb_strtolower($data['code'], 'UTF-8'), $key)){
        cache(ADMIN_LOGIN_VERIFY_.$data['uniqid'],null);
    }else{
        return failure(config('error.er17')['code'],config('error.er17')['msg']);
    }

return AsysUserService::login($data);
}
```

这里主要是对参数进行验证，这里也包含了输入验证码的验证，验证通过后，再调用业务核心代码。如果你看不懂这个验证码的验证，你可以阅读`3.3扩展验证码`这一章节，里面讲得很明白。

最后配置一下路由，打开`app.php`

```php
//获取验证码
Route::get('login/verify','sysUser/verify');
//管理员登录
Route::post('login','sysUser/login');
```

**疑问：这里不用判断请求是post请求吗？我看有些是这么写的`if(!$this->request->isPost()){//抛出异常}`？**

> 如果说每个方法都这么写，非常的繁琐，因此为了解决这个问题，我们开启了强制路由，路由配置那章有提到。同时我们也对路由异常进行捕抓，异常接管那章有提到。一旦我们请求方式不对，或者写错了，都会抛出异常

接下来我们登录看看

先获取验证码

![](demo-shop-img/3.6-01.jpg)

复制image，在浏览器打开

![](demo-shop-img/3.6-02.jpg)

![](demo-shop-img/3.6-03.jpg)

## 3.7用户验证中间件

用户想访问后台，那一定是要登录的，后端的接口是如何知道用户是否登录了呢？

上节讲到用户登录成功后，会返回一串token给前端，这个token就是一个登录凭证。当我们调用后台的接口时一定要带上这个凭证，否则你是无法访问。

一般情况下我们都是通过header头来携带token信息，拿到这窜token后，我们在那里解析它呢？？

接下来路由中间件要出场了，你可以在https://www.kancloud.cn/manual/thinkphp6_0/1037493阅读到相关介绍

在`admin`应用下新建`middleware/Auth.php`，内容如下

```php
<?php
// +----------------------------------------------------------------------
// | 登录验证中间件
// +----------------------------------------------------------------------
namespace app\admin\middleware;

use Firebase\JWT\JWT;
use Firebase\JWT\Key;

class Auth
{
    public function handle($request, \Closure $next)
    {
        try{
            $token = $request->header('token');   // 一
            $device = $request->header('device'); // 一
            
            if($device == 'admin' && $token){
                JWT::decode($token,new Key(config('app.jwt_code_admin'),'HS256')); // 二
            }else{
                return failure(config('error.er14')['code'],config('error.er14')['msg']);
            }
        }catch (\Exception $e) {
            return failure(config('error.er14')['code'],config('error.er14')['msg']);
        }

return $next($request);
    }
}
```

一、header头携带了token和device，这里之所以要把$device传过来主要时标识这窜token是哪个应用的token

二、解析token，如果token解析不了就会抛出异常，否则会抛出异常

```json
{
	"code": "2000",
	"msg": "token非法!"
}
```

注意这里一定要带上`app.php`文件中配置的加密窜

```php
//jwt加密字符串
'jwt_code_admin' => 'admin-demo-shop'
```

接下来把中间件注册到路由中，打开`admin/route/app.php`，在后面添加如下

```php
//路由分组，sysuser组里面的请求都要登录后才能访问
Route::group('sysuser', function(){
})->middleware(app\admin\middleware\Auth::class);
```

之后凡是要登录验证的接口都要注册在`sysuser`这个组里面

## 3.8用户信息封装

前面讲`jwt`的时候提到过，把用户信息加密生成一串`token`，用户登录后台成功后，访问后台接口需要带上这一串`token`，中间件会解析这个`token`，如果能被解析则说明这窜`token`有效，并且解析出来的内容就是当初加密的用户信息。

接下来的问题就是，怎么保存这个用户信息，使其在任何地方都可以被调用？

这里我们打开上一节实现的中间件`Auth.php`，需要改动一下

```php
$userInfo = JWT::decode($token,new Key(config('app.jwt_code_admin'),'HS256'));          
$request->user = ['id'=>$userInfo->id,'account'=>$userInfo->account];
```

这里使用$request这个全局对象，设置`sysuser`变量保存登录信息，这里只保存了id和account，一般情况下id是用到最多的，比如说创建者、更新者保存的都是id，再比如我们修改个人信息的时候，也需要根据id去更新。

为了方便我们获取到id或者是用户信息，最好在写两个全局函数，打开`common.php`

```php
/**
 * 获取登录用户ID
 */
function getUserId(){
    return isset(request()->user['id']) ? request()->user['id'] : 0;
}

/**
 * 获取登录用户
 */
function getUserInfo(){
    return isset(request()->user) ? request()->user : [];
}
```

这样的话我们就可以在任何地方很方便的使用它

## 3.9添加/编辑管理员

我们先来看看表字段，看看需要保存哪些信息

| 字段        | 类型             | 备注                      |
| ----------- | ---------------- | ------------------------- |
| id          | int(10) unsigned | 主键（PRIMARY）           |
| root        | tinyint(1)       | 是否是超级管理：0-否 1-是 |
| account     | varchar(30)      | 账号                      |
| password    | varchar(80)      | 密码                      |
| remark      | varchar(255)     | 备注                      |
| roles       | varchar(255)     | 角色，多个用逗号分开      |
| login_time  | datetime         | 最后登录时间              |
| login_ip    | varchar(30)      | 最后登录ip                |
| status      | tinyint(1)       | 状态：0-禁用，1-启用      |
| creator     | int(11)          | 创建者                    |
| updator     | int(11)          | 更新者                    |
| create_time | datetime         | 创建时间                  |
| update_time | datetime         | 更新时间                  |
| delete_time | datetime         | 删除时间                  |

主要的信息是**账号**和**密码**，这两个是必填项。

root字段表示是否超级管理，也就是开发者账号，拥有最高权限

管理员的新增和编辑这一章主要涉及到下面3个知识点：

### 3.9.1密码加密规则

这里我把它封装成一个函数，写在了`app->common.php`

当然这不是唯一的实现方式，如果你没有更好的方式，不妨可以使用这段代码。

### **3.9.2封装公共业务层**

对于新增、编辑、删除这些业务来说，一般来说我们可以把它封装成公共的业务层。

在`commom`目录新建`service`目录，在新建`SysUserService.php`，注意命名方式不要跟`admin/service/AsysUserService.php`一样

```php
/**
     * 新增数据
     * @param  array  $data  新增的数据
     * @return json
     */
public static function save($data){
    if(SysUserModel::getByAccount($data['account'])){
        //如果存在
        return failure(config('error.er8')['code'],config('error.er8')['msg']);
    }
    $sysUser = new SysUserModel;
    //加密
    $data['password'] = createPassword($data['password']);
    $sysUser->save($data);

return success($sysUser->id);
}

/**
     * 更新数据
     * @param  array  $data  更新的数据
     * @return json
     */
public static function update($data){
    $sysUser = SysUserModel::find($data['id']);
    if(!$sysUser){
        return failure(config('error.er15')['code'],config('error.er15')['msg']);
    }

//如果提交过来的账号跟数据库记录的账号不一样，说明当前提交过来的账号是修改过后的账号，因此这里需要验证码修改过的账号是否在数据库里面已经存在
    if(isset($data['account']) && $data['account'] !== $sysUser->account){
        if(SysUserModel::getByAccount($data['account'])){
            //如果存在
            return failure(config('error.er8')['code'],config('error.er8')['msg']);
        }
    }

//加密
    if(isset($data['password']) && !empty($data['password'])){
        $data['password'] = createPassword($data['password']);
    }

$sysUser->save($data);

return success($sysUser->id);
}
```

更新管理员信息这段代码需要注意的有两点：

一、如果提交过来的账号跟数据库记录的账号不一样，说明当前提交过来的账号是修改过后的账号，因此这里需要验证码修改过的账号是否在数据库里面已经存在

二、如果密码字段存在且不为空，那么我们将更新密码

### 3.9.3字段自动填充

创建表的时候创建了这样四个字段：创建时间、创建人、更新时间、更新人

创建时间和更新时间的自动填充我们可以看文档：https://www.kancloud.cn/manual/thinkphp6_0/1037592，里面讲到只需配置一下数据库配置文件即可。我们这里主要讲一下创建人、更新人的自动填充。

要想填充这两个字段，那必须是在插入前和更新前赋值，框架中的**模型事件**刚好解决这个问题，参考文档如下：https://www.kancloud.cn/manual/thinkphp6_0/1037598

我们，打开`BaseModel.php`，新增如下方法

```php
use SoftDelete;
protected $deleteTime = 'delete_time';

//插入前
public static function onBeforeInsert($data){
    return $data['creator'] = getUserId();
}

//更新前
public static function onBeforeUpdate($data){
    return $data['updator'] = getUserId();
}
```

利用模型事件，完成字段的填充，这样我们就不用每个方法都写这两行代码了。

> 作为一个程序员要具备懒人思想，想办法把重复的东西给封装起来

最后我们贴出控制器代码，因为逻辑比较清晰，不做讲解

打开`SysUser.php`，新增如下内容

```php
//新增
public function add(){
    $data = $this->request->post();
    //验证规则
    $validate = [
        'account' => 'require',
        'password'  => 'require|regex:/^[a-zA-Z0-9_]{8,20}$/',
    ];
    //提示信息
    $message = [
        'account.require' => '账号不能为空!',
        'password.require' => '密码不能为空!',
        'password.regex' => '密码长度8~20位，包含字母数字下划线!',
    ];
    $this->validate($data, $validate, $message);

return SysUserService::save($data);
}

//更新
public function edit(){
    $data = $this->request->post();
    //验证规则
    $validate = [
        'id' => 'require',
        'account' => 'require',
    ];
    //提示信息
    $message = [
        'id.require' => 'ID不能为空!',
        'account.require' => '账号不能为空!',
    ];

if(!empty($data['password'])){
        //如果密码不为空时，说明是修改密码，因此要进行密码校验
        $validate['password'] = 'require|regex:/^[a-zA-Z0-9_]{8,20}$/';
        $message['password.require'] = '密码不能为空!';
        $message['password.regex'] = '密码长度8~20位，包含字母数字下划线!';
    }else{
        //销毁变量
        unset($data['password']);
    }

$this->validate($data, $validate, $message);

return SysUserService::update($data);
}
```

新增路由`app.php`

```php
//路由分组
Route::group('sysuser', function(){
    //新增管理员
    Route::post('add','sysUser/add');
    //编辑管理员
    Route::post('edit','sysUser/edit');
})->middleware(app\admin\middleware\Auth::class);
```

## 3.10分页查询

### 3.10.1搜索器

获取列表数据，一般都会设置搜索条件，就拿管理员列表为例子，根据账号搜索，这个功能是很常见的，一般来说我们会在业务核心层这样写

```php
if($request->get('account')){
    $where = $query->where('account', $value);
}
```

当然这样写并没有问题，但你会发现如果条件很多，这个函数体的代码量就会很多，再说了这些搜索条件我们需要在任何地方都可以复用，为了解决这个问题，`thinkphp`的模型给我们提供了很便利的方法：**搜索器**

我们只需要在`app->common->SysUserModel.php`新增如下方法

```php
//根据账号搜索
public function searchAccountAttr($query, $value, $data)
{
    $query->where('account', $value);
}

//根据状态搜索
public function searchStatusAttr($query, $value, $data)
{
    $query->where('status', $value);
}
```

这些搜索只针对当前的模型，简单的讲就是根据表的字段去查询数据，你可以随便定义搜索条件，无论哪个应用都可以共用这些搜索条件

我们调用的时候可以这样调用

```php
SysUserModel::withSearch(array_keys($param),$param)->select();
```

`withSearch()`第一个参数是搜索的字段，是一个一维数组，例如['account','status']

第二个参数是搜索字段对应的条件，也是一个一维数组，例如['account'=>'admin']

### 3.10.2分页的封装

接下来实现业务核心层的代码，打开`app->common->service->SysUserService.php`

```php
/**
 * 列表
 * @param  array  $param  请求参数
 * @return array
*/
public static function page($param){
    //分页设置
    $page = !isset($param['page']) ? 1 : $param['page'];
    $pageSize = !isset($param['page_size']) || $param['page_size'] > 100 ? 10 : $param['page_size'];
	
    //提取搜索体检
    $keyArr = array_keys($param);
    $query = SysUserModel::withSearch(array_keys($param),$param);

$data['total'] = $query->count();
    $data['list'] = [];
    if($data['total'] > 0){
        $data['list'] = $query->withoutField('password')->order('id','desc')->limit(($page-1)*$pageSize,$pageSize)->select()->toArray();

foreach ($data['list']  as $k => $v) {
            $data['list'][$k]['status_text'] = SysUserModel::$status[$v['status']];
        }
    }

return success($data);
}
```

这里有个关键的地方，我们先查总数，如果总数为0，那就没有必要查列表了，直接返回。另外的话这个状态是个整型，因此我们需要转换成中文，因此我在`SysUserModel.php`定义了如下的数组

```php
public static $status = [0=>'禁用',1=>'正常'];
```

**不知道大家有没有发现，如果每个模块的分页查询都要写那么多代码是不是很麻烦？**

接下来我们要做的就是封装一下这块逻辑，我们在开发的时候一定要有这种进化代码的思想，接下来看看我们是怎么做的：

打开`app->common->model->BaseModel.php`

```php
use SoftDelete;
protected $deleteTime = 'delete_time';

//插入前
public static function onBeforeInsert($data){
    return $data['creator'] = getUserId();
}

//更新前
public static function onBeforeUpdate($data){
    return $data['updator'] = getUserId();
}
```

这是之前的内容，我们在后面加上一个`page`方法

```php
//分页查询
public static function page($param, $other = []){
    //分页默认值
    $page = !isset($param['page']) ? 1 : $param['page'];
    $pageSize = !isset($param['page_size']) || $param['page_size'] > 100 ? 10 : $param['page_size'];

//设置排序
    if(isset($other['order']) && $other['order']){
        $arr = explode(',',$other['order']);
        $orderField = $arr[0];
        $orderValue = $arr[1];
    }else{
        $orderField = "id";
        $orderValue = "desc";
    }

$keyArr = array_keys($param);
    $query = self::withSearch(array_keys($param),$param);

$data['total'] = $query->count();
    $data['list'] = [];
    if($data['total'] > 0){
        //设置排除字段
        if(isset($other['withoutField']) && $other['withoutField']){
            $query = $query->withoutField($other['withoutField']);
        }
        //设置查询的字段
        if(isset($other['field']) && $other['field']){
            $query = $query->field($other['field']);
        }

$data['list'] = $query->order($orderField,$orderValue)->limit(($page-1)*$pageSize,$pageSize)->select()->toArray();
    }

return $data;
}
```

`$param `：查询参数以及分页参数

`$other`：目前包含了排序、排除字段、需要查询的字段，后面根据需求进行扩展

再回头看看我们的业务核心层代码，就非常简单了

```php
/**
 * 列表
 * @param  array  $param  请求参数
 * @return array
*/
public static function page($param){
    $data = SysUserModel::page($param,['withoutField'=>'password']);

foreach ($data['list']  as $k => $v) {
        $data['list'][$k]['status_text'] = SysUserModel::$status[$v['status']];
    }

return success($data);
}
```

再看看我们控制器`SysUser.php`写的代码

```php
//列表
public function page(){
    $param = $this->request->get();
    return SysUserService::list($param);
}
```

## 3.11删除管理员

删除一般指软删除，并不会把数据从表里面删除，一般情况下删除数据都是根据id进行删除，另外删除有可能删除一条，也有可能批量删除，因此从实际业务出发，这里又对它进行封装

打开`app->common->service->SysUserService.php`，新增以下内容

```php
/**
 * 删除
 * @param  string  $ids     需要删除数据的id
*/
public static function deleteById($ids){
    if(!empty($ids)){
        foreach(explode(',',$ids) as $id){
            $model = self::find($id);
            $model->delete_time = date('Y-m-d H:i:s',time());
            $model->save();
        }
    }
}
```

这段代码满足批量删除，接下来业务核心层及控制器层调用就非常简单了

`SysUserService.php`

```php
/**
 * 删除
 * @param  string  $ids     需要删除数据的id
*/
public static function destroy($ids){
    if(!empty($ids)){
        SysUserModel::deleteById($ids);
    }
}
```

`SysUser.php`

```php
//删除
public function delete(){
    $ids = $this->request->get("ids");
    if(empty($ids)){
        return failure(config('error.er5')['code'],"请选择要删除的数据");
    }

SysUserService::destroy($ids);
    return success();
}
```

## 3.12其他

### 3.12.1修改个人密码

打开`SysUser.php`，新增以下内容

```php
//修改个人密码
public function updatePwd(){
    $data = $this->request->post();
    //验证规则
    $validate = [
        'password'  => 'require|regex:/^[a-zA-Z0-9_]{8,20}$/',
        'repassword'  => 'require'
    ];
    //提示信息
    $message = [
        'password.require' => '密码不能为空!',
        'password.regex' => '密码长度8~20位，包含字母数字下划线!',
        'repassword.require' => '确认密码不能为空!',
    ];

$this->validate($data, $validate, $message);

//两次输入的密码不一致
    if($data['password'] !== $data['repassword']){
        return failure(config('error.er6')['code'],config('error.er6')['msg']);
    }

return SysUserService::update($data);
}
```

修改密码其实也是修改编辑管理员信息，只不过这个管理员是自己而已

### 3.12.2启用/禁用

```php
//启用、禁用
public function updateStatus(){
    $data = $this->request->post();
    //验证规则
    $validate = [
        'id'  => 'require',
        'status'  => 'require'
    ];
    //提示信息
    $message = [
        'id.require' => '请选择要禁用的数据!',
        'status.require' => '状态不能为空!',
    ];

$result = $this->validate($data, $validate, $message);
    if($result !== true){
        return failure(config('error.er5')['code'],$result->getError());
    }

$data['updator'] = $this->user->id;
    if(SysUserService::update($data)){
        return success();
    }else{
        return failure();
    }
}
```

看看路由的配置

```php
//获取验证码
Route::get('login/verify','sysUser/verify');
//管理员登录
Route::post('login','sysUser/login');

//路由分组
Route::group('sysuser', function(){
    //新增管理员
    Route::post('add','sysUser/add');
    //编辑管理员
    Route::post('edit','sysUser/edit');
    //管理员列表
    Route::get('list','sysUser/list');
    //启用、禁用
    Route::post('updateStatus','sysUser/updateStatus');
    //删除
    Route::get('delete','sysUser/delete');
    //修改个人密码
    Route::post('updatePwd','sysUser/updatePwd');
})->middleware(app\admin\middleware\Auth::class);
```

**注：**

> 无论是修改密码还是对账号进行启用、禁用，其本质是都是根据id修改数据，因此这里的业务逻辑直接调用common应用里面的service层，当然这里你也可以把业务写在admin下的service层，因为管理员模块一般都是amdin应用特有的

## 3.13角色管理

我们先看看角色表需要保存哪些信息

| 字段        | 类型             | 备注            |
| ----------- | ---------------- | --------------- |
| id          | int(10) unsigned | 主键（PRIMARY） |
| role_name   | varchar(30)      | 角色名称        |
| remark      | varchar(255)     | 描述            |
| auth_ids    | text             | 权限            |
| creator     | int(11)          | 创建者          |
| updator     | int(11)          | 更新者          |
| create_time | datetime         | 创建时间        |
| update_time | datetime         | 更新时间        |
| delete_time | datetime         | 删除时间        |

重要的就是两个字段：**角色名称**和**权限**，对应的就是以下两部分内容：

- 增删改查
- 授权，该角色拥有什么权限

**增删改查**

这一部分的内容很简单，并没有什么特殊操作，我们在业务核心层新增四个方法：增、删、改、查

在`app->common/service`下新建`SysRoleService.php`，新增如下内容

```php
<?php
// +----------------------------------------------------------------------
// | 管理员角色模块业务逻辑
// +----------------------------------------------------------------------
namespace app\common\service;
use app\common\model\SysRoleModel;

class SysRoleService{
	/**
     * 新增
     * @param  array  $data  新增的数据
     * @return int
     */
    public static function save($data){
        $role = SysRoleModel::create($data);
        return success($role->id);
    }

/**
     * 更新
     * @param  array  $data 更新的数据
     * @return int
     */
    public static function update($data){
        $role = SysRoleModel::find($data['id']);
        if(!$role){
            return failure(config('error.er15')['code'],config('error.er15')['msg']);
        }
        $role->save($data);
        return success($role->id);

}

/**
     * 删除
     * @param  string  $ids  需要删除数据的id
     */
    public static function destroy($ids){
        if(!empty($ids)){
            SysRoleModel::deleteById($ids);
        }
    }

/**
     * 分页
     * @param  array  $param 搜索条件
     * @return array
     */
    public static function page($param){
        return success(SysRoleModel::page($param));
    } 
}
```

看看分页的代码，之前我们在`BaseModel.php`封装了分页方法，现在是不是体现出来它的好出啦。

接下来新建控制器`app->admin->controller->SysRole.php`

```php
<?php
// +----------------------------------------------------------------------
// | 管理员角色管理控制器
// +----------------------------------------------------------------------
namespace app\admin\controller;

use app\common\service\SysRoleService;

class SysRole extends AdminController
{
    //新增
    public function add(){
        $data = $this->request->post();
        //验证规则
        $validate = [
            'role_name' => 'require',
        ];
        //提示信息
        $message = [
            'role_name.require' => '名称不能为空!',
        ];
        $this->validate($data, $validate, $message);
        
        return SysRoleService::save($data);
    }

//更新
    public function edit(){
        $data = $this->request->post();
        //验证规则
        $validate = [
            'role_name' => 'require',
        ];
        //提示信息
        $message = [
            'role_name.require' => '名称不能为空!',
        ];

$this->validate($data, $validate, $message);

return SysRoleService::update($data);
    }

//分页
    public function page(){
        $param = $this->request->get();
        return SysRoleService::page($param);
    }

//删除
    public function delete(){
        $ids = $this->request->get("ids");
        if(empty($ids)){
            return failure(config('error.er5')['code'],"请选择要删除的数据");
        }

SysRoleService::destroy($ids);
        return success();
    }
}
```

对应的路由配置`app.php`

```php
//路由分组
Route::group('sysuser', function(){
    //新增管理员
    Route::post('add','sysUser/add');
    //编辑管理员
    Route::post('edit','sysUser/edit');
    //管理员列表
    Route::get('page','sysUser/page');
    //启用、禁用
    Route::post('updateStatus','sysUser/updateStatus');
    //删除
    Route::get('delete','sysUser/delete');
    //修改个人密码
    Route::post('updatePwd','sysUser/updatePwd');

//新增角色
    Route::post('role/add','sysRole/add');
    //编辑角色
    Route::post('role/edit','sysRole/edit');
    //角色列表
    Route::get('role/page','sysRole/page');
    //删除角色
    Route::get('role/delete','sysRole/delete');
})->middleware(app\admin\middleware\Auth::class);
```

这里就没有新建一个role组，这里分组的思路按照模块来，角色属于管理员模块，因此就把路由建在一个分组下

**授权**

简单来说就是把菜单的id保存在`auth_ids`这个字段中。

打开`SysRole.php`，新增以下内容

```php
//授权
public function hasAuth(){
    $data = $this->request->post();
    //验证规则
    $validate = [
        'id' => 'require',
        'auth_ids' => 'require',
    ];
    //提示信息
    $message = [
        'id.require' => 'ID不能为空!',
        'auth_ids.require' => '请选择相应权限!',
    ];
    $this->validate($data, $validate, $message);

return SysRoleService::update($data);
}
```

`auth_ids`内容是用逗号分开的权限ID

## 3.14菜单管理

我们先来看看菜单表保存了哪些信息

| 字段        | 类型             | 备注                             |
| ----------- | ---------------- | -------------------------------- |
| id          | int(10) unsigned | 主键（PRIMARY）                  |
| parent_id   | int(11)          | 上一级ID                         |
| type        | tinyint(1)       | 菜单类型：1-目录，2-菜单，3-按钮 |
| name        | varchar(30)      | 菜单名称                         |
| icon        | varchar(255)     | 图标                             |
| route       | varchar(50)      | 前端路由                         |
| component   | varchar(50)      | 组件                             |
| perms       | varchar(50)      | 权限标识                         |
| method      | varchar(30)      | 请求方式                         |
| creator     | int(11)          | 创建者                           |
| updator     | int(11)          | 更新者                           |
| create_time | datetime         | 创建时间                         |
| update_time | datetime         | 更新时间                         |
| delete_time | datetime         | 删除时间                         |

新建模型`app->common->model->SysMenuModel.php`

```php
<?php
// +----------------------------------------------------------------------
// | 菜单模型
// +----------------------------------------------------------------------
namespace app\common\model;

use think\Model;
use think\model\concern\SoftDelete;

class SysMenuModel extends BaseModel
{   
    protected $table = 'ds_sys_menu';
}
```

核心业务层`SysMenuService.php`

```php
<?php
// +----------------------------------------------------------------------
// | 菜单模块业务逻辑
// +----------------------------------------------------------------------
namespace app\common\service;

use app\common\model\SysMenuModel;

class SysMenuService{

/**
     * 新增
     * @param  array  $data  新增的数据
     * @return int
     */
    public static function save($data){
        $result = SysMenuModel::create($data);
        return success($result->id);
    }

/**
     * 更新
     * @param  array  $data 更新的数据
     * @return int
     */
    public static function update($data){
        $result = SysMenuModel::find($data['id']);
        if(!$result){
            failure(config('error.er15')['code'],config('error.er15')['msg']);
        }
        $result->save($data);
        return success($result->id);

}

/**
     * 删除
     * @param  string  $ids  需要删除数据的id
     */
    public static function destroy($ids){
        if(!empty($ids)){
            SysMenuModel::deleteById($ids);
        }
    }

/**
     * 列表
     * @return array
     */
    public static function list(){
        $list = SysMenuModel::select()->toArray();
        $list = treeMenu($list);
        return success($list);
    }
}
```

这里面的列表查询有点特别，首先我们要一次性查出所有菜单，然后递归输出其层级结构，我们看看这个递归函数

`app->common.php`

```php
/**
 * 递归输出菜单
 * @param array  $data      菜单列表
 * @param array  $parentId  父级菜单ID
 */
function treeMenu($data, $parentId=0){
    if(empty($data)) {
        return [];
    }

$list = [];
    foreach ($data as $k => $v) {
        if($parentId == $v['parent_id']){
            $v['children'] = treeMenu($data,$v['id']);
            $list[] = $v;
        }
    }

return $list;
}
```

最后输出的列表是这样的

![](demo-shop-img/3.14-01.jpg)

控制器`app->admin->controller->SysMenu.php`

```php
<?php
// +----------------------------------------------------------------------
// | 菜单管理控制器
// +----------------------------------------------------------------------
namespace app\admin\controller;

use app\common\service\SysMenuService;

class SysMenu extends AdminController
{
    //新增
    public function add(){
        $data = $this->request->post();
        //验证规则
        $validate = [
            'name' => 'require'
        ];
        //提示信息
        $message = [
            'name.require' => '名称不能为空!'
        ];
        $this->validate($data, $validate, $message);
        
        return SysMenuService::save($data);
    }

//更新
    public function edit(){
        $data = $this->request->post();
        //验证规则
        $validate = [
            'id' => 'require',
            'name' => 'require'
        ];
        //提示信息
        $message = [
            'id.require' => 'ID不能为空!',
            'name.require' => '名称不能为空!'
        ];

$this->validate($data, $validate, $message);

return SysMenuService::update($data);
    }

//列表
    public function list(){
        return SysMenuService::list();
    }

SysMenuService::destroy($ids);
        return success();
    }
}
```

## 3.15权限控制

### 3.15.1左侧菜单

当用户登录成功后，不同角色应该看到不一样的菜单，如图

![](demo-shop-img/后台菜单.jpg)

我们可以描述一下整个链路，这样就知道我们接下来要做的东西

1.要查登录用户能看到哪些菜单，那是不是要看该用户归属哪些角色，即需要得到roles字段的内容

2.得到角色的ID后，去查角色表，得到`auth_ids`里面的内容，即菜单ID

3.通过菜单ID去获取菜单的详细信息

那接下来看看如何实现

打开`app->common->service->SysUserService.php`，新增以下内容

```php
/**
 * 详情
 * @param  string  $id   用户ID
*/
public static function info($id){
    $user = SysUserModel::withoutField('password')->find($id)->toArray();
    $user['menu'] = [];
    if($user['root'] == 1){
        //如果是超级管理员，直接返回所有菜单
        $user['menu'] = SysMenuService::list();
    }else{
        if($user['roles']){
            //根据角色ID获取角色拥有的菜单ID
            $authIds = SysRoleService::getAuths($user['roles']);
            //根据id获取菜单详细信息，例如名称
            $user['menu'] = SysMenuService::listById($authIds);
        }
    }

return success($user);
}
```

这个函数主要是获取用户详细信息，其中包含了用户可以访问到菜单栏目。这里面有个判断就是如果`root=1`表示是超级管理员，否则就是获取该账号下角色拥有的权限

我们看看`SysRoleService.php`里面的`getAuths()`方法

```php
/**
 * 返回角色的权限ID
 * @param  string  $ids  角色ID
 * @return array
*/
public static function getAuths($ids){
    $result = SysRoleModel::where('id','in',$ids)->select()->toArray();
    if(count($result) == 0){
        return [];
    }

$atuhStr = '';
    foreach ($result as $k => $v) {
        if($v['auth_ids']){
            $atuhStr = $atuhStr.$v['auth_ids'].',';
        }
    }

if(empty($atuhStr)){
        return [];
    }

return array_unique(explode(',',substr($atuhStr,0,-1)));
}
```

每个角色保存的权限id是用逗号分隔，如果多个角色，就把所有`auth_ids`串联起来，然后再分割、去重，最后得到当前用户的权限ID，最后根据ID去获取列表信息

这边的控制器`SysUser.php`比较简单

```php
//登录用户信息
public function loginUserInfo(){
    return SysUserService::info(getUserId());
}
```

这个方法方法一般是在登录成功里面调用的

### 3.15.2授权判断

上面一节我们实现了界面的权限控制，但细想一下，假如说系统设置下还有一个`会员注册设置`的菜单，虽然说它不会显示在页面左侧，但如果直接访问的话，它还是可以被访问到，因为到目前为止，我们只要求用户登录了就能访问后台，并没有对其拥有的权限进行授权设置。

那怎么时间权限校验呢？下面是大概思路

1. 新增菜单的时候，我们需要添加一个权限标识，也就是保存到菜单表的`perms`字段的值，这个值一般就是访问当前菜单的控制器名+方法名
2. 获取当前登录用户拥有的菜单权限
3. 获取当前访问的控制器名+方法名，看看这个组合是否存在于当前用户拥有的菜单权限中

有了思路之后呢，我们打开登录校验的中间件`Auth.php`，在方法里面增加如下的代码

```php
public function handle($request, \Closure $next)
{
    try{
        $token = $request->header('token');
        $device = $request->header('device');
        if($device == 'admin' && $token){
            //解析token得到用户信息
            $userInfo = JWT::decode($token,new Key(config('app.jwt_code_admin'),'HS256'));
            //把部分用户信息保存到全局reqeust对象中
            $request->user = ['id'=>$userInfo->id,'account'=>$userInfo->account];

//判断是否有权限访问
            if(!$this->checkPermission($request,$userInfo)){
                return failure(config('error.er19')['code'],config('error.er19')['msg']);
            }
        }else{
            return failure(config('error.er14')['code'],config('error.er14')['msg']);
        }
    }catch (\Exception $e) {
        return failure(config('error.er14')['code'],config('error.er14')['msg']);
    }

return $next($request);
}

private function checkPermission($request,$userInfo){
    if($userInfo->root == 1){
        //超管直接返回true
        return true;
    }

if(!$userInfo->roles){
        return false;
    }

if(cache(ADMIN_PERMS_.$userInfo->id)){
        $perms = cache(ADMIN_PERMS_.$userInfo->id);
    }else{
        //根据角色获取菜单ID
        $authIds = SysRoleService::getAuths($userInfo->roles);
        //根据菜单ID获取权限标识，返回的是一个一维数组
        $perms = SysMenuService::getPerms($authIds);
        //保存到缓存中，避免每次查询数据库，注意这里的键值使用了用户ID进行区分
        cache(ADMIN_PERMS_.$userInfo->id,$perms);
    }

if(count($perms) == 0) return false;

//通过request对象获取当前访问的控制器名和方法名，也就是权限标识
    $current = $request->controller().'/'.$request->action();
    //判断标识是否存在于当前用户中
    if(!in_array($current,$perms)){
        return false;
    }

return true;
}
```

**注：**

> 建议此功能放到最后开发，或者是开发好注释掉，这样方便开发

# 4.后台会员模块

后台会员的数据来源一般都是用户在网站进行注册而得到的，因此在讲后台管理模块时，会穿插讲一下会员的注册

## 3.1功能简介

下面规划的一些基础功能，前期从简单的开始，后面再来丰富它的功能

| 功能     | 描述                        |
| -------- | --------------------------- |
| 会员注册 | 手机号注册、手机验证码      |
| 会员信息 | 查询、更新、启用/禁用、删除 |
| 会员等级 | 新增、查询、更新、删除      |

## 3.2手机验证码

目前用户注册比较主流的都是使用手机号了，因此我们先来实现一下发生手机验证码的功能

### 3.2.1免费的短信服务

手机短信平台有很多，例如百度的、腾讯的、阿里的，无论哪个平台都有相应的`sdk`，这里我们使用阿里云的短信服务，上面提供了免费服务供我们学习测试打开如下

地址：https://dysms.console.aliyun.com/quickstart，然后获取相对应的签名和模板

![](demo-shop-img/手机验证码01.jpg)

![](demo-shop-img/手机验证码02.jpg)

这里边是示例代码，有几个比较重要的参数，`accessKeyId`，`accessKeySecret`，`signName`，`templateCode`

其中`signName`，`templateCode`示例代码有

至于`accessKeyId`，`accessKeySecretd`的获取，从下面入口进入即可

![](demo-shop-img/手机验证码03.jpg)

做完这些准备工作后，下面开始写代码了

### 3.2.2策略模式

这里我们学习一种`php`的设计模式-策略模式，来封装发送验证码的核心代码，我们先了解一下它的概念

**策略模式**又叫做政策模式，用于如何组织和调用算法的，是属于行为型模式的一种。 策略模式需要三个角色构成：

- `Context` 封装角色：也叫做上下文角色，起承上启下封装作用，屏蔽高层模块对策略、算法的直接访问，封装可能存在的变化
- `Strategy` 抽象策略角色：通常为接口，指定规则
- `ConcreteStrategy` 具体策略角色：实现抽象策略中的操作，该类含有具体的算法

**优点**

算法可以通过参数自由切换， 方便扩展，增加策略只需要实现接口就行了 。

**第一步：Strategy 抽象策略角色**

它就是定义一个基础接口，这样做的目的就是规范代码，不管你用哪个服务商的代码，但都必须实现这个基础接口

在`commom`应用里面新建一个lib目录(第三方组件)--->`msg`目录(手机发送信息组件)--->`Message.php`

```php
namespace app\common\lib\msg;

interface Message
{   
    /**
     * 发送验证码
     * @param  string     $mobile     手机号
     * @param  string     $code       验证码
     * @return bool
     */
    public function send($mobile,$code);
}
```

这里定义了一个`send()`方法，后续接入进来的服务商代码都要继承这个接口，实现`send()`方法

**第二步：ConcreteStrategy 具体策略角色 **

以阿里云的服务商为例，我们把代码复制过来

```php
class AliYunMessage implements Message
{	//实现接口
    public function send($mobile, $code){
        //读取配置文件的配置
        $config = new Config([
            "accessKeyId" => config('aliyun.accessKeyId'),
            "accessKeySecret" => config('aliyun.accessKeySecret')
        ]);
        $config->endpoint = config('aliyun.dysmsapi');
        $client = new Dysmsapi($config);

$sendSmsRequest = new SendSmsRequest([
            "phoneNumbers" => $mobile,
            "signName" => config('aliyun.signName'),
            "templateCode" => config('aliyun.templateCode'),
            "templateParam" => json_encode(['code'=>$code])
        ]);

$runtime = new RuntimeOptions([]);
        try {
            // 复制代码运行请自行打印 API 的返回值
            $rs = $client->sendSmsWithOptions($sendSmsRequest, $runtime);
            Log::write("获取手机验证码：".json_encode($rs));
            return true;
        }
        catch (Exception $error) {
            if (!($error instanceof TeaError)) {
                $error = new TeaError([], $error->getMessage(), $error->getCode(), $error);
            }
            Log::write('获取手机验证码异常：'.$error->message);
            return false;
        }
    }
}
```

代码中第一步就是读取配置文件的一些关键信息，这里需要`common`下新建`config`目录新建`aliyun.php`,内容如下

```php
<?php
// +----------------------------------------------------------------------
// | 阿里云相关配置
// +----------------------------------------------------------------------

return [
    //AccessKey ID
    'accessKeyId'         => '',
    // AccessKey Secret
    'accessKeySecret'    => '',
    
    /***短信配置****/
    // 签名
    'signName'       => '阿里云短信测试',
    // 短信模板CODE
    'templateCode'      => 'SMS_154950909',
    // 访问的域名
    'dysmsapi' => 'dysmsapi.aliyuncs.com'
];
```

**第三步：Context 封装角色**

```php
namespace app\common\lib\msg;

class MessageContext
{
    private $message;
	
    public function __construct(Message $msg)
    {
        $this->message = $msg;
    }

public function sendMessage($mobile,$code)
    {
        return $this->message->send($mobile,$code);
    }
}
```

这个类里面的构造函数的参数实际就是策略类，然后再调用其里面的`send()`方法

最后看看调用示例

```java
$msgCtx = new MessageContext(new AliYunMessage);
$msgCtx->sendMessage($mobile,$code);
```

有些人可能会觉得，如果直接在`AliYunMessage`类定义一个静态方法，然后直接调用是不是更加方便？

显然，确实是更加方便。

这里我们使用这种策略模式，其目的就是多学习一下php的设计模式，它本身的代码也不复杂，适合在项目中使用。另外它的一个优点就是调用方并不是直接调用算法，而是通过上下文角色进行调用，这样我们就不需要关注算法本身，如果我们要加策略，直接新增类就行。

**注：**

> 把手机验证码发送的核心逻辑封装在`common`应用里面，主要还是因为它是一个公用的功能，任务其它应用如果使用到手机验证码都可以调用它

## 3.3用户注册

### 3.3.1获取手机验证码

用户注册肯定是web端应用，因此在获取验证码的之前，我们先建一个`pc`目录作为web端应用，在`pc`目录下新建如下目录

```
├─app           应用目录
│  ├─pc           应用目录
│  │  ├─controller      控制器目录
│  │  ├─config          配置目录
│  │  ├─route           路由目录
│  │  ├─service         业务核心目录
│  │  ├─middleware      中间件目录
│  │  └─ ...            更多类库目录
```

类似于`admin`应用，我们也为`pc`应用新建一个`PcController`的基础控制器，内容跟`admin`应用差不多，大家可以下载源码看

接下来在`common`应用下的`service`目录，新建`UserService.php`用户核心业务层

```php
/**
 * 获取手机验证码
 * @param  string  $mobile  手机号
 * @param  string  $limit   位数
 * @return bool
*/
public static function getMobileCode($mobile, $limit = 4){
    if($limit == 4){
        $code = rand(0000,9999);
    }else{
        $code = rand(000000,999999);
    }
    
    //如果手机验证码还没有过期，则提示不要重复发送
    if(cache(config('cachekey.mobile_code').$mobile)){
        serviceException(config('error.er3')['code'],config('error.er3')['msg']);
    }

$msgCtx = new MessageContext(new AliYunMessage);
    if($msgCtx->sendMessage($mobile,$code)){
        cache(config('cachekey.mobile_code').$mobile,$code,120);
        return true;
    }else{
        return false;
    }
}
```

该函数实现了手机发送4位或6位手机验证码，这里调用我们前面封装好的函数，然后保存到缓存中，注意这里的key值，一定要把手机号作为key的一部分，这样才能唯一，同时缓存时间设置位120秒

### 3.3.2注册

在common/model新建`UserModel.php`

```php
<?php
// +----------------------------------------------------------------------
// | 用户模型
// +----------------------------------------------------------------------
// | Author: myh
// +----------------------------------------------------------------------
namespace app\common\model;

use think\Model;

class UserModel extends BaseModel
{   
    protected $table = 'ds_user';
}
```

在`pc`应用下的`service`目录新建`PuserService.php`

```php
/**
 * 用户注册
 * @param  array  $data  新增的数据
 * @return int
*/
public static function register($data){
    //验证该账号是否存在
    if(UserModel::getByAccount($data['account'])){
        serviceException(config('error.er8')['code'],config('error.er8')['msg']);
    }

//验证手机号是否存在
    if(UserModel::getByMobile($data['mobile'])){
        serviceException(config('error.er9')['code'],config('error.er9')['msg']);
    }

$data['password'] = createPassword($data['password']);
    $user = new UserModel;
    $user->save($data);
    cache(config('cachekey.mobile_code').$data['mobile'],null);
    return $user->id;
}
```

首先判断账号和手机号是否被注册，然后对密码进行加密存储，最后新增到数表中，并删除验证码缓存。

这里的密码加密函数，是自定义在`app`目录下的`common.php`

一个是加密函数，一个是比较函数

最后就是控制器`User.php`代码

```php
//用户注册
public function register(){
    $data = $this->request->post();
    $data['account'] = trim($data['account']);
    //验证规则
    $validate = [
        'account'  => 'require',
        'password'  => 'require|regex:/^[a-zA-Z0-9_]{8,20}$/',
        'repassword'  => 'require',
        'mobile'  => 'require|regex:/^1[3-9]\d{9}$/',
        'code'  => 'require'
    ];
    //提示信息
    $message = [
        'account.require' => '账号不能为空!',
        'password.require' => '密码不能为空!',
        'password.regex' => '密码长度8~20位，包含字母数字下划线!',
        'repassword.require' => '确认密码不能为空!',
        'mobile.require' => '手机号不能为空!',
        'mobile.regex' => '手机号格式不正确!',
        'code.require' => '验证码不能为空!',
    ];

$this->validate($data, $validate, $message);

//验证码不一致
    if($data['code'] != config('cachekey.mobile_code').$data['mobile']){
        return failure(config('error.er7')['code'],config('error.er7')['msg']);
    }

//验证两次输入的密码是否一致
    if($data['password'] != $data['repassword']){
        return failure(config('error.er6')['code'],config('error.er6')['msg']);
    }

if(PuserService::register($data)){
        return success();
    }else{
        return failure();
    }
}
```

没有啥逻辑可言，就是验证数据

最后就是路由

```php
//用户注册
Route::post('user/register','user/register');
```

## 3.4用户列表

这一章回到我们的`admin`应用，管理员可以查看会员的信息，包括对其进行禁用/启用，首先我们实现它的列表接口

打开`UserService.php`，新增如下内容

```php
/**
 * 用户列表
 * @param  array  $param  请求参数
 * @return array
*/
public static function page($param){
    $data = UserModel::page($param,['withoutField'=>'password']);

foreach ($data['list']  as $k => $v) {
        $data['list'][$k]['status_text'] = UserModel::$status[$v['status']];
    }

return $data;
}
```

就是这么方便，我们直接调用`BaseModel`里面封装的`page()`方法即可，获取到数据后，我们需要对一些字段进行转换，例如代码中的状态，需要把数字转换成中文，因此在`UserModel`模型定义了如下的静态数组

```php
public static $status = [0=>'禁用',1=>'正常'];
```

控制器代码更简单了，在`admin/controller`应用下新建`User.php`

```php
//分页列表
public function page(){
    return $this->success(UserService::page($this->request->get()));
}
```

**注：**

> 只要前期做好了代码的封装，后续开发会非常的方便，包括后面要做的会员等级列表也是一样

## 3.5启用/禁用

可能因为某些原因，我们需要对违规的会员账号进行禁用操作，目前实现这一功能主要是更改会员表的`status`字段即可

打开`common/service/UserService.php`，

```php
/**
 * 更新数据
 * @param  array  $data  更新数据
 * @return bool
*/
public static function update($data){
    $user = UserModel::find($data['id']);
    if(!$user){
        serviceException(config('error.er15')['code'],config('error.er15')['msg']);
    }

if($user->save($data)){
        return true;
    }else{
        return false;
    }
}
```

启用、禁用本质上是修改数据，因此我们在`common`应用下封装一个更新用户信息的方法，后面会员修改个人信息的时候也会用到

再看看控制器`User.php`代码

$this->validate($data, $validate, $message);

if(UserService::update($data)){
        return success();
    }else{
        return failure();
    }
}
```

## 3.6会员等级

会员等级的管理并没有什么复杂的逻辑，只是简单的对数据的增删改查，后面如果遇到跟它类似的模块都按照这个模块的方式去开发

新建`common/model/UserLevelModel.php`

```php
<?php
// +----------------------------------------------------------------------
// | 用户等级模型
// +----------------------------------------------------------------------
// | Author: myh
// +----------------------------------------------------------------------
namespace app\common\model;

class UserLevelModel extends BaseModel
{   
    protected $table = 'ds_user_level';
}

```

新建`common/model/UserLevelService.php`

```php
/**
 * 新增等级数据
 * @param  array  $data  新增的数据
 * @return int
*/
public static function save($data){
    $userLevel = new UserLevelModel;
    $userLevel->save($data);
    //清空缓存
    cache(config('redisKey.USER_LEVEL_LIST'),null);
    return $userLevel->id;
}

/**
 * 更新等级数据
 * @param  array  $data 更新的数据
 * @return int
*/
public static function update($data){
    $user = UserLevelModel::find($data['id']);
    if(!$user){
        serviceException(config('error.er15')['code'],config('error.er15')['msg']);
    }

if($user->save($data)){
        //清空缓存
        cache(config('redisKey.USER_LEVEL_LIST'),null);
        return true;
    }else{
        return false;
    }
}

/**
 * 删除
 * @param  string  $ids  需要删除数据的id
*/
public static function destroy($ids){
    if(!empty($ids)){
        //清空缓存
        cache(config('redisKey.USER_LEVEL_LIST'),null);
        UserLevelModel::destroy(explode(',',$ids));
    }
}

/**
 * 会员等级列表
 * @return array
*/
public static function list(){
    if(cache(config('redisKey.USER_LEVEL_LIST'))){
        return cache(config('redisKey.USER_LEVEL_LIST'));
    }

$list = UserLevelModel::order('growth_value','asc')->select();
    if(!empty($list)){
        //永久缓存
        cache(config('redisKey.USER_LEVEL_LIST'),$list,0);
    }

return $list;
}
```

会员等级不会有很多条数据，因此这里不做分页，同时我们给列表数据加上缓存。

控制器`UserLevel.php`代码

```php
<?php
// +----------------------------------------------------------------------
// | 用户等级模块
// +----------------------------------------------------------------------
// | Author: myh
// +----------------------------------------------------------------------
namespace app\admin\controller;

use app\common\service\UserLevelService;

class UserLevel extends AdminController
{
    //列表
    public function list(){
        $param = $this->request->get();
        return $this->success(UserLevelService::list($param));
    }

//新增
    public function add(){
        $data = $this->request->post();
        //验证规则
        $validate = [
            'level_name'  => 'require',
            'growth_value'  => 'require',
        ];
        //提示信息
        $message = [
            'level_name.require' => '等级名称不能为空!',
            'growth_value.require' => '成长值不能为空!',
        ];

$this->validate($data, $validate, $message);

if(UserLevelService::save($data)){
            return success();
        }else{
            return failure();
        }
    }

//更新
    public function edit(){
        $data = $this->request->post();
        //验证规则
        $validate = [
            'id' => 'require',
            'level_name'  => 'require',
            'growth_value'  => 'require',
        ];
        //提示信息
        $message = [
            'id.require' => '请选择要更新的数据!',
            'level_name.require' => '等级名称不能为空!',
            'growth_value.require' => '成长值不能为空!',
        ];

$this->validate($data, $validate, $message);

if(UserLevelService::update($data)){
            return success();
        }else{
            return failure();
        }
    }

UserLevelService::destroy($ids);

return success();
    }

}
```

## 3.7完善会员列表

之前我们查询用户列表的时候，返回的用户等级level字段是一个整型，它存储的是`ds_user_level`这个表的自增ID，因此我们需要在查询用户列表的时候把level_name给查出来。

打开`UserLevelService.php`，新增一个方法

```php
/**
 * 根据ID获取名称
 * @param  string  $id  等级ID
 * @return string
*/
public static function getLevelNameById($id){
    $list = self::list();
    $levelName = '';
    foreach($list as $v){
        if($v['id'] == $id){
            $levelName = $v['level_name'];
            break;
        }
    }

return $levelName;
}
```

这段代码先调用`list()`方法，获取所有用户等级，然后再根据传进来的ID去获取相对于的等级名称

接下来打开`UserService.php`，找到之前写好的`page($param)`方法，在循环体里面新增如下一行代码即可

```php
foreach ($data['list']  as $k => $v) {
    $data['list'][$k]['status_text'] = UserModel::$status[$v['status']];
    //新加的
    $data['list'][$k]['level_name'] = UserLevelService::getLevelNameById($v['level']);
}
```

这里我并没有使用连表查询，其实开发过程中尽量不要连表查，特别是表数据量大，连的表比较多的时候更加不要连表。像上面这种情况是可以连表的，因为等级表的数据量就是那么几条，连表也无所谓。

另外还有一个地方，上诉代码中在循环体中调用了`getLevelNameById()`这个方法，需要注意的是如果这个方法里面每次都要访问数据库，就不建议这样去做，因为这会增加数据库的压力，千万别怀疑这个东西，当你的循环体有好几个都是这么写，系统越来越庞大，数据量越来越多，性能肯定会下降的，因此我们从一开始就要杜绝这种情况的发生。

这里我之所有那么写，是因为`getLevelNameById($id)`这个方法的实现理论上是不用查数据库的，即使要查也是最多查一次，因为用户等级全部数据都是存储在redis缓存中。

相信大家也知道为啥我不这样实现这个方法

```php
public static function getLevelNameById($id){
 	$level = UserLevelModel::find($id);
    return $level->level_name;
}
```

**注：**

> 上面这种实现逻辑主要是针对表数据比较少的情况，如果说用户等级的数据也几十万条，甚至更多，那这里就不能这样实现，因为你不太可能一次性查出所有数据

## 3.8会员注册默认等级

现在回到注册那一块，注册的时候我们需要给一个默认的会员等级，一般都是最普通的等级。

打开`pc/service/PuserService.php`，找到之前写的`register($data)`方法，新增如下代码

```php
public static function save($data){
    //验证该账号是否存在
    if(UserModel::getByAccount($data['account'])){
        failure(config('error.er8')['code'],config('error.er8')['msg']);
    }

//验证手机号是否存在
    if(UserModel::getByMobile($data['mobile'])){
        failure(config('error.er9')['code'],config('error.er9')['msg']);
    }

//默认会员等级----这是新增的代码
    $level = UserLevelService::list();
    $data['level'] = empty($level) ? 0 : $level[0]['id'];

$data['password'] = createPassword($data['password']);
    $user = new UserModel;
    $user->save($data);
    return $user->id;
}
```

这里调用`UserLevelService::list()`获取会员等级列表，这里的会员等级列表获取是根据`成长值`字段排序输出的，排在第一个的肯定是最开始的一个等级。

# 4.后台商品模块

商品模块可以说是最复杂最核心的一个模块了，首先我们要搞清楚需要实现什么功能，然后我们再去设计数据库。

商品这个模块，我打算拿京东商城的作为参考，可以说是比较复杂的了，只要把这个搞懂了，以后遇到其它的商城项目，对你来说，应该就没啥难度了

## 4.1谈谈SPU和SKU

如果谈到商城项目，特别是目前主流的商城网站，商品SPU和SKU 当属最常用的术语了，我们需要根据它去设计数据的存储方式。

**SPU**是指产品标准化信息单元（Standard Product Unit），是描述一类产品的属性、特征、规格等信息的统一标准 。例如牛仔裤它就是一个spu，一般来说包含了尺寸、颜色、适用季节、适用人群、风格等等属性，你可以把它看作是这一类东西的集合

**SKU**是指库存量单位（Stock Keeping Unit），是指一种特定型号、颜色、尺寸等属性的产品，每个SKU都有一个唯一的编码。你可以把它理解为具体的一个产品

电商平台上，一个SPU可能对应多个SKU，每个SKU代表着不同的产品属性组合，例如不同颜色或尺寸的牛仔裤。通过使用SPU和SKU来管理商品信息，电商平台可以更好地组织和展示商品，方便消费者进行比较和选择。

下面截取了某商城的网页

![](demo-shop-img/4.1spu.jpg)

这里展示的牛仔裤就是一个spu，它具备了尺码、颜色、适用季节、裤型等属性，当面我们点击其中一个spu来到详情页

![](demo-shop-img/4.1sku.jpg)

这里展示的是这个spu集合里面具体的某个产品，也就是sku，这里面sku也有相关的属性，例如颜色、尺码

## 4.2设计数据表

# 附录

## 1.建表语句

### **1.1会员表**

```sql
CREATE TABLE `ds_user`  (
  `id` int(11) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `user_sn` char(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '会员码',
  `account` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '账号',
  `password` varchar(80) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '密码',
  `nickname` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '昵称',
  `avatar` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '头像',
  `mobile` varchar(11) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '手机',
  `level` tinyint(4) NULL DEFAULT 0 COMMENT '等级',
  `sex` tinyint(1) NULL DEFAULT 0 COMMENT '性别：0-未知；1-男；2-女',
  `birthday` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '生日',
  `user_integral` int(11) NULL DEFAULT 0 COMMENT '积分',
  `user_growth` int(11) NULL DEFAULT 0 COMMENT '成长值',
  `login_time` datetime(0) NULL DEFAULT NULL COMMENT '最后登录时间',
  `login_ip` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '最后登录IP',
  `status` tinyint(4) NULL DEFAULT 1 COMMENT '状态：0-禁用 1-启用',
  `is_first_login` tinyint(1) NULL DEFAULT 0 COMMENT '第一次登录：0-未登录 1-已经登录过',
  `creator` int(11) NULL DEFAULT 0 COMMENT '创建人',
  `updator` int(11) NULL DEFAULT 0 COMMENT '更新人',
  `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime(0) NULL DEFAULT NULL COMMENT '更新时间',
  `delete_time` datetime(1) NULL DEFAULT NULL COMMENT '删除时间，默认为空',
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `idx_account`(`account`) USING BTREE,
  INDEX `idx_mobile`(`mobile`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '用户表' ROW_FORMAT = Dynamic;
```

| 字段           | 类型             | 备注                              |
| -------------- | ---------------- | --------------------------------- |
| id             | int(11) unsigned | 主键（PRIMARY）                   |
| user_sn        | char(20)         | 会员码                            |
| account        | varchar(30)      | 账号                              |
| password       | varchar(80)      | 密码                              |
| nickname       | varchar(30)      | 昵称                              |
| avatar         | varchar(200)     | 头像                              |
| mobile         | varchar(11)      | 手机                              |
| level          | tinyint(4)       | 等级                              |
| sex            | tinyint(1)       | 性别：0-未知；1-男；2-女          |
| birthday       | varchar(20)      | 生日                              |
| user_integral  | int(11)          | 积分                              |
| user_growth    | int(11)          | 成长值                            |
| login_time     | datetime         | 最后登录时间                      |
| login_ip       | varchar(30)      | 最后登录IP                        |
| status         | tinyint(4)       | 状态：0-禁用 1-启用               |
| is_first_login | tinyint(1)       | 第一次登录：0-未登录 1-已经登录过 |
| creator        | int(11)          | 创建人                            |
| updator        | int(11)          | 更新人                            |
| create_time    | datetime         | 创建时间                          |
| update_time    | datetime         | 更新时间                          |
| delete_time    | datetime(1)      | 删除时间，默认为空                |

### 1.2会员积分明细表

```mysql
CREATE TABLE `ds_user_integral_log`  (
  `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `type` tinyint(4) NULL DEFAULT 0 COMMENT '类型：1-签到，2-下单',
  `user_id` int(11) NULL DEFAULT 0 COMMENT '用户ID',
  `integral` int(11) NULL DEFAULT 0 COMMENT '积分',
  `creator` int(11) NULL DEFAULT 0 COMMENT '创建者ID',
  `updator` int(1) NULL DEFAULT 0 COMMENT '更新者ID',
  `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime(0) NULL DEFAULT NULL COMMENT '更新时间',
  `delete_time` datetime(0) NULL DEFAULT NULL COMMENT '删除时间',
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `idx_user_id`(`user_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '用户积分明细表' ROW_FORMAT = Dynamic;
```

| 字段        | 类型             | 备注                 |
| ----------- | ---------------- | -------------------- |
| id          | int(10) unsigned | 主键（PRIMARY）      |
| type        | tinyint(4)       | 类型：1-签到，2-下单 |
| user_id     | int(11)          | 用户ID               |
| integral    | int(11)          | 积分                 |
| creator     | int(11)          | 创建者ID             |
| updator     | int(1)           | 更新者ID             |
| create_time | datetime         | 创建时间             |
| update_time | datetime         | 更新时间             |
| delete_time | datetime         | 删除时间             |

### 1.3会员等级表

```mysql
CREATE TABLE `ds_user_level`  (
  `id` int UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `level_name` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '等级名称',
  `growth_value` int(11) NULL DEFAULT 0 COMMENT '成长值',
  `remark` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '等级备注',
  `image` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '等级图标',
  `privilege` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '等级权益',
  `discount` decimal(11, 1) NULL COMMENT '等级折扣',
  `creator` int(11) NULL DEFAULT 0 COMMENT '创建者',
  `updator` int(11) NULL DEFAULT 0 COMMENT '更新者',
  `create_time` datetime NULL COMMENT '创建时间',
  `update_time` datetime NULL COMMENT '更新时间',
  `delete_time` datetime NULL COMMENT '删除时间',
  PRIMARY KEY (`id`)
) COMMENT = '会员等级表';
```

| 字段         | 类型             | 备注            |
| ------------ | ---------------- | --------------- |
| id           | int(10) unsigned | 主键（PRIMARY） |
| level_name   | varchar(30)      | 等级名称        |
| growth_value | int(11)          | 成长值          |
| remark       | varchar(255)     | 等级备注        |
| image        | varchar(255)     | 等级图标        |
| privilege    | varchar(255)     | 等级权益        |
| discount     | decimal(11,1)    | 等级折扣        |
| creator      | int(11)          | 创建者          |
| updator      | int(11)          | 更新者          |
| create_time  | datetime         | 创建时间        |
| update_time  | datetime         | 更新时间        |
| delete_time  | datetime         | 删除时间        |

### 1.4管理员表

```mysql
CREATE TABLE `ds_sys_user`  (
  `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `root` tinyint(1) NULL DEFAULT 0 COMMENT '是否是超级管理：0-否 1-是',
  `account` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '账号',
  `password` varchar(80) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '密码',
  `remark` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '备注',
  `roles` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '角色，多个用逗号分开',
  `login_time` datetime(0) NULL DEFAULT NULL COMMENT '最后登录时间',
  `login_ip` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '最后登录ip',
  `status` tinyint(1) NULL DEFAULT 1 COMMENT '状态：0-禁用，1-启用',
  `creator` int(11) NULL DEFAULT 0 COMMENT '创建者',
  `updator` int(11) NULL DEFAULT NULL COMMENT '更新者',
  `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime(0) NULL DEFAULT NULL COMMENT '更新时间',
  `delete_time` datetime(0) NULL DEFAULT NULL COMMENT '删除时间',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '管理员表' ROW_FORMAT = Dynamic;
```

### 1.5管理员角色表

```mysql
DROP TABLE IF EXISTS `ds_sys_role`;
CREATE TABLE `ds_sys_role`  (
  `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `role_name` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '角色名称',
  ` remark` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '描述',
  `auth_ids` text CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL COMMENT '权限',
  `creator` int(11) NULL DEFAULT 0 COMMENT '创建者',
  `updator` int(11) NULL DEFAULT 0 COMMENT '更新者',
  `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime(0) NULL DEFAULT NULL COMMENT '更新时间',
  `delete_time` datetime(0) NULL DEFAULT NULL COMMENT '删除时间',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '管理员角色表' ROW_FORMAT = Dynamic;
```

### 1.6后台菜单表

```mysql
CREATE TABLE `ds_sys_menu`  (
  `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `parent_id` int(11) NULL DEFAULT 0 COMMENT '上一级ID',
  `type` tinyint(1) NULL DEFAULT 1 COMMENT '菜单类型：1-目录，2-菜单，3-按钮',
  `name` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '菜单名称',
  `icon` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '图标',
  `route` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '前端路由',
  `component` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '组件',
  `perms` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '权限标识',
  `method` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT '' COMMENT '请求方式',
  `creator` int(11) NULL DEFAULT 0 COMMENT '创建者',
  `updator` int(11) NULL DEFAULT 0 COMMENT '更新者',
  `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime(0) NULL DEFAULT NULL COMMENT '更新时间',
  `delete_time` datetime(0) NULL DEFAULT NULL COMMENT '删除时间',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '菜单表' ROW_FORMAT = Dynamic;
```

非凡X/demo-shop

简介

发行版

贡献者

近期动态

非凡X/demo-shop .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

非凡X/demo-shop