mpvue小程序：网易严选后端 mpvue-shop-node

朴灿烈づ我的快乐病毒、 2022-12-06 12:57 179阅读 0赞

# 后端项目搭建：mpvue-shop-node #

<table> 
 <thead> 
  <tr> 
   <th>目录结构</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>controllers</td> 
   <td>控制层</td> 
  </tr> 
  <tr> 
   <td>routes</td> 
   <td>路由分发层</td> 
  </tr> 
  <tr> 
   <td>app.js</td> 
   <td>入口文件</td> 
  </tr> 
  <tr> 
   <td>config.js</td> 
   <td>项目配置文件</td> 
  </tr> 
  <tr> 
   <td>mysql.js</td> 
   <td>数据库基础配置</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

> 新建后端项目：server
> 
>  *  knex 查询构造器是用于构建和执行标准的SQL查询,例如：select, insert, update, delete
>  *  koa-bodyparser 用于解析前端发起post请求传递的数据对象
> 
> 文档：https://blog.songxingguo.com/2018/06/30/knex.js-query/
> 
>     cd server
>     npm init -y
>     npm i koa koa-router koa-bodyparser knex mysql -S

## 后端接收前端传递的数据方式：（重点） ##

// get请求，接收前端传递的数据：ctx.query.数据字段
    const openId = ctx.query.openId
    
    // post请求，接收前端传递的数据（对象）：ctx.request.body
    const { openId, keyword} = ctx.request.body

## 查询语句总结：（重点） ##

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>查询数据>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    // 查询表中的所有数据
    const channel = await mysql('nideshop_channel').select()
    
    // 根据id查询表中的数据
    const banner = await mysql('nideshop_ad').where({ 
    ad_position_id: 1
    }).select()
    
    // 查询指定内容（根据id）
    const newGoods = await mysql('nideshop_goods').whereIn('id', [1181000, 1135002, 1134030, 1134032]).andWhere('is_new', 1).select()
    
    // 查询表中指定字段
    const hotGoods = await mysql('nideshop_goods').column('id', 'name', 'list_pic_url', 'retail_price', 'goods_brief').where({ 
    is_hot: 1
    }).limit(5).select()
    
    
    // 根据id查询表中的数据,升序，只显示4条数据
    const brandList = await mysql('nideshop_brand').where({ 
    is_new: 1
    }).orderBy('new_sort_order', 'asc').limit(4).select()
    
    // 模糊查询：用于获取用户输入的搜索关键字，显示带有关键字的搜索内容（限制10条）
    const keywords = await mysql('nideshop_goods')
    .column('id', 'name', 'list_pic_url', 'retail_price')
    .where('name', 'like', '%' + keyword + '%').limit(10).select()
    
    >>>>>>>>>>>>>>>>>>>>>>关联查询：表A存储值；表B存储键>>>>>>>>>>>>>>>
    const attribute = await mysql('表A').column('表A.value', '表B.name').leftJoin('表B', '表A.attribute_id', '表B.id').where({ 
    '表A.goods_id': 前端传入的查询参数goodsId
    }).select()
    
    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>插入数据>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    // 向数据库表中，插入指定数据
    const data = await mysql('nideshop_search_history').insert({ 
    'user_id': openId,
    'keyword': keyword,
    'add_time': parseInt(new Date().getTime() / 1000)
    })
    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>删除数据>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    // 根据用户标识 openId ，清除用户搜索历史记录
    const data = await mysql('nideshop_search_history').where({ 
    'user_id': openId
    }).del()
    console.log(data) // 显示删除的数据条数
    if (data) { 
    ctx.body = { 
    'data': '清除成功'
    }
    } else { 
    ctx.body = { 
    'data': '清除失败'
    }
    }
    
    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>更新数据>>>>>>>>>>>>>>>>>>>>>>>>>>
    const data = await mysql('nideshop_order').where({ 
       'user_id': openId
     }).update({ 
       user_id: openId,
       goods_id: goodsId,
       allprice: allPrice
     })

## package.json文件 ##

{ 
      "name": "mpvue-shop-node",
      "version": "1.0.0",
      "description": "",
      "main": "index.js",
      "scripts": { 
        "test": "echo \"Error: no test specified\" && exit 1"
      },
      "author": "",
      "license": "ISC",
      "dependencies": { 
        "knex": "^0.20.8",
        "koa": "^2.11.0",
        "koa-bodyparser": "^4.2.1",
        "koa-router": "^8.0.6",
        "mysql": "^2.18.1"
      },
      "devDependencies": { 
        "nodemon": "^2.0.2"
      }
    }

## 1. controllers 控制层 ##

### 1-1：总布局 index.js ###

> controllers / index.js（自动读取本地目录结构,获取文件绝对路径）

const _ = require('lodash')
    const fs = require('fs')
    const path = require('path')
    
    // 映射 d 文件夹下的文件为模块
    
    const mapDir = d => { 
      const tree = { }
    
      // 获取当前文件夹下的所有文件夹和文件，分成两组，文件夹一组，文件一组
      const [dirs, files] = _(fs.readdirSync(d)).partition(p => fs.statSync(path.join(d, p)).isDirectory())
      // 映射文件夹
      dirs.forEach(dir => { 
        tree[dir] = mapDir(path.join(d, dir))
      });
      // 映射文件
      files.forEach(file => { 
        // 获取文件后缀名字
        if (path.extname(file) === '.js') { 
          tree[path.basename(file, '.js')] = require(path.join(d, file))
        }
      })
    
      return tree
    }
    
    // 默认导出当前文件夹下的映射
    module.exports = mapDir(path.join(__dirname))

### 1-2：收货地址 address/ index.js ###

> 收货地址相关的接口：controllers / address/ index.js

const {  mysql } = require('../../mysql')
    
    // 获取收货地址列表
    async function getListAction(ctx) { 
    
      // 第一步：接收前端传递的数据
      const openId = ctx.query.openId
    
      // 第二步：根据用户id 查询 `收货地址表`
      const addressList = await mysql('nideshop_address').where({ 
        'user_id': openId
      }).orderBy('is_default', 'desc').select()
    
      // 第三步：判断查询状态
      ctx.body = { 
        data: addressList
      }
    }
    
    // 获取详细地址
    async function detailAction(ctx) { 
      const id = ctx.query.id
      const detailData = await mysql('nideshop_address').where({ 
        'id': id
      }).select()
      ctx.body = { 
        data: detailData[0]
      }
    }
    
    // 添加或更新收货地址
    async function saveAction(ctx) { 
    
      // 第一步：获取前端传递的数据
      const addressId = ctx.request.body.addressId
      const {  userName, telNumber, address, detailaddress, checked, openId } = ctx.request.body
      console.log(checked)
    
      // 第二步：如果是默认选中，首先在数据库中查询是否是默认地址（默认收货地址只能有一个）
      if (checked) { 
    
        // 首先：查询数据库中此时默认的收货地址
        const isDefault = await mysql('nideshop_address').where({ 
          'user_id': openId,
          'is_default': 1
        }).select()
    
        // 然后：如果找到了这条数据，将其更改为普通收货地址
        if (isDefault.length > 0) { 
          await mysql('nideshop_address').where({ 
            'user_id': openId,
            'is_default': 1
          }).update({ 
            'is_default': 0
          })
        }
      }
    
      // 收货地址不存在：说明用户新建收货地址 或者 一键导入收货地址 => 也就是要执行：添加收货地址
      if (!addressId) { 
        // 添加地址
        const data = await mysql('nideshop_address').insert({ 
          name: userName,
          mobile: telNumber,
          address: address,
          address_detail: detailaddress,
          user_id: openId,
          is_default: checked == 'true' || checked ? 1 : 0
        })
        // 数据添加成功-失败
        if (data) { 
          ctx.body = { 
            data: true
          }
        } else { 
          ctx.body = { 
            data: false
          }
        }
      } else { 
        // 收货地址存在：用户点击的是编辑收货地址
        // 第一步：执行更新收货地址
        const data = await mysql('nideshop_address').where({ 
          'id': addressId
        }).update({ 
          name: userName,
          mobile: telNumber,
          address: address,
          address_detail: detailaddress,
          user_id: openId,
          is_default: checked == 'true' || checked ? 1 : 0
        })
        if (data) { 
          ctx.body = { 
            data: true
          }
        } else { 
          ctx.body = { 
            data: false
          }
        }
      }
    }
    
    module.exports = { 
      getListAction,
      detailAction,
      saveAction
    }

### 1-3：购物车 cart / index.js ###

> 购物车相关的接口：controllers / cart / index.js

const {  mysql } = require('../../mysql')
    
    async function addCart(ctx) { 
    
      // 接收前端传递的数据
      const {  openId, goodsId, number } = ctx.request.body
    
      /** * 判断`购物车数据表`是否包含此数据 * 当前商品是否已加入购物车：如果有只要增加具体的数量就可以了；如果没有执行商品加入购物车的操作 */
      const haveGoods = await mysql('nideshop_cart').where({ 
        'user_id': openId,
        'goods_id': goodsId
      }).select()
    
      if (haveGoods.length === 0) { 
    
        // 根据商品id从`商品信息表`中，查询：商品的价格、商品名称、商品图片 =>然后将商品信息加入`购物车数据表`中
        const goods = await mysql('nideshop_goods').where({ 
          'id': goodsId
        }).select()
        const {  retail_price, name, list_pic_url } = goods[0]
        // 如果不存在，说明该商品没有加入购物车：将该商品加入购物车就可以了
        await mysql('nideshop_cart').insert({ 
          'user_id': openId,
          'goods_id': goodsId,
          number,
          'goods_name': name,
          retail_price,
          list_pic_url
        })
      } else { 
        // 在`购物车表`中，能找到该商品。说明该商品已加入购物车 => 修改商品数量
        // 第一步：查询`购物车数据表`中，该商品的数量
        const oldNumber = await mysql('nideshop_cart').where({ 
          'user_id': openId,
          'goods_id': goodsId
        }).column('number').select()
        // 第二步：更新`购物车数据表`中的数据
        await mysql('nideshop_cart').where({ 
          'user_id': openId,
          'goods_id': goodsId
        }).update({ 
          'number': oldNumber[0].number + number
        })
      }
      // 商品加入购物车成功
      ctx.body = { 
        data: 'success'
      }
    }
    
    // 获取购物车列表
    async function cartList(ctx) { 
    
      // 第一步：接收前端传递的数据
      const {  openId } = ctx.query
      // 第二步：查询购物车表中的数据
      const cartList = await mysql('nideshop_cart').where({ 
        'user_id': openId
      }).select()
      ctx.body = { 
        data: cartList
      }
    }
    
    module.exports = { 
      addCart,
      cartList
    }

### 1-3：商品分类 category / index.js ###

> 分类相关的接口：controllers / category / index.js

const {  mysql } = require('../../mysql')
    
    // 获取分类列表,导航栏
    async function categoryNav(ctx) { 
    
      // 第一步：获取前端传递的商品分类id
      const categoryId = ctx.query.id
      // 第二步：获取分类（这个商品id是由前端上一个页面传递的 => 然后进入商品分类页面）
      const currentNav = await mysql('nideshop_category').where({ 
        'id': categoryId
      }).select()
      // 第三步：获取它的同类（是指：在首页中点击居家 =>进入商品分类页面：此时商品分类页面也要显示居家的商品分类内容）
      const navData = await mysql('nideshop_category').where({ 
        'parent_id': currentNav[0].parent_id
      }).select()
    
      ctx.body = { 
        navData,
        currentNav: currentNav[0]
      }
    }
    
    // 分类页面
    async function indexAction(ctx) { 
    
      // 第一步：
      const {  id: categoryId } = ctx.query
      // 第一步：查找 parent_id 为0的数据，作为菜单分类数据（左侧数据）
      const data = await mysql('nideshop_category').where({ 
        'parent_id': 0
      }).select()
      // 第二步：
      const currentCategory = []
      if (categoryId) { 
        currentCategory = await mysql('nideshop_category').where({ 
          'parent_id': categoryId
        }).select()
      }
    
      ctx.body = { 
        'categoryList': data
      }
    }
    
    // 点击左侧菜单获取的分类商品
    async function currentAction(ctx) { 
    
      // 第一步：获取商品id
      const {  id: categoryId } = ctx.query
      // 第二步：查询`分类表`
      const data =  { }
      const currentOne = await mysql('nideshop_category').where({ 
        'id': categoryId
      }).select()
      const subList = await mysql('nideshop_category').where({ 
        'parent_id': currentOne[0].id
      }).select()
      data.currentOne = currentOne[0]
      data.currentOne.subList = subList
    
      ctx.body = { 
        'data': data
      }
    }
    
    module.exports = { 
      categoryNav,
      indexAction,
      currentAction
    }

### 1-4：收藏 collect / index.js ###

> 收藏相关的接口：controllers / collect / index.js

const {  mysql } = require('../../mysql')
    
    // 添加收藏
    async function addCollect(ctx) { 
      const {  openId, goodsId } = ctx.request.body
      // 判断是否已经收藏
      const iscollect = await mysql('nideshop_collect').where({ 
        'user_id': openId,
        'value_id': goodsId
      }).select()
      if (iscollect.length == 0) { 
        await mysql('nideshop_collect').insert({ 
          'user_id': openId,
          'value_id': goodsId
        })
        ctx.body = { 
          data: 'collected'
        }
      } else { 
        await mysql('nideshop_collect').where({ 
          'user_id': openId,
          'value_id': goodsId
        }).del()
        ctx.body = { 
          data: 'uncollect'
        }
      }
    }
    
    module.exports = { 
      addCollect
    }

### 1-5：商品 goods / index.js ###

> 商品相关的接口：controllers / goods / index.js

const {  mysql } = require('../../mysql')
    
    // 商品详情页数据
    async function detailAction(ctx) { 
      const goodsId = ctx.query.id
      const openId = ctx.query.openId
      // 商品信息
      const info = await mysql('nideshop_goods').where({ 
        'id': goodsId
      }).select()
      // 获取商品的图片
      const gallery = await mysql('nideshop_goods_gallery').where({ 
        'goods_id': goodsId
      })
      // 商品参数 关联查询两张表leftJoin
      /** * 理解：这两张表都是用来形容一个人的详细信息 * A表：name id age * B表：sex number tall * 做法：找到A表的age18岁，然后拿着age18去找number也为18的数据 * * 数据库表划分的非常精细：键和值分别在不同的表中 * 例如： name 对应 小明 * 表 nideshop_attribute 存放键 * 表 nideshop_goods_attribute 存放对应的值 */
      const attribute = await mysql('nideshop_goods_attribute').column('nideshop_goods_attribute.value', 'nideshop_attribute.name').leftJoin('nideshop_attribute', 'nideshop_goods_attribute.attribute_id', 'nideshop_attribute.id').where({ 
        'nideshop_goods_attribute.goods_id': goodsId
      }).select()
    
      // 常见问题
      const issue = await mysql('nideshop_goods_issue').select()
    
      // 大家都在看
      const productList = await mysql('nideshop_goods').where({ 
        'category_id': info[0].category_id
      }).select()
    
      // 判断是否收藏过
      const iscollect = await mysql('nideshop_collect').where({ 
        'user_id': openId,
        'value_id': goodsId
      }).select()
      let collected = false
      if (iscollect.length > 0) { 
        collected = true
      }
    
      // 判断该用户的购物车里是否含有此商品
      const oldNumber = await mysql('nideshop_cart').where({ 
        'user_id': openId
      }).column('number').select()
      let allnumber = 0
      if (oldNumber.length > 0) { 
        for (let i = 0; i < oldNumber.length; i++) { 
          const element = oldNumber[i] // {number: 1}
          allnumber += element.number
        }
      }
    
      ctx.body = { 
        'info': info[0] || [],
        'gallery': gallery,
        'attribute': attribute,
        'issue': issue,
        'productList': productList,
        'collected': collected,
        'allnumber': allnumber
      }
    }
    
    // 商品列表
    async function goodsList(ctx) { 
    
      // 第一步：获取分类id
      const categoryId = ctx.query.categoryId
      // 第二步：根据分类id，获取该商品分类所属的商品信息列表
      let goodsList = []
      if (categoryId) { 
    
        // 查询商品信息表
        goodsList = await mysql('nideshop_goods').where({ 
          'category_id': categoryId
        }).select()
    
        // 查询商品分类表
        const currentNav = await mysql('nideshop_category').where({ 
          'id': categoryId
        }).select()
    
        // 如果没有取到商品
        if (goodsList.length == 0) { 
    
          // 找到与之相关的子类，再找到与子类相关的商品
          let subIds = await mysql('nideshop_category').where({ 
            'parent_id': categoryId
          }).column('id').select()
    
          // 如果找到了
          if (subIds.length !== 0) { 
            subIds = subIds.map((item) => { 
              return item.id
            })
          }
          goodsList = await mysql('nideshop_goods').whereIn('category_id', subIds).limit(50).select()
        }
    
        ctx.body = { 
          data: goodsList,
          currentNav: currentNav[0]
        }
      }
    }
    
    module.exports = { 
      detailAction,
      goodsList
    }

### 1-6：首页 home / index.js ###

> 首页相关的接口：controllers / home / index.js

// 因为要查询数据库中的数据，所以引入mysql
    const {  mysql } = require('../../mysql')
    
    module.exports = async (ctx) => { 
      // 轮播图数据
      const banner = await mysql('nideshop_ad').where({ 
        ad_position_id: 1
      }).select()
    
      // tab类型
      const channel = await mysql('nideshop_channel').select()
    
      // 品牌列表
      const brandList = await mysql('nideshop_brand').where({ 
        is_new: 1
      }).orderBy('new_sort_order', 'asc').limit(4).select()
    
      // 新品首发
      const newGoods = await mysql('nideshop_goods').whereIn('id', [1181000, 1135002, 1134030, 1134032]).andWhere('is_new', 1).select()
    
      // 人气推荐
      const hotGoods = await mysql('nideshop_goods').column('id', 'name', 'list_pic_url', 'retail_price', 'goods_brief').where({ 
        is_hot: 1
      }).limit(5).select()
    
      // 专题精选
      const topicList = await mysql('nideshop_topic').limit(3).select()
    
      // 第一步：查询标题：类别列表 **好物：查询出页面标题展示的内容
      const categoryList = await mysql('nideshop_category').where({ 
        parent_id: 0
      }).select()
    
      // 第二步：区分标题下面所属的内容：哪些内容属于居家好物一类；哪些内容属于xxx的一类，等等...
      const newCategoryList = []
      for (let i = 0; i < categoryList.length; i++) { 
        let item = categoryList[i]
        let childCategoryIds = await mysql('nideshop_category').where({ 
          parent_id: item.id
        }).column('id').select()
        // 变成数组的形式 [1020000, 1036002]
        childCategoryIds = childCategoryIds.map((item) => { 
          return item.id
        })
        // 第三步：在商品中找到在childCategoryIds里的7条数据，whereIn 判断：category_id 是否存在于 childCategoryIds 
        const categoryGoods = await mysql('nideshop_goods').column('id', 'name', 'list_pic_url', 'retail_price').whereIn('category_id', childCategoryIds).limit(7).select()
        newCategoryList.push({ 
          'id': item.id,
          'name': item.name,
          'goodsList': categoryGoods
        })
      }
    
      ctx.body = { 
        'banner': banner,
        'channel': channel,
        'brandList': brandList,
        'newGoods': newGoods,
        'hotGoods': hotGoods,
        'topicList': topicList,
        'newCategoryList': newCategoryList
      }
    }

### 1-7：订单 order / index.js ###

> 订单相关的接口：controllers / order / index.js

const {  mysql } = require('../../mysql')
    
    async function submitAction (ctx) { 
      // let goodsId = ctx.request.body.goodsId
      // let allPrice = ctx.request.body.allPrice
    
      // 接口前端传递的参数
      const {  openId, goodsId, allPrice } = ctx.request.body
     
      // 是否存在订单
      const isOrder = await mysql('nideshop_order').where({ 
        'user_id': openId
      }).select()
      // 说明数据库中存在该商品--只是显示`未支付订单`--只需要更改商品信息就可以了，不需要再次插入同样的商品数据信息
      if (isOrder.length > 0) { 
        // 
        const data = await mysql('nideshop_order').where({ 
          'user_id': openId
        }).update({ 
          user_id: openId,
          goods_id: goodsId,
          allprice: allPrice
        })
        /** * 数据更新状态：更新成功--更新失败 */
        if (data) { 
          ctx.body = { 
            data: true
          }
        } else { 
          ctx.body = { 
            data: false
          }
        }
      } else { 
        // 说明该商品不在`未支付订单`中，说明用户要添加新的商品--直接将商品信息添加到未支付表中
        const data = await mysql('nideshop_order').insert({ 
          user_id: openId,
          goods_id: goodsId,
          allprice: allPrice
        })
      /** * 数据添加状态：数据添加成功--数据添加失败 */
        if (data) { 
          ctx.body = { 
            data: true
          }
        } else { 
          ctx.body = { 
            data: false
          }
        }
      }
    }
    
    /** * 获取用户的收货地址 */
    async function detailAction (ctx) { 
    
      // 第一步：获取前端传递的数据：收货地址和用户标识openId
      const openId = ctx.query.openId
      const addressId = ctx.query.addressId || ''
    
      // 第二步：根据openId查询订单表（未支付订单）
      const orderDetail = await mysql('nideshop_order').where({ 
        'user_id': openId
      }).select()
    
      // 第三步：如果有多个商品，就会把商品id用逗号分隔为数组，如：["1001","1002","1003"]
      var goodsIds = orderDetail[0].goods_id.split(',')
    
      // 第四步：根据用户openId 查询 `购物车表`；判断`购物车表`中的goods_id，是否存在于未支付订单表中
      const list = await mysql('nideshop_cart').andWhere({ 
        'user_id': openId
      }).whereIn('goods_id', goodsIds).select()
    
      // 第五步：收货地址
      var addressList;
      if (addressId) { 
    
        // 收货地址存在：查询`收货地址表`中的数据
        addressList = await mysql('nideshop_address').where({ 
          'user_id': openId,
          'id': addressId
        }).orderBy('is_default', 'desc').select()
    
      } else { 
    
        // 收货地址不存在（前端没有传递收货地址）
        addressList = await mysql('nideshop_address').where({ 
          'user_id': openId
        }).orderBy('is_default', 'desc').select()
    
      }
      ctx.body = { 
        price: orderDetail[0].allprice,  // 商品单价
        goodsList: list,  // 商品列表
        address: addressList[0] || { } // 收货地址
      }
    }
    
    module.exports = { 
      submitAction,
      detailAction
    }

### 1-8：搜索 search / index.js ###

> 搜索相关的接口：controllers / search / index.js

const {  mysql } = require('../../mysql')
    
    /** * 这个接口：负责搜索记录数据和热门搜索的数据 */
    async function indexAction(ctx) { 
    
      /** * get请求，接收前端传递的数据：ctx.query.数据字段 * 传入用户的标识 openId */
      const openId = ctx.query.openId
    
      // 默认关键字：如果 is_default 为1，说明取出的是搜索热门的默认关键字。
      const defaultKeyword = await mysql('nideshop_keywords').where({ 
        is_default: 1
      }).limit(1).select()
    
      // 热门关键字：keyword 是指数据库中的字段
      const hotKeywordList = await mysql('nideshop_keywords').distinct('keyword').column('keyword', 'is_hot').limit(10).select()
    
      // 搜索历史(取10条)：传入用户的标识 openId ，你存的数据只有你才能取出来。同理：你也不能看到别人存的数据...
      const historyData = await mysql('nideshop_search_history').where({ 
        'user_id': openId
      }).limit(10).select()
      ctx.body = { 
        'defaultKeyword': defaultKeyword[0],
        'hotKeywordList': hotKeywordList,
        'historyData': historyData
      }
    }
    
    
    // 搜索时匹配搜索相关的内容
    async function helperAction(ctx) { 
    
      // 获取用户搜索的内容
      const keyword = ctx.query.keyword
      var order = ctx.query.order
      if (!order) { 
        order = ''
        orderBy = 'id'
      } else { 
        orderBy = 'retail_price'
      }
    
      // 查询搜索关键字
      const keywords = await mysql('nideshop_goods').orderBy(orderBy, order)
      .column('id', 'name', 'list_pic_url', 'retail_price')
      .where('name', 'like', '%' + keyword + '%').limit(10).select()
      
      if (keywords) { 
        ctx.body = { 
          keywords
        }
      } else { 
        ctx.body = { 
          keywords: []
        }
      }
    }
    
    
    // 添加搜索历史
    async function addHistoryAction(ctx) { 
    
      // post请求，接收前端传递的数据（对象）：ctx.request.body
      const { openId, keyword} = ctx.request.body
    
      // 查询历史搜索记录
      const oldData = await mysql('nideshop_search_history').where({ 
        'user_id': openId,
        'keyword': keyword
      })
    
      /** * 如果用户搜索的内容，已存在数据库中。则不需要重复存储搜索记录。 * 目的：判断当下搜索字段，是否插入数据库表中，作为历史搜索记录。 */
    
      if (oldData.length == 0) { 
    
        // 如果搜索内容，在数据库搜索历史表中找不到。则将用户搜索内容保存在数据库表中
        const data = await mysql('nideshop_search_history').insert({ 
          'user_id': openId,
          'keyword': keyword,
          'add_time': parseInt(new Date().getTime() / 1000)
        })
        // 如果data值存在，说明数据插入成功；否则数据插入失败。
        if (data) { 
          ctx.body = { 
            data: 'success'
          }
        } else { 
          ctx.body = { 
            data: 'fail'
          }
        }
      } else { 
        ctx.body = { 
          data: '已经有记录了'
        }
      }
    }
    
    // 清除历史记录
    async function clearHistoryAction(ctx) { 
    
      // 获取前端传递的用户标识 openId
      const openId = ctx.request.body.openId
    
      const data = await mysql('nideshop_search_history').where({ 
        'user_id': openId
      }).del()
      if (data) { 
        ctx.body = { 
          'data': '清除成功'
        }
      } else { 
        ctx.body = { 
          'data': null
        }
      }
    }
    
    module.exports = { 
      indexAction,
      addHistoryAction,
      clearHistoryAction,
      helperAction
    }

### 1-9：专题 topic / index.js ###

> 专题接口相关的接口：controllers / topic / index.js

const {  mysql } = require('../../mysql')
    
    // 获取专题列表数据
    async function listAction (ctx) { 
    
      // 第一步：获取请求第几页数据（默认第一页）
      let page = ctx.query.page || 1
      // 第二步：每页显示多少条数据
      const size = 5
      // 第三步：分页处理
      const data = await mysql('nideshop_topic').column('id', 'title', 'price_info', 'scene_pic_url', 'subtitle').limit(size).offset((page - 1) * size)
      const data1 = await mysql('nideshop_topic').column('id', 'title', 'price_info', 'subtitle').select()
      // 计算：总页数
      const total = parseInt(data1.length / 5)
    
      ctx.body = { 
        'page': page,
        'total': total,
        'data': data
      }
    }
    
    // 专题详情
    async function detailAction (ctx) { 
    
      // 第一步：获取前端传递的商品专题id
      const id = ctx.query.id
      // 第二步：
      let data = []
      if (id) { 
        data = await mysql('nideshop_topic').where({ 
          'id': id
        }).select()
      }
      const recommendList = await mysql('nideshop_topic').column('id', 'title', 'price_info', 'scene_pic_url', 'subtitle').limit(4).select()
      ctx.body = { 
        'data': data[0],
        'recommendList': recommendList
      }
    }
    
    module.exports = { 
      listAction,
      detailAction
    }

## 2. 路由 routes / index.js ##

// prefix 表示路由前缀
    
    const router = require('koa-router')({ 
      prefix: '/lm'
    })
    const controllers = require('../controllers/index')
    
    // 首页相关的接口
    router.get('/index/index', controllers.home.index)
    
    // 分类相关的接口
    router.get('/category/categoryNav', controllers.category.index.categoryNav)
    router.get('/category/indexaction', controllers.category.index.indexAction)
    router.get('/category/currentaction', controllers.category.index.currentAction)
    
    
    // 搜索相关的接口
    router.get('/search/indexaction', controllers.search.index.indexAction)
    router.post('/search/addhistoryaction', controllers.search.index.addHistoryAction)
    router.post('/search/clearhistoryAction', controllers.search.index.clearHistoryAction) // 清除搜索历史
    router.get('/search/helperaction', controllers.search.index.helperAction) // 搜索提示
    
    // 商品
    router.get('/goods/detailaction', controllers.goods.index.detailAction)
    router.get('/goods/goodsList', controllers.goods.index.goodsList)
    
    
    // 收藏相关的接口
    router.post('/collect/addcollect', controllers.collect.index.addCollect)
    
    
    // 订单相关的接口
    router.post('/order/submitAction', controllers.order.index.submitAction)
    router.get('/order/detailAction', controllers.order.index.detailAction)
    
    
    // 购物车相关的接口
    router.post('cart/addCart', controllers.cart.index.addCart)
    router.get('/cart/cartList', controllers.cart.index.cartList)
    
    
    // 收货地址相关的接口
    router.get('/address/getListAction', controllers.address.index.getListAction)
    router.get('/address/detailAction', controllers.address.index.detailAction)
    router.post('/address/saveAction', controllers.address.index.saveAction)
    
    // 专题接口
    router.get('/topic/listaction', controllers.topic.index.listAction)
    router.get('/topic/detailaction', controllers.topic.index.detailAction)
    
    module.exports = router

## 3. 启动文件 app.js ##

const Koa = require('koa')
    const app = new Koa()
    const bodyParser = require('koa-bodyparser')
    const config = require('./config')
    
    // 解析请求体
    app.use(bodyParser())
    
    const router = require('./routes')
    app.use(router.routes())
    
    app.listen(config.port, () => { 
      console.log(`server is started at port ${ config.port}`)
    })

## 4. 配置文件 config.js ##

const CONF = { 
      port: '5757',
      mysql: { 
        host: 'localhost',
        port: 3306,
        user: 'mpvue_shop',
        db: 'nodemysql',
        pass: 'mpvue_shop123',
        char: 'utf8mb4'
      }
    }
    
    module.exports = CONF

## 5. 数据库 mysql.js ##

// 获取基础配置
    const configs = require('./config')
    
    var knex = require('knex') ({ 
      client: 'mysql',
      connection: { 
        host: configs.mysql.host,
        port: configs.mysql.port,
        user: configs.mysql.user,
        password: configs.mysql.pass,
        database: configs.mysql.db,
      }
    })
    // 将基础配置和sdk.config 合并 导出初始化完成的sdk
    module.exports = {  mysql: knex }

## 6. 网易严选 - 数据库表 ##

> 需要自己手动导入 ,如：`PHPstudy软件`