黑马程序员《苍穹外卖》笔记（主后端）2

​

一、redis

1.1.1 五种常用数据类型介绍

redis存储是key-value结构的数据，其中key是字符串类型，value有5种常用的数据类型：

• 字符串 string

• 哈希 hash

• 列表 list

• 集合 set

• 有序集合 sorted set / zset

1.1.2 各种数据类型的特点

• 字符串（string）：普通字符串，redis中最简单的数据类型

• 哈希（hash）：也叫散列，类似于Java中的HashMap结构

• 列表（list）：按照插入顺序排序，可以有重复元素，类似于Java中的linkedList

• 集合（set）：无序集合，没有重复元素，类似于Java中的hash Set

• 有序集合（sorted set / zset）：集合中每个元素关联一个分数（score），根据分数升序排序，没有重复元素

1.2redis常用命令

1.2.1 字符串操作命令

redis 字符串类型常用命令：

• SET key value 设置指定key的值

• GET key 获取指定key的值

• SETEX key seconds value 设置指定key的值，并将key的过去过期时间设为seconds秒

• SETNX key value 只有在key不存在时设置key的值

1.2.2 哈希操作命令

redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象，常用命令：

• HSET key field value 将哈希表key中的字段field 的值设为value

• HGET key field 获取存储在哈希表中指定字段的值

• HDEL key field 删除存储在哈希表中的指定字段

• HKEYS key 获取哈希表中所有字段

• HVALS key 获取哈希表中听所有值

1.2.3 列表操作命令

Redis 列表是简单的字符串列表，按照插入顺序排序，常用命令：

• LPUSH key value1 [value2] 将一个或多个值插入到列表头部

• LRANGE key start stop 获取列表指定范围内的元素

• RPOP key 移除并获取列表最后一个元素

• LLEN key 获取列表长度

1.2.4 集合操作命令

Redis set 是string类型的无序集合。集合成员是唯一的，集合中不能出现重复的数据，常用命令：

• SADD key member1 [member2] 向集合添加一个或多个成员

• SMEMBERS key 返回集合中的所有成员

• SCARD key 获取集合的成员数

• SINTER key1 [key2] 返回给定所有集合的交集

• SUNION key1 [key2] 返回所有给定集合的并集

• SREM key member1 [member2] 删除集合中一个或多个成员

1.2.5 有序集合操作命令

Redis有序集合是string类型元素的集合，且不允许有重复成员。每个元素都会关联一个double类型的分数。常用命令：

• ZADD key score1 member1 [score2 member2] 向有序集合添加一个或多个成员

• ZRANGE key start stop [WITHSCORES] 通过索引区间返回有序集合中指定区间内的成员

• ZINCRBY key increment member 有序集合中对指定成员的分数加上增量increment

• ZREM key member [member…] 移除有序集合中的一个或多个成员

1.2.6 通用命令

Redis 的通用命令是不分数据类型的，都可以使用命令

• KEYS pattern 查找所有符合给定模式（pattern）的key

• EXⅠSTS key 检查指定key是否存在

• TYPE key 返回key所储存的值的类型

• DEL key 该命令用于在key存在是删除key

1.3 在Java中操作redis

• Redis的Java客户端

Redis 的Java客户端有很多，常用的几种：

    1. Jedis

    2. Lettuce

    3. Spting Data Redis

Spring Data Redis是Spring的一部分，对Redis底层开发包进行了高度封装，在Spring项目中，可以使用Spring Data Redis来简化操作。

• Spring Data Redis 使用方法

操作步骤：

    1. 导入Spring Data Redis的Maven坐标

（pom.xml）

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

    2. 配置Redis数据源

(application.yml)

  redis:
    host: localhost
    port: 6379
    password: xxxxxx
    database: 0

    3. 编写配置类，创建RedisTemplate 对象

（config）

@Configuration
@Slf4j
public class RedisConfiguration {
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
        log.info("开始创建redis模版对象...");
        RedisTemplate redisTemplate = new RedisTemplate();

        //设置redis的连接工厂对象
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        //设置redis key的序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

    4.通过RedisTemplate对象操作Redis

＃＃ 二、店铺营业状态设置

2.1需求分析设计

接口设计：

• 设置营业状态

• 管理端查询营业状态

• 用户端查询营业状态

本项月约定：

-管理端发出的请求，统一使用/admin作为前缀

• 用户端发出的请求，统一使用/user作为前缀

2.2 代码开发

controller层

ShopController

 @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 设置店铺营业状态
     * @param status
     * @return
     */
    @PutMapping("{status}")
    @ApiOperation("设置店铺营业状态")
    public Result setStatus(@PathVariable Integer status){
        log.info("设置店铺营业状态为：{}",status == 1 ? "营业中" : "已打烊");
        redisTemplate.opsForValue().set("SHOP_STATUS",status);
        return Result.success();
    }

    @GetMapping("/status")
    @ApiOperation("获取店铺营业状态")
    public Result<Integer> getStatus(){
        Integer status = (Integer) redisTemplate.opsForValue().get("SHOP_STATUS");
        log.info("获取店铺营业状态为：{}",status == 1 ? "营业中" : "已打烊");
        return Result.success(status);
    }

三、微信登录、商品浏览

1. HttpClient

• 介绍
  HttpClient 是Apache Jakarta Common下的子项目，可以用来提供高效的，最新的，功能丰富的支持Http协议
  的客户端编程工具包，并且它支持Http协议最新的版本和建议。

核心API：

• HttpClient
• HttpClients
• CloseableHttpClient
• HttpGet
• HttpPost

发送请求步骤：

• 创建HttpClient对象
• 创建Http请求对象
• 调用HttpClient的execute方法发送请求

HttpClient的作用：在Java程序中通过编码的方式来发送Http请求

• 入门案例

1. GET请求

/**
     * 测试通过httpClient 发送GET方式的请求
     */
    @Test
    public void testGET() throws Exception{
        //创建httpClient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();

        //创建请求对象
        HttpGet httpGet = new HttpGet("http://localhost:8080/user/shop/status");

        //发送请求,接收响应结果
        CloseableHttpResponse response = httpClient.execute(httpGet);

        //获取服务端返回的状态码
        int statusCode = response.getStatusLine().getStatusCode();
        System.out.println("服务端返回的状态码为：" + statusCode);

        HttpEntity entity = response.getEntity();
        String body = EntityUtils.toString(entity);
        System.out.println("服务端返回的数据为：" + body);

        //关闭资源
        response.close();
        httpClient.close();
    }

测试结果：

1.1 POST请求

/**
     * 测试通过httpClient 发送POST方式的请求
     */
    @Test
    public void testPOST() throws Exception{
        //创建httpClient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();

        //创建请求对象
        HttpPost httpPost = new HttpPost("http://localhost:8080/admin/employee/login");

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("username","admin");
        jsonObject.put("password","123456");

        StringEntity entity = new StringEntity(jsonObject.toString());

        //指定请求编码方式
        entity.setContentEncoding("utf-8");

        //数据格式
        entity.setContentType("application/json");
        httpPost.setEntity(entity);

        //发送请求
        CloseableHttpResponse response = httpClient.execute(httpPost);

        //解析返回结果
        int statusCode = response.getStatusLine().getStatusCode();
        System.out.println("服务端返回的状态码为：" + statusCode);

        HttpEntity entity1 = response.getEntity();
        String body = EntityUtils.toString(entity1);
        System.out.println("服务端返回的数据为：" + body);

        //关闭资源
        response.close();
        httpClient.close();
    }

测试结果：

Http工具类

/**
 * Http工具类
 */
public class HttpClientUtil {

    static final  int TIMEOUT_MSEC = 5 * 1000;

    /**
     * 发送GET方式请求
     * @param url
     * @param paramMap
     * @return
     */
    public static String doGet(String url,Map<String,String> paramMap){
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();

        String result = "";
        CloseableHttpResponse response = null;

        try{
            URIBuilder builder = new URIBuilder(url);
            if(paramMap != null){
                for (String key : paramMap.keySet()) {
                    builder.addParameter(key,paramMap.get(key));
                }
            }
            URI uri = builder.build();

            //创建GET请求
            HttpGet httpGet = new HttpGet(uri);

            //发送请求
            response = httpClient.execute(httpGet);

            //判断响应状态
            if(response.getStatusLine().getStatusCode() == 200){
                result = EntityUtils.toString(response.getEntity(),"UTF-8");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                response.close();
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return result;
    }

    /**
     * 发送POST方式请求
     * @param url
     * @param paramMap
     * @return
     * @throws IOException
     */
    public static String doPost(String url, Map<String, String> paramMap) throws IOException {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";

        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);

            // 创建参数列表
            if (paramMap != null) {
                List<NameValuePair> paramList = new ArrayList();
                for (Map.Entry<String, String> param : paramMap.entrySet()) {
                    paramList.add(new BasicNameValuePair(param.getKey(), param.getValue()));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
                httpPost.setEntity(entity);
            }

            httpPost.setConfig(builderRequestConfig());

            // 执行http请求
            response = httpClient.execute(httpPost);

            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            throw e;
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    /**
     * 发送POST方式请求
     * @param url
     * @param paramMap
     * @return
     * @throws IOException
     */
    public static String doPost4Json(String url, Map<String, String> paramMap) throws IOException {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";

        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);

            if (paramMap != null) {
                //构造json格式数据
                JSONObject jsonObject = new JSONObject();
                for (Map.Entry<String, String> param : paramMap.entrySet()) {
                    jsonObject.put(param.getKey(),param.getValue());
                }
                StringEntity entity = new StringEntity(jsonObject.toString(),"utf-8");
                //设置请求编码
                entity.setContentEncoding("utf-8");
                //设置数据类型
                entity.setContentType("application/json");
                httpPost.setEntity(entity);
            }

            httpPost.setConfig(builderRequestConfig());

            // 执行http请求
            response = httpClient.execute(httpPost);

            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            throw e;
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }
    private static RequestConfig builderRequestConfig() {
        return RequestConfig.custom()
                .setConnectTimeout(TIMEOUT_MSEC)
                .setConnectionRequestTimeout(TIMEOUT_MSEC)
                .setSocketTimeout(TIMEOUT_MSEC).build();
    }

}

2. 微信小程序开发

• 介绍
  小程序是一种新的开放能力，开发者可以快速地开发一个小程序。可以在微信内被便捷地获取和传播，同时具有出色的使用体验。
  
  小程序主要运行微信内部，可通过上述网站来整体了解微信小程序的开发。

在开发前，需要先去注册一个小程序



2.1 准备工作：
开发微信小程序之前需要做如下准备工作：

• 注册小程序 （地址：https://mp.weixin.qq.com/cgi-bin/wx?lang=zh_CN&token=）
  !
  

完善小程序信息、小程序类目
查看小程序的 AppID

2.2 下载开发者工具
下载地址：https://developers.weixin.qq.com/miniprogram/dev/devtools/stable.html

扫描登录开发者工具

创建小程序

熟悉开发者工具布局

设置不校验合法域名

注：开发阶段，小程序发出请求到后端的Tomcat服务器，若不勾选，请求发送失败。

2.3 入门案例
2.3.1操作步骤：

• 了解小程序目录结构
  小程序包含一个描述整体程序的app和对歌描述各自页面的page。
  一个小程序主体部分由三个文件组成，必须放在项目的根目录，如下：
  
  文件说明：
  
  app.js：必须存在，主要存放小程序的逻辑代码

app.json：必须存在，小程序配置文件，主要存放小程序的公共配置

app.wxss: 非必须存在，主要存放小程序公共样式表，类似于前端的CSS样式
对小程序主体三个文件了解后，其实一个小程序又有多个页面。比如说，有商品浏览页面、购物车的页面、订单支付的页面、商品的详情页面等等。那这些页面会放在哪呢？

会存放在pages目录。

每个小程序页面主要由四个文件组成：

文件说明：

js文件：必须存在，存放页面业务逻辑代码，编写的js代码。

wxml文件：必须存在，存放页面结构，主要是做页面布局，页面效果展示的，类似于HTML页面。

json文件：非必须，存放页面相关的配置。

wxss文件：非必须，存放页面样式表，相当于CSS文件。

- 编写和编译小程序
编写入门程序

1. 获取用户名和头像
   进入到index.wxml，编写页面布局

<!--index.wxml-->
<navigation-bar title="苍穹外卖" back="{{false}}" color="black" background="#FFF"></navigation-bar>
<scroll-view class="scrollarea" scroll-y type="list">
  <view class="container">
    {{msg}}
  </view>
  <view>
    <button type="primary" bind:tap="getUserInfo">获取用户信息</button>
    昵称：{{nickName}}
    头像：<image src="{{avatarUrl}}" style="width: 100px; height: 100px;"></image>
  </view>
</scroll-view>

进入到index.js，编写业务逻辑代码

// index.js
Page({
  data:{
      msg:'中村百合香',
      nickName:'',
      avatarUrl:''
  },
  //获取微信用户的头像和昵称
  getUserInfo(){
    wx.getUserProfile({
      desc: '获取用户信息',
      success:(res) =>{
        console.info(res.userInfo)
        //为数据赋值
        this.setData({
          nickName:res.userInfo.nickName,
          avatarUrl:res.userInfo.avatarUrl
        })
      }
    })
  }
})

点击获取用户信息效果如下：

注：点击获取用户信息可能会出现不能弹框的情况，可降低版本号解决

2. 获取微信授权码
   index.wxml

<view>
    <button type="warn" bind:tap="wxLogin">微信登录</button>
    授权码：{{code}}
  </view>

index.js

  //获取微信授权码
  wxLogin(){
    wx.login({
      success: (res) => {
        console.info(res.code)
        this.setData({
          code:res.code
        })
      },
    })
  }
})

效果如下：

编译

点击发送请求
注：需要先启动后端项目和redis服务

发布小程序
小程序的代码都已经开发完毕，要将小程序发布上线，让所有的用户都能使用到这个小程序。

点击上传按钮，输入版本号和备注：

上传成功：

上传成功不代表小程序就已经发布了
还需要进入微信公众平台提交审核

需提交审核，变成审核版本，审核通过后，进行发布，变成线上版本。

一旦成为线上版本，这就说明小程序就已经发布上线了，微信用户就可以在微信里面去搜索和使用这个小程序了。

3. 微信登录

3.1 导入小程序代码
开发微信小程序，本质上是属于前端的开发，我们的重点其实还是后端代码开发。所以，小程序的代码已经提供好了，直接导入到微信开发者工具当中，直接来使用就可以了。
1）找到资料

2）导入代码

3）查看项目结构
主体的文件:app.js app.json app.wxss

项目的页面比较多，主要存放在pages目录。

4) 修改配置

因为小程序要请求后端服务，需要修改为自己后端服务的ip地址和端口号(默认不需要修改)

3.2 微信登录流程
微信登录：小程序登录 | 微信开放文档

流程图：

步骤分析：

1. 小程序端，调用wx.login()获取code，就是授权码。
2. 小程序端，调用wx.request()发送请求并携带code，请求开发者服务器(自己编写的后端服务)。
3. 开发者服务端，通过HttpClient向微信接口服务发送请求，并携带appId+appsecret+code三个参数。
4. 开发者服务端，接收微信接口服务返回的数据，session_key+opendId等。opendId是微信用户的唯一标识。
5. 开发者服务端，自定义登录态，生成令牌(token)和openid等数据返回给小程序端，方便后绪请求身份校验。
6. 小程序端，收到自定义登录态，存储storage。
7. 小程序端，后绪通过wx.request()发起业务请求时，携带token。
8. 开发者服务端，收到请求后，通过携带的token，解析当前登录用户的id。
9. 开发者服务端，身份校验通过后，继续相关的业务逻辑处理，最终返回业务数据。

接下来，我们使用Postman进行测试。

说明：

调用 wx.login() 获取 临时登录凭证code ，并回传到开发者服务器。
调用 auth.code2Session 接口，换取 用户唯一标识 OpenID 、 用户在微信开放平台帐号下的唯一标识UnionID（若当前小程序已绑定到微信开放平台帐号） 和 会话密钥 session_key。
之后开发者服务器可以根据用户标识来生成自定义登录态，用于后续业务逻辑中前后端交互时识别用户身份。

实现步骤：

1. 获取授权码
   点击确定按钮，获取授权码，每个授权码只能使用一次，每次测试，需重新获取。
   
   获取授权码
   

2. 明确请求接口

请求方式、请求路径、请求参数

3). 发送请求
获取session_key和openid

若出现code been used错误提示，说明授权码已被使用过，请重新获取

3.3 需求分析和设计
3.3.1 产品原型
用户进入到小程序的时候，微信授权登录之后才能点餐。需要获取当前微信用户的相关信息，比如昵称、头像等，这样才能够进入到小程序进行下单操作。是基于微信登录来实现小程序的登录功能，没有采用传统账户密码登录的方式。若第一次使用小程序来点餐，就是一个新用户，需要把这个新的用户保存到数据库当中完成自动注册。

登录功能原型图：

业务规则：

基于微信登录实现小程序的登录功能
如果是新用户需要自动完成注册

3.3.2 接口设计
通过微信登录的流程，如果要完成微信登录的话，最终就要获得微信用户的openid。在小程序端获取授权码后，向后端服务发送请求，并携带授权码，这样后端服务在收到授权码后，就可以去请求微信接口服务。最终，后端向小程序返回openid和token等数据。

基于上述的登录流程，就可以设计出该接口的请求参数和返回数据。


说明： 请求路径/user/user/login,第一个user代表用户端，第二个user代表用户模块。

3.3.3 表设计
当用户第一次使用小程序时，会完成自动注册，把用户信息存储到user表中。

字段名	数据类型	说明	备注
id	bigint	主键	自增
openid	vachar(45)	微信用户的唯一标示
name	vachar(32)	用户姓名
phone	vachar(11)	手机号
sex	vachar(2)	性别
id_number	vachar(18)	身份证号
avatar	vachar(500)	微信用户头像路径
create_time	datetime	注册时间

说明： 手机号字段比较特殊，个人身份注册的小程序没有权限获取到微信用户的手机号。如果是以企业的资质注册的小程序就能够拿到微信用户的手机号。

3.4 代码开发
3.4.1 定义相关配置
配置微信登录所需配置项：

application-dev.yml

application.yml

配置为微信用户生成jwt令牌时使用的配置项：

application.yml

3.4.2 DTO设计
根据传入参数设计DTO类：

在sky-pojo模块，UserLoginDTO.java已定义

package com.sky.dto;
 
import lombok.Data;
 
import java.io.Serializable;
 
/**
 * C端用户登录
 */
@Data
public class UserLoginDTO implements Serializable {
 
    private String code;
 
}

3.4.3 VO设计
根据返回数据设计VO类：

在sky-pojo模块，UserLoginVO.java已定义

package com.sky.vo;
 
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
 
import java.io.Serializable;
 
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UserLoginVO implements Serializable {
 
    private Long id;
    private String openid;
    private String token;
 
}

3.4.4 Controller层
根据接口定义创建UserController的login方法：

package com.sky.controller.user;

import com.sky.constant.JwtClaimsConstant;
import com.sky.dto.UserLoginDTO;
import com.sky.entity.User;
import com.sky.properties.JwtProperties;
import com.sky.result.Result;
import com.sky.service.UserService;
import com.sky.utils.JwtUtil;
import com.sky.vo.UserLoginVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;

@RestController
@Slf4j
@RequestMapping("/user/user")
@Api(tags = "C端用户相关接口")
public class UserController {

    @Autowired
    private UserService userService;
    @Autowired
    private JwtProperties jwtProperties;

    /**
     * 微信登录
     * @param userLoginDTO
     * @return
     */
    @PostMapping("login")
    @ApiOperation("用户登录")
    public Result<UserLoginVO> wxLogin(@RequestBody UserLoginDTO userLoginDTO){
        log.info("微信用户登录：{}",userLoginDTO.getCode());
        //微信登录
        User user = userService.wxLogin(userLoginDTO);//后绪步骤实现

        //为微信用户生成jwt令牌
        Map<String, Object> claims = new HashMap<>();
        claims.put(JwtClaimsConstant.USER_ID,user.getId());
        String token = JwtUtil.createJWT(jwtProperties.getUserSecretKey(), jwtProperties.getUserTtl(), claims);

        UserLoginVO userLoginVO = UserLoginVO.builder()
                .id(user.getId())
                .openid(user.getOpenid())
                .token(token)
                .build();
        return Result.success(userLoginVO);
    }
}

其中，JwtClaimsConstant.USER_ID常量已定义。

3.4.5 Service层接口
创建UserService接口：

package com.sky.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.sky.constant.MessageConstant;
import com.sky.dto.UserLoginDTO;
import com.sky.entity.User;
import com.sky.exception.LoginFailedException;
import com.sky.mapper.UserMapper;
import com.sky.properties.WeChatProperties;
import com.sky.service.UserService;
import com.sky.utils.HttpClientUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;

@Service
public class UserServiceImpl implements UserService {

    //微信服务接口地址
    public static final String WX_LOGIN= "https://api.weixin.qq.com/sns/jscode2session";

    @Autowired
    private WeChatProperties weChatProperties;
    @Autowired
    private UserMapper userMapper;

    /**
     * 微信登录
     * @param userLoginDTO
     * @return
     */
    public User wxLogin(UserLoginDTO userLoginDTO) {

        String openid = getOpenid(userLoginDTO.getCode());
        //判断openid是否为空，如果为空表示登录失败，抛出业务异常
        if (openid == null) {
            throw new LoginFailedException(MessageConstant.LOGIN_FAILED);
        }

        //判断当前用户是否是新用户
        User user = userMapper.getByOpenid(openid);

        //如果是新用户，自动完成注册
        if (user == null) {
            user = User.builder()
                    .openid(openid)
                    .createTime(LocalDateTime.now())
                    .build();
            userMapper.insert(user);
        }
        //返回这个用户对象
        return user;
    }

    /**
     * 调用微信接口服务，获取微信用户的openid
     * @param code
     * @return
     */
    private String getOpenid(String code){
        //调用微信接口服务，获得当前微信用户的openid
        Map<String, String> map = new HashMap<>();
        map.put("appid",weChatProperties.getAppid());
        map.put("secret",weChatProperties.getSecret());
        map.put("js_code",code);
        map.put("grant_type","authorization_code");
        String json = HttpClientUtil.doGet(WX_LOGIN, map);

        JSONObject jsonObject = JSON.parseObject(json);
        String openid = jsonObject.getString("openid");
        return openid;
    }
}

3.4.7 Mapper层
创建UserMapper接口：

package com.sky.mapper;

import com.sky.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface UserMapper {

    /**
     * 根据openid查询用户
     * @param openid
     * @return
     */
    @Select("select * from user where openid = #{openid}")
    User getByOpenid(String openid);

	 /**
     * 插入数据
     * @param user
     */
     void insert(User user);
}

创建UserMapper.xml映射文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.sky.mapper.UserMapper">
    <insert id="insert" useGeneratedKeys="true" keyProperty="id">
        insert into user (openid,name,phone,sex,id_number,avatar,create_time)
        values
        (#{openid},#{name},#{phone},#{sex},#{idNumber},#{avatar},#{createTime})
    </insert>
</mapper>

3.4.8 编写拦截器
编写拦截器JwtTokenUserInterceptor： 统一拦截用户端发送的请求并进行jwt校验

package com.sky.interceptor;

import com.sky.constant.JwtClaimsConstant;
import com.sky.context.BaseContext;
import com.sky.properties.JwtProperties;
import com.sky.utils.JwtUtil;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * jwt令牌校验的拦截器
 */
@Component
@Slf4j
public class JwtTokenUserInterceptor implements HandlerInterceptor {

    @Autowired
    private JwtProperties jwtProperties;

    /**
     * 校验jwt
     *
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //判断当前拦截到的是Controller的方法还是其他资源
        //是Controller的资源就拦截，不是就放行
        if (!(handler instanceof HandlerMethod)) {
            //当前拦截到的不是动态方法，直接放行
            return true;
        }

        //1、从请求头中获取令牌
        String token = request.getHeader(jwtProperties.getUserTokenName());

        //2、校验令牌
        try {
            log.info("jwt校验:{}", token);
            Claims claims = JwtUtil.parseJWT(jwtProperties.getUserSecretKey(), token);
            Long userId = Long.valueOf(claims.get(JwtClaimsConstant.USER_ID).toString());
            BaseContext.setCurrentId(userId);
            log.info("当前用户id：", userId);
            //3、通过，放行
            return true;
        } catch (Exception ex) {
            //4、不通过，响应401状态码
            response.setStatus(401);
            return false;
        }
    }
}

在WebMvcConfiguration配置类中注册拦截器：

    /**
     * 注册自定义拦截器
     * @param registry
     */
    protected void addInterceptors(InterceptorRegistry registry) {
        log.info("开始注册自定义拦截器...");
        //addInterceptor 指定要加入的是哪个拦截器
        //.............
        registry.addInterceptor(jwtTokenUserInterceptor)
                .addPathPatterns("/user/**")
                .excludePathPatterns("/user/user/login")
                .excludePathPatterns("/user/shop/status");
    }

3.5 功能测试
重新编译小程序，进行登录，获取到openid和token数据

查看后台日志

查看数据库user表，第一次登录，会自动注册

4. 导入商品浏览功能代码
4.1 需求分析和设计
4.1.1 产品原型

4.2 代码导入
导入资料中的商品浏览功能代码即可
资料 - day06 - 代码导入 -商品浏览
可按照mapper–>service–>controller依次导入，这样代码不会显示相应的报错。

进入到sky-server模块中
4.2.1 Mapper层
在SetmealMapper.java中添加list和getDishItemBySetmealId两个方法

package com.sky.mapper;

import com.sky.entity.Setmeal;
import com.sky.vo.DishItemVO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.List;

@Mapper
public interface SetmealMapper {
    /**
     * 动态条件查询套餐
     * @param setmeal
     * @return
     */
    List<Setmeal> list(Setmeal setmeal);

    /**
     * 根据套餐id查询菜品选项
     * @param setmealId
     * @return
     */
    @Select("select sd.name, sd.copies, d.image, d.description " +
            "from setmeal_dish sd left join dish d on sd.dish_id = d.id " +
            "where sd.setmeal_id = #{setmealId}")
    List<DishItemVO> getDishItemBySetmealId(Long setmealId);
}

创建SetmealMapper.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.sky.mapper.SetmealMapper">
 
    <select id="list" parameterType="Setmeal" resultType="Setmeal">
        select * from setmeal
        <where>
            <if test="name != null">
                and name like concat('%',#{name},'%')
            </if>
            <if test="categoryId != null">
                and category_id = #{categoryId}
            </if>
            <if test="status != null">
                and status = #{status}
            </if>
        </where>
    </select>
</mapper>

4.2.2 Service层
创建SetmealService.java

package com.sky.service;
 
import com.sky.dto.SetmealDTO;
import com.sky.dto.SetmealPageQueryDTO;
import com.sky.entity.Setmeal;
import com.sky.result.PageResult;
import com.sky.vo.DishItemVO;
import com.sky.vo.SetmealVO;
import java.util.List;
 
public interface SetmealService {
 
    /**
     * 条件查询
     * @param setmeal
     * @return
     */
    List<Setmeal> list(Setmeal setmeal);
 
    /**
     * 根据id查询菜品选项
     * @param id
     * @return
     */
    List<DishItemVO> getDishItemById(Long id);
 
}

创建SetmealServiceImpl.java

package com.sky.service.impl;
 
import java.util.List;
 
/**
 * 套餐业务实现
 */
@Service
@Slf4j
public class SetmealServiceImpl implements SetmealService {
 
    @Autowired
    private SetmealMapper setmealMapper;
    @Autowired
    private SetmealDishMapper setmealDishMapper;
    @Autowired
    private DishMapper dishMapper;
 
    /**
     * 条件查询
     * @param setmeal
     * @return
     */
    public List<Setmeal> list(Setmeal setmeal) {
        List<Setmeal> list = setmealMapper.list(setmeal);
        return list;
    }
 
    /**
     * 根据id查询菜品选项
     * @param id
     * @return
     */
    public List<DishItemVO> getDishItemById(Long id) {
        return setmealMapper.getDishItemBySetmealId(id);
    }
}

在DishService.java中添加listWithFlavor方法定义

	/**
     * 条件查询菜品和口味
     * @param dish
     * @return
     */
    List<DishVO> listWithFlavor(Dish dish);

在DishServiceImpl.java中实现listWithFlavor方法

	/**
     * 条件查询菜品和口味
     * @param dish
     * @return
     */
    public List<DishVO> listWithFlavor(Dish dish) {
        List<Dish> dishList = dishMapper.list(dish);
 
        List<DishVO> dishVOList = new ArrayList<>();
 
        for (Dish d : dishList) {
            DishVO dishVO = new DishVO();
            BeanUtils.copyProperties(d,dishVO);
 
            //根据菜品id查询对应的口味
            List<DishFlavor> flavors = dishFlavorMapper.getByDishId(d.getId());
 
            dishVO.setFlavors(flavors);
            dishVOList.add(dishVO);
        }
 
        return dishVOList;
    }

4.2.3 Controller层
创建DishController.java

package com.sky.controller.user;
 
import java.util.List;
 
@RestController("userDishController")
@RequestMapping("/user/dish")
@Slf4j
@Api(tags = "C端-菜品浏览接口")
public class DishController {
    @Autowired
    private DishService dishService;
 
    /**
     * 根据分类id查询菜品
     *
     * @param categoryId
     * @return
     */
    @GetMapping("/list")
    @ApiOperation("根据分类id查询菜品")
    public Result<List<DishVO>> list(Long categoryId) {
        Dish dish = new Dish();
        dish.setCategoryId(categoryId);
        dish.setStatus(StatusConstant.ENABLE);//查询起售中的菜品
 
        List<DishVO> list = dishService.listWithFlavor(dish);
 
        return Result.success(list);
    }
 
}

创建CategoryController.java

package com.sky.controller.user;
 
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
 
@RestController("userCategoryController")
@RequestMapping("/user/category")
@Api(tags = "C端-分类接口")
public class CategoryController {
 
    @Autowired
    private CategoryService categoryService;
 
    /**
     * 查询分类
     * @param type
     * @return
     */
    @GetMapping("/list")
    @ApiOperation("查询分类")
    public Result<List<Category>> list(Integer type) {
        List<Category> list = categoryService.list(type);
        return Result.success(list);
    }
}

创建SetmealController.java

package com.sky.controller.user;
 
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
 
@RestController("userSetmealController")
@RequestMapping("/user/setmeal")
@Api(tags = "C端-套餐浏览接口")
public class SetmealController {
    @Autowired
    private SetmealService setmealService;
 
    /**
     * 条件查询
     *
     * @param categoryId
     * @return
     */
    @GetMapping("/list")
    @ApiOperation("根据分类id查询套餐")
    public Result<List<Setmeal>> list(Long categoryId) {
        Setmeal setmeal = new Setmeal();
        setmeal.setCategoryId(categoryId);
        setmeal.setStatus(StatusConstant.ENABLE);
 
        List<Setmeal> list = setmealService.list(setmeal);
        return Result.success(list);
    }
 
    /**
     * 根据套餐id查询包含的菜品列表
     *
     * @param id
     * @return
     */
    @GetMapping("/dish/{id}")
    @ApiOperation("根据套餐id查询包含的菜品列表")
    public Result<List<DishItemVO>> dishList(@PathVariable("id") Long id) {
        List<DishItemVO> list = setmealService.getDishItemById(id);
        return Result.success(list);
    }
}

4.3 功能测试
重启服务器、重新编译小程序

微信登录进入首页

菜品和套餐分类查询：

具体分类下的菜品查询：

菜品口味查询：

4. 导入商品浏览功能代码

​