02 平台管理端基础数据准备&登录实现

今日目标

  • 能够掌握项目中通用异常的处理方式
  • 能够了解前端基础环境搭建
  • 能够完成敏感词管理的开发
  • 能够熟悉常用密码加密方式
  • 能够完成admin端登录功能
  • 能够完成nacos注册中心的搭建

1 通用异常

1.1 什么是通用异常

目前的代码中如果发生系统异常，则直接会给用户抛出不友好的异常信息。为了增加用户的体验，应该给一些适当信息进行提示。例如删除频道的代码，如下
1596090267542.png

目前红框圈起来的是可以给用户友好提示的，但是当执行删除这一行代码，如何失败了该如何处理。有可能系统会抛出异常。那这个时候就不应该把异常信息直接返回给用户。那该如何处理呢？

项目开发中肯定会设置全局异常处理，不管系统发生了任何不可知的异常信息，都应该给用户返回友好提示信息。
1599822964963.png

1.2 通用异常配置

在heima-leadnews-common模块中新建类ExceptionCatch

  1. package com.heima.common.exception;
  3. import com.heima.model.common.dtos.ResponseResult;
  4. import com.heima.model.common.enums.AppHttpCodeEnum;
  5. import lombok.extern.log4j.Log4j2;
  6. import org.springframework.web.bind.annotation.ControllerAdvice;
  7. import org.springframework.web.bind.annotation.ExceptionHandler;
  8. import org.springframework.web.bind.annotation.ResponseBody;
  10. @ControllerAdvice//控制器增强
  11. @Log4j2
  12. public class ExceptionCatch {
  15.     //捕获Exception此类异常
  16.     @ExceptionHandler(Exception.class)
  17.     @ResponseBody
  18.     public ResponseResult exception(Exception exception) {
  19.         exception.printStackTrace();
  20.         //记录日志
  21.         log.error("catch exception:{}", exception.getMessage());
  22.         //返回通用异常
  23.         return ResponseResult.errorResult(AppHttpCodeEnum.SERVER_ERROR);
  24.     }
  25. }

@ControllerAdvice 控制器增强注解

@ExceptionHandler 异常处理器 与上面注解一起使用，可以拦截指定的异常信息

1.3 集成到项目中使用

在heima-leadnews-admin模块中新增类ExceptionCatchConfig

  1. package com.heima.admin.config;
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  6. @Configuration
  7. @ComponentScan("com.heima.common.exception")
  8. public class ExceptionCatchConfig {
  9. }

1.4 测试

如:在删除频道的时候传的id为数值类型，如果不添加全局异常返回如下：
1596091238896.png

添加异常信息以后，返回如下：
1596091108660.png

2 前端相关基础知识（了解）

2.1 webpack

2.1.1 什么是webpack

webpack 是一个现代 JavaScript 应用程序的模块打包器(module bundler)，分析你的项目结构，找到JavaScript模块以及其它的一些浏览器不能直接运行的拓展语言（Sass，TypeScript等），并将其转换和打包为合适的格式供浏览器使用。
webpack是什么.png

2.1.2 webpack安装

注意：请先安装node环境

webpack基于node.js运行，首先需要安装node.js。(须安装)
1583898834079.png

安装webpack

npm install webpack@3.6.0 -g (须安装)

建议大家这样操作(随时切换镜像源)：

  1. npm install nrm -g // 安装nrm
  2. nrm ls // 查看镜像源
  3. nrm use taobao // 选择淘宝镜像，也可以选择cnpm

2.2 vue脚手架(可不做)

vue-cli是官方的一个脚手架工具，所谓脚手架呢就是一个架子，什么架子呢？项目结构的架子，里面有一些最基本的结构配置。利用vue-cli呢，我们可以生成这样的一个脚手架，所以呢它就被称为vue脚手架工具。

npm install vue-cli -g 安装

vue init webpack admin 初始化项目

3.3 导入admin前端工程

使用webstorm工具打开资料中前端项目1599811598575.png

（1）安装js依赖，保证有网络，在项目的根目录执行命令npm install
1599815619023.png

(2)修改文件，暂时不登录

文件的位置：project-heima-leadnews-admin-vue-teacher\src\views\login\index.vue

修改效果如下：
1599815791305.png

（3）启动项目

在package.json文件上右键，选择1599815900388.png

然后双击 dev 就能启动项目了
1599815853706.png

（4）前端项目端口修改

修改文件：project-heima-leadnews-admin-vue-teacher\config\index.js，如下图效果
1599815975087.png

（5）启动成功以后，用浏览器打开，可以测试已开发好的频道功能
1599816103136.png

3 敏感词管理

1584772467927.png1584772487338.png

ad_sensitive 敏感词
1584772681422.png

实体类：

  1. package com.heima.model.admin.pojos;
  3. import com.baomidou.mybatisplus.annotation.IdType;
  4. import com.baomidou.mybatisplus.annotation.TableField;
  5. import com.baomidou.mybatisplus.annotation.TableId;
  6. import com.baomidou.mybatisplus.annotation.TableName;
  7. import lombok.Data;
  9. import java.io.Serializable;
  10. import java.util.Date;
  12. /**
  13.  * <p>
  14.  * 敏感词信息表
  15.  * </p>
  16.  *
  17.  * @author itheima
  18.  */
  19. @Data
  20. @TableName("ad_sensitive")
  21. public class AdSensitive implements Serializable {
  23.     private static final long serialVersionUID = 1L;
  25.     /**
  26.      * 主键
  27.      */
  28.     @TableId(value = "id", type = IdType.AUTO)
  29.     private Integer id;
  31.     /**
  32.      * 敏感词
  33.      */
  34.     @TableField("sensitives")
  35.     private String sensitives;
  37.     /**
  38.      * 创建时间
  39.      */
  40.     @TableField("created_time")
  41.     private Date createdTime;
  43. }

3.1 接口定义

分别要完成敏感词管理的如下功能

  • 敏感词的分页按照关键字模糊查询
  • 敏感词新增
  • 敏感词修改
  • 敏感词删除


在heima-leadnews-apis模块中新建接口com.heima.api.admin.SensitiveControllerApi

分别定义查询，新增，修改，删除方法

  1. package com.heima.apis.admin;
  3. import com.heima.model.admin.dtos.SensitiveDto;
  4. import com.heima.model.admin.pojos.AdSensitive;
  5. import com.heima.model.common.dtos.ResponseResult;
  7. public interface AdSensitiveControllerApi {
  9.     /**
  10.      * 根据名称分页查询敏感词
  11.      * @param dto
  12.      * @return
  13.      */
  14.     public ResponseResult list(SensitiveDto dto);
  16.     /**
  17.      * 新增
  18.      * @param adSensitive
  19.      * @return
  20.      */
  21.     public ResponseResult save(AdSensitive adSensitive);
  23.     /**
  24.      * 修改
  25.      * @param adSensitive
  26.      * @return
  27.      */
  28.     public ResponseResult update(AdSensitive adSensitive);
  30.     /**
  31.      * 删除敏感词
  32.      * @param id
  33.      * @return
  34.      */
  35.     public ResponseResult deleteById(Integer id);
  36. }

SensitiveDto

  1. package com.heima.model.admin.dtos;
  3. import com.heima.model.common.dtos.PageRequestDto;
  4. import lombok.Data;
  6. @Data
  7. public class SensitiveDto extends PageRequestDto {
  9.     /**
  10.      * 敏感词名称
  11.      */
  12.     private String name;
  13. }

3.2 mapper接口

定义敏感词mapper接口：com.heima.admin.mapper.AdSensitiveMapper

  1. package com.heima.admin.mapper;
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import com.heima.model.admin.pojos.AdSensitive;
  5. import org.apache.ibatis.annotations.Mapper;
  7. @Mapper
  8. public interface AdSensitiveMapper extends BaseMapper<AdSensitive> {
  9. }

3.3 业务层

定义敏感词业务接口com.heima.admin.service.AdSensitiveService

  1. package com.heima.admin.service;
  3. import com.baomidou.mybatisplus.extension.service.IService;
  4. import com.heima.model.admin.dtos.SensitiveDto;
  5. import com.heima.model.admin.pojos.AdSensitive;
  6. import com.heima.model.common.dtos.ResponseResult;
  8. public interface AdSensitiveService extends IService<AdSensitive> {
  10.     /**
  11.      * 根据名称分页查询敏感词
  12.      * @param dto
  13.      * @return
  14.      */
  15.     public ResponseResult list(SensitiveDto dto);
  17.     /**
  18.      * 新增
  19.      * @param adSensitive
  20.      * @return
  21.      */
  22.     public ResponseResult insert(AdSensitive adSensitive);
  24.     /**
  25.      * 修改
  26.      * @param adSensitive
  27.      * @return
  28.      */
  29.     public ResponseResult update(AdSensitive adSensitive);
  31.     /**
  32.      * 删除敏感词
  33.      * @param id
  34.      * @return
  35.      */
  36.     public ResponseResult deleteById(Integer id);
  37. }

实现类：

  1. package com.heima.admin.service.impl;
  3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
  4. import com.baomidou.mybatisplus.core.metadata.IPage;
  5. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
  6. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  7. import com.heima.admin.mapper.AdSensitiveMapper;
  8. import com.heima.admin.service.AdSensitiveService;
  9. import com.heima.model.admin.dtos.SensitiveDto;
  10. import com.heima.model.admin.pojos.AdSensitive;
  11. import com.heima.model.common.dtos.PageResponseResult;
  12. import com.heima.model.common.dtos.ResponseResult;
  13. import com.heima.model.common.enums.AppHttpCodeEnum;
  14. import org.apache.commons.lang3.StringUtils;
  15. import org.springframework.stereotype.Service;
  17. import java.util.Date;
  19. @Service
  20. public class AdSensitiveServiceImpl extends ServiceImpl<AdSensitiveMapper, AdSensitive> implements AdSensitiveService {
  22.     @Override
  23.     public ResponseResult list(SensitiveDto dto) {
  24.         //1.检查参数
  25.         if(dto==null){
  26.             return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
  27.         }
  28.         dto.checkParam();
  30.         //2.根据名称模糊分页查询
  31.         Page page = new Page<>(dto.getPage(),dto.getSize());
  32.         LambdaQueryWrapper<AdSensitive> lambdaQueryWrapper = new LambdaQueryWrapper();
  33.         if(StringUtils.isNotBlank(dto.getName())){
  34.             lambdaQueryWrapper.like(AdSensitive::getSensitives,dto.getName());
  35.         }
  37.         IPage result = page(page, lambdaQueryWrapper);
  39.         //3.结果返回
  40.         ResponseResult responseResult = new PageResponseResult(dto.getPage(),dto.getSize(),(int)result.getTotal());
  41.         responseResult.setData(result.getRecords());
  42.         return responseResult;
  43.     }
  45.     @Override
  46.     public ResponseResult insert(AdSensitive adSensitive) {
  47.         //1.参数检查
  48.         if(adSensitive == null){
  49.             return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
  50.         }
  52.         //2.保存
  53.         adSensitive.setCreatedTime(new Date());
  54.         save(adSensitive);
  55.         return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
  56.     }
  58.     @Override
  59.     public ResponseResult update(AdSensitive adSensitive) {
  60.         //1.参数检查
  61.         if(adSensitive == null || adSensitive.getId() == null){
  62.             return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
  63.         }
  65.         //2.修改
  66.         updateById(adSensitive);
  67.         return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
  68.     }
  70.     @Override
  71.     public ResponseResult deleteById(Integer id) {
  72.         //1.参数检查
  73.         if(id == null){
  74.             return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
  75.         }
  76.         //2.判断当前敏感词是否存在
  77.         AdSensitive adSensitive = getById(id);
  78.         if(adSensitive == null){
  79.             return ResponseResult.errorResult(AppHttpCodeEnum.DATA_NOT_EXIST);
  80.         }
  81.         //3.删除操作
  82.         removeById(id);
  83.         return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
  84.     }
  85. }

3.4 控制层

定义com.heima.admin.controller.v1.SensitiveController实现SensitiveControllerApi接口

  1. package com.heima.admin.controller.v1;
  3. import com.heima.admin.service.AdSensitiveService;
  4. import com.heima.apis.admin.AdSensitiveControllerApi;
  5. import com.heima.model.admin.dtos.SensitiveDto;
  6. import com.heima.model.admin.pojos.AdSensitive;
  7. import com.heima.model.common.dtos.ResponseResult;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.web.bind.annotation.*;
  11. @RestController
  12. @RequestMapping("/api/v1/sensitive")
  13. public class AdSensitiveController implements AdSensitiveControllerApi {
  15.     @Autowired
  16.     private AdSensitiveService adSensitiveService;
  18.     @PostMapping("/list")
  19.     @Override
  20.     public ResponseResult list(@RequestBody SensitiveDto dto) {
  21.         return adSensitiveService.list(dto);
  22.     }
  24.     @PostMapping("/save")
  25.     @Override
  26.     public ResponseResult save(@RequestBody AdSensitive adSensitive) {
  27.         return adSensitiveService.insert(adSensitive);
  28.     }
  30.     @PostMapping("/update")
  31.     @Override
  32.     public ResponseResult update(@RequestBody AdSensitive adSensitive) {
  33.         return adSensitiveService.update(adSensitive);
  34.     }
  36.     @DeleteMapping("/del/{id}")
  37.     @Override
  38.     public ResponseResult deleteById(@PathVariable("id") Integer id) {
  39.         return adSensitiveService.deleteById(id);
  40.     }
  41. }

3.5 测试

1584773181498.png

如果集成页面进行测试，请严格按照讲义中的控制层路径进行定义
1599814458026.png

4 常见的加密方式

由于在学习JWT的时候会涉及使用很多加密算法, 所以在这里做下扫盲, 简单了解就可以

加密算法种类有:

4.1.可逆加密算法

解释: 加密后, 密文可以反向解密得到密码原文.

4.1.1. 对称加密

【文件加密和解密使用相同的密钥，即加密密钥也可以用作解密密钥】
1599808731133.png

解释: 在对称加密算法中，数据发信方将明文和加密密钥一起经过特殊的加密算法处理后，使其变成复杂的加密密文发送出去，收信方收到密文后，若想解读出原文，则需要使用加密时用的密钥以及相同加密算法的逆算法对密文进行解密，才能使其回复成可读明文。在对称加密算法中，使用的密钥只有一个，收发双方都使用这个密钥，这就需要解密方事先知道加密密钥。

优点: 对称加密算法的优点是算法公开、计算量小、加密速度快、加密效率高。

缺点: 没有非对称加密安全.

用途： 一般用于保存用户手机号、身份证等敏感但能解密的信息。

常见的对称加密算法有: AES、DES、3DES、Blowfish、IDEA、RC4、RC5、RC6、HS256

4.1.2. 非对称加密

【两个密钥：公开密钥（publickey）和私有密钥，公有密钥加密，私有密钥解密】
1599809661084.png

解释: 同时生成两把密钥：私钥和公钥，私钥隐秘保存，公钥可以下发给信任客户端.

加密与解密:

  • 私钥加密，持有公钥才可以解密
  • 公钥加密，持有私钥才可解密


签名:

  • 私钥签名, 持有公钥进行验证是否被篡改过.


优点: 非对称加密与对称加密相比，其安全性更好；

缺点: 非对称加密的缺点是加密和解密花费时间长、速度慢，只适合对少量数据进行加密。
用途： 一般用于签名和认证。私钥服务器保存, 用来加密, 公钥客户拿着用于对于令牌或者签名的解密或者校验使用.

常见的非对称加密算法有： RSA、DSA（数字签名用）、ECC（移动设备用）、RS256 (采用SHA-256 的 RSA 签名)

4.2.不可逆加密算法

解释: 一旦加密就不能反向解密得到密码原文.

种类: Hash加密算法, 散列算法, 摘要算法等

用途：一般用于效验下载文件正确性，一般在网站上下载文件都能见到；存储用户敏感信息，如密码、 卡号等不可解密的信息。

常见的不可逆加密算法有： MD5、SHA、HMAC

4.3.Base64编码

Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一。Base64编码可用于在HTTP环境下传递较长的标识信息。采用Base64Base64编码解码具有不可读性，即所编码的数据不会被人用肉眼所直接看到。注意：Base64只是一种编码方式，不算加密方法。

在线编码工具：

http://www.jsons.cn/img2base64/

5 密码加密的方式选型

5.1 MD5密码加密

1583919949361.png

  1. //md5加密  DegestUtils：spring框架提供的工具类
  2. String md5Str = DigestUtils.md5DigestAsHex("abc".getBytes());
  3. System.out.println(md5Str);//900150983cd24fb0d6963f7d28e17f72

缺点：md5相同的密码每次加密都一样，不太安全

5.2 手动加密（md5+随机字符串）

在md5的基础上手动加盐（salt）处理

  1. //uername:zhangsan  password:123   salt:随时字符串
  2. String salt = RandomStringUtils.randomAlphanumeric(10);//获取一个10位的随机字符串
  3. System.out.println(salt);
  4. String pswd = "123"+salt;
  6. String saltPswd = DigestUtils.md5DigestAsHex(pswd.getBytes());
  7. System.out.println(saltPswd);

这样同样的密码，加密多次值是不相同的，因为加入了随机字符串

5.3 . BCrypt密码加密

  1. 在用户模块，对于用户密码的保护，通常都会进行加密。我们通常对密码进行加密，然后存放在数据库中，在用户进行登录的时候，将其输入的密码进行加密然后与数据库中存放的密文进行比较，以验证用户密码是否正确。  目前，MD5和BCrypt比较流行。相对来说，BCrypt比MD5更安全。

BCrypt 官网http://www.mindrot.org/projects/jBCrypt/

（1）我们从官网下载源码

（2）新建工程，将源码类BCrypt拷贝到工程

（3）新建测试类，main方法中编写代码，实现对密码的加密

  1. String gensalt = BCrypt.gensalt();//这个是盐  29个字符，随机生成
  2. System.out.println(gensalt);
  3. String password = BCrypt.hashpw("123456", gensalt);  //根据盐对密码进行加密
  4. System.out.println(password);//加密后的字符串前29位就是盐

（4）新建测试类，main方法中编写代码，实现对密码的校验。BCrypt不支持反运算，只支持密码校验。

  1. //解密的代码
  2. boolean checkpw = BCrypt.checkpw("123456",     "$2a$10$61ogZY7EXsMDWeVGQpDq3OBF1.phaUu7.xrwLyWFTOu8woE08zMIW");
  3. System.out.println(checkpw);

6 jwt介绍

6.1 token认证

随着 Restful API、微服务的兴起，基于 Token 的认证现在已经越来越普遍。基于token的用户认证是一种服务端无状态的认证方式，所谓服务端无状态指的token本身包含登录用户所有的相关数据，而客户端在认证后的每次请求都会携带token，因此服务器端无需存放token数据。

  1. 当用户认证后，服务端生成一个token发给客户端，客户端可以放到 cookie 或 localStorage 等存储中，每次请求时带上 token，服务端收到token通过验证后即可确认用户身份。<br />![1596685595899.png](https://cdn.nlark.com/yuque/0/2021/png/12492094/1615794217323-35c46b65-69da-4315-b57f-46c818e82fc1.png#align=left&display=inline&height=429&margin=%5Bobject%20Object%5D&name=1596685595899.png&originHeight=429&originWidth=724&size=20378&status=done&style=none&width=724)

6.2 什么是JWT？

  1. 我们现在了解了基于token认证的交互机制，但令牌里面究竟是什么内容？什么格式呢？市面上基于token的认证方式大都采用的是JWT(Json Web Token)。
  3. JSON Web Token（JWT）是一个开放的行业标准（RFC 7519），它定义了一种简洁的、自包含的协议格式，用于在通信双方传递json对象，传递的信息经过数字签名可以被验证和信任。

JWT令牌结构：

JWT令牌由Header、Payload、Signature三部分组成，每部分中间使用点（.）分隔，比如：xxxxx.yyyyy.zzzzz

  • Header


头部包括令牌的类型（即JWT）及使用的哈希算法（如HMAC、SHA256或RSA）。

一个例子：

  1. {
  2.     "alg": "HS256"，
  3.     "typ": "JWT"
  4. }

将上边的内容使用Base64Url编码，得到一个字符串就是JWT令牌的第一部分。

  • Payload


第二部分是负载，内容也是一个json对象，它是存放有效信息的地方，它可以存放jwt提供的现成字段，比如：iss（签发者），exp（过期时间戳）， sub（面向的用户）等，也可自定义字段。
此部分不建议存放敏感信息，因为此部分可以解码还原原始内容。
一个例子：

  1. {
  2.     "sub": "1234567890"，
  3.     "name": "456"，
  4.     "admin": true
  5. }

最后将第二部分负载使用Base64Url编码，得到一个字符串就是JWT令牌的第二部分。

  • Signature


第三部分是签名，此部分用于防止jwt内容被篡改。
这个部分使用base64url将前两部分进行编码，编码后使用点（.）连接组成字符串，最后使用header中声明
签名算法进行签名。
一个例子：

  1. HMACSHA256(
  2. base64UrlEncode(header) + "." +
  3. base64UrlEncode(payload)，
  4. secret)

base64UrlEncode(header)：jwt令牌的第一部分。
base64UrlEncode(payload)：jwt令牌的第二部分。
secret：签名所使用的密钥。

下图中包含一个生成的jwt令牌：
1581919573856.png

6.3 生成token

需要引入jwt相关依赖

  1. <dependency>
  2.     <groupId>io.jsonwebtoken</groupId>
  3.     <artifactId>jjwt</artifactId>
  4. </dependency>

工具类

  1. package com.heima.utils.common;
  3. import io.jsonwebtoken.*;
  5. import javax.crypto.SecretKey;
  6. import javax.crypto.spec.SecretKeySpec;
  7. import java.util.*;
  9. public class AppJwtUtil {
  11.     // TOKEN的有效期一天（S）
  12.     private static final int TOKEN_TIME_OUT = 3_600;
  13.     // 加密KEY
  14.     private static final String TOKEN_ENCRY_KEY = "MDk4ZjZiY2Q0NjIxZDM3M2NhZGU0ZTgzMjYyN2I0ZjY";
  15.     // 最小刷新间隔(S)
  16.     private static final int REFRESH_TIME = 300;
  18.     // 生产ID（生成token）
  19.     public static String getToken(Long id){
  20.         Map<String, Object> claimMaps = new HashMap<>();
  21.         claimMaps.put("id",id);
  22.         long currentTime = System.currentTimeMillis();
  23.         return Jwts.builder()
  24.                 .setId(UUID.randomUUID().toString())
  25.                 .setIssuedAt(new Date(currentTime))  //签发时间
  26.                 .setSubject("system")  //说明
  27.                 .setIssuer("heima") //签发者信息
  28.                 .setAudience("app")  //接收用户
  29.                 .compressWith(CompressionCodecs.GZIP)  //数据压缩方式
  30.                 .signWith(SignatureAlgorithm.HS512, generalKey()) //加密方式
  31.                 .setExpiration(new Date(currentTime + TOKEN_TIME_OUT * 1000))  //过期时间戳
  32.                 .addClaims(claimMaps) //cla信息
  33.                 .compact();
  34.     }
  36.     /**
  37.      * 获取token中的claims信息
  38.      *
  39.      * @param token
  40.      * @return
  41.      */
  42.     private static Jws<Claims> getJws(String token) {
  43.             return Jwts.parser()
  44.                     .setSigningKey(generalKey())
  45.                     .parseClaimsJws(token);
  46.     }
  48.     /**
  49.      * 获取payload body信息
  50.      *
  51.      * @param token
  52.      * @return
  53.      */
  54.     public static Claims getClaimsBody(String token) {
  55.         try {
  56.             return getJws(token).getBody();
  57.         }catch (ExpiredJwtException e){
  58.             return null;
  59.         }
  60.     }
  62.     /**
  63.      * 获取hearder body信息
  64.      *
  65.      * @param token
  66.      * @return
  67.      */
  68.     public static JwsHeader getHeaderBody(String token) {
  69.         return getJws(token).getHeader();
  70.     }
  72.     /**
  73.      * 是否过期
  74.      *
  75.      * @param claims
  76.      * @return -1：有效，0：有效，1：过期，2：过期
  77.      */
  78.     public static int verifyToken(Claims claims) {
  79.         if(claims==null){
  80.             return 1;
  81.         }
  82.         try {
  83.             claims.getExpiration()
  84.                     .before(new Date());
  85.             // 需要自动刷新TOKEN
  86.             if((claims.getExpiration().getTime()-System.currentTimeMillis())>REFRESH_TIME*1000){
  87.                 return -1;
  88.             }else {
  89.                 return 0;
  90.             }
  91.         } catch (ExpiredJwtException ex) {
  92.             return 1;
  93.         }catch (Exception e){
  94.             return 2;
  95.         }
  96.     }
  98.     /**
  99.      * 由字符串生成加密key
  100.      *
  101.      * @return
  102.      */
  103.     public static SecretKey generalKey() {
  104.         byte[] encodedKey = Base64.getEncoder().encode(TOKEN_ENCRY_KEY.getBytes());
  105.         SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
  106.         return key;
  107.     }
  109.     public static void main(String[] args) {
  110.        /* Map map = new HashMap();
  111.         map.put("id","11");*/
  112.         System.out.println(AppJwtUtil.getToken(1102L));
  113.         Jws<Claims> jws = AppJwtUtil.getJws("eyJhbGciOiJIUzUxMiIsInppcCI6IkdaSVAifQ.H4sIAAAAAAAAADWLQQqEMAwA_5KzhURNt_qb1KZYQSi0wi6Lf9942NsMw3zh6AVW2DYmDGl2WabkZgreCaM6VXzhFBfJMcMARTqsxIG9Z888QLui3e3Tup5Pb81013KKmVzJTGo11nf9n8v4nMUaEY73DzTabjmDAAAA.4SuqQ42IGqCgBai6qd4RaVpVxTlZIWC826QA9kLvt9d-yVUw82gU47HDaSfOzgAcloZedYNNpUcd18Ne8vvjQA");
  114.         Claims claims = jws.getBody();
  115.         System.out.println(claims.get("id"));
  117.     }
  118. }

7 admin端-登录实现

ad_user 运营平台用户信息表
1584805655406.png

对应实体类

  1. package com.heima.model.admin.pojos;
  3. import com.baomidou.mybatisplus.annotation.TableField;
  4. import com.baomidou.mybatisplus.annotation.TableName;
  5. import lombok.Data;
  7. import java.io.Serializable;
  8. import java.util.Date;
  10. /**
  11.  * <p>
  12.  * 管理员用户信息表
  13.  * </p>
  14.  *
  15.  * @author itheima
  16.  */
  17. @Data
  18. @TableName("ad_user")
  19. public class AdUser implements Serializable {
  21.     private static final long serialVersionUID = 1L;
  23.     /**
  24.      * 主键
  25.      */
  26.     private Integer id;
  28.     /**
  29.      * 登录用户名
  30.      */
  31.     @TableField("name")
  32.     private String name;
  34.     /**
  35.      * 登录密码
  36.      */
  37.     @TableField("password")
  38.     private String password;
  40.     /**
  41.      * 盐
  42.      */
  43.     @TableField("salt")
  44.     private String salt;
  46.     /**
  47.      * 昵称
  48.      */
  49.     @TableField("nickname")
  50.     private String nickname;
  52.     /**
  53.      * 头像
  54.      */
  55.     @TableField("image")
  56.     private String image;
  58.     /**
  59.      * 手机号
  60.      */
  61.     @TableField("phone")
  62.     private String phone;
  64.     /**
  65.      * 状态
  66.             0 暂时不可用
  67.             1 永久不可用
  68.             9 正常可用
  69.      */
  70.     @TableField("status")
  71.     private Integer status;
  73.     /**
  74.      * 邮箱
  75.      */
  76.     @TableField("email")
  77.     private String email;
  79.     /**
  80.      * 最后一次登录时间
  81.      */
  82.     @TableField("login_time")
  83.     private Date loginTime;
  85.     /**
  86.      * 创建时间
  87.      */
  88.     @TableField("created_time")
  89.     private Date createdTime;
  91. }

7.1 接口定义

在heima-leadnews-apis中新建:com.heima.api.admin.LoginControllerApi

  1. package com.heima.api.admin;
  3. import com.heima.model.admin.dtos.AdUserDto;
  4. import com.heima.model.admin.pojos.AdUser;
  5. import com.heima.model.common.dtos.ResponseResult;
  6. import org.springframework.web.bind.annotation.RequestBody;
  8. public interface LoginControllerApi {
  10.     /**
  11.      * admin登录功能
  12.      * @param dto
  13.      * @return
  14.      */
  15.     public ResponseResult login(@RequestBody AdUserDto dto);
  16. }

AdUserDto

  1. package com.heima.model.admin.dtos;
  3. import lombok.Data;
  5. @Data
  6. public class AdUserDto {
  8.     //用户名
  9.     private String name;
  11.     //密码
  12.     private String password;
  13. }

7.2 mapper

  1. package com.heima.admin.mapper;
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import com.heima.model.admin.pojos.AdUser;
  6. @Mapper
  7. public interface AdUserMapper extends BaseMapper<AdUser> {
  8. }

7.3 业务层代码

  1. package com.heima.admin.service;
  3. import com.baomidou.mybatisplus.extension.service.IService;
  4. import com.heima.model.admin.dtos.AdUserDto;
  5. import com.heima.model.admin.pojos.AdUser;
  6. import com.heima.model.common.dtos.ResponseResult;
  8. public interface UserLoginService extends IService<AdUser> {
  9.     /**
  10.      * 登录功能
  11.      * @param dto
  12.      * @return
  13.      */
  14.     ResponseResult login(AdUserDto dto);
  15. }

实现类：

  1. package com.heima.admin.service.impl;
  3. import com.baomidou.mybatisplus.core.conditions.Wrapper;
  4. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  5. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  6. import com.google.common.collect.Maps;
  7. import com.heima.admin.mapper.AdUserMapper;
  8. import com.heima.admin.service.UserLoginService;
  9. import com.heima.model.admin.dtos.AdUserDto;
  10. import com.heima.model.admin.pojos.AdUser;
  11. import com.heima.model.common.dtos.ResponseResult;
  12. import com.heima.model.common.enums.AppHttpCodeEnum;
  13. import com.heima.utils.common.AppJwtUtil;
  14. import com.heima.utils.common.MD5Utils;
  15. import org.apache.commons.lang3.StringUtils;
  16. import org.springframework.stereotype.Service;
  17. import org.springframework.transaction.annotation.Transactional;
  18. import org.springframework.util.DigestUtils;
  20. import java.util.List;
  21. import java.util.Map;
  23. @Service
  24. @Transactional
  25. public class UserLoginServiceImpl extends ServiceImpl<AdUserMapper, AdUser> implements UserLoginService {
  26.     @Override
  27.     public ResponseResult login(AdUserDto dto) {
  28.         //1.参数校验
  29.         if (StringUtils.isEmpty(dto.getName()) || StringUtils.isEmpty(dto.getPassword())) {
  30.             return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_REQUIRE, "用户名或密码不能为空");
  31.         }
  32.         Wrapper wrapper = new QueryWrapper<AdUser>();
  33.         ((QueryWrapper) wrapper).eq("name", dto.getName());
  35.         List<AdUser> list = list(wrapper);
  36.         if (list != null && list.size() == 1) {
  37.             AdUser adUser = list.get(0);
  38.             String pswd = DigestUtils.md5DigestAsHex((dto.getPassword() + adUser.getSalt()).getBytes());
  39.             if (adUser.getPassword().equals(pswd)) {
  40.                 Map<String, Object> map = Maps.newHashMap();
  41.                 adUser.setPassword("");
  42.                 adUser.setSalt("");
  43.                 map.put("token", AppJwtUtil.getToken(adUser.getId().longValue()));
  44.                 map.put("user", adUser);
  45.                 return ResponseResult.okResult(map);
  46.             } else {
  47.                 return ResponseResult.errorResult(AppHttpCodeEnum.LOGIN_PASSWORD_ERROR);
  48.             }
  49.         } else {
  50.             return ResponseResult.errorResult(AppHttpCodeEnum.DATA_NOT_EXIST, "用户不存在");
  51.         }
  52.     }
  53. }

7.4 控制层代码

  1. package com.heima.admin.controller.v1;
  3. import com.heima.admin.service.UserLoginService;
  4. import com.heima.apis.admin.LoginControllerApi;
  5. import com.heima.model.admin.dtos.AdUserDto;
  6. import com.heima.model.admin.pojos.AdUser;
  7. import com.heima.model.common.dtos.ResponseResult;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.web.bind.annotation.PostMapping;
  10. import org.springframework.web.bind.annotation.RequestBody;
  11. import org.springframework.web.bind.annotation.RequestMapping;
  12. import org.springframework.web.bind.annotation.RestController;
  14. @RestController
  15. @RequestMapping("/login")
  16. public class LoginController implements LoginControllerApi {
  18.     @Autowired
  19.     private UserLoginService userLoginService ;
  21.     @Override
  22.     @PostMapping("/in")
  23.     public ResponseResult login(@RequestBody AdUserDto dto){
  24.         return userLoginService.login(dto);
  25.     }
  26. }

7.5 测试

在表中创建一个用户guest，使用以下代码生成密码后修改表中的密码

  1. String salt = "123456";
  2. String pswd = "guest"+salt;
  4. String saltPswd = DigestUtils.md5DigestAsHex(pswd.getBytes());
  5. System.out.println(saltPswd);
  6. //34e20b52f5bd120db806e57e27f47ed0

生成密码后的结果为：

salt:123456

password:34e20b52f5bd120db806e57e27f47ed0

username:guest
1596092694393.png

接口工具测试，或者页面直接登录测试

8 spring cloud nacos注册中心搭建

8.1 简介

Nacos是阿里的一个开源产品，它是针对微服务架构中的服务发现、配置管理、服务治理的综合型解决方案。
官方介绍是这样的：

Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您实现动态服务
发现、服务配置管理、服务及流量管理。 Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。
Nacos 是构建以“服务”为中心的现代应用架构的服务基础设施。


官网地址：https://nacos.io

官方文档：https://nacos.io/zh-cn/docs/what-is-nacos.html

Nacos主要提供以下四大功能：

  1. 服务发现与服务健康检查
    Nacos使服务更容易注册，并通过DNS或HTTP接口发现其他服务，Nacos还提供服务的实时健康检查，以防止向不健康的主机或服务实例发送请求。
  2. 动态配置管理
    动态配置服务允许您在所有环境中以集中和动态的方式管理所有服务的配置。Nacos消除了在更新配置时重新
    部署应用程序，这使配置的更改更加高效和灵活。
  3. 动态DNS服务
    Nacos提供基于DNS 协议的服务发现能力，旨在支持异构语言的服务发现，支持将注册在Nacos上的服务以
    域名的方式暴露端点，让三方应用方便的查阅及发现。
  4. 服务和元数据管理
    Nacos 能让您从微服务平台建设的视角管理数据中心的所有服务及元数据，包括管理服务的描述、生命周
    期、服务的静态依赖分析、服务的健康状态、服务的流量管理、路由及安全策略。

8.2 虚拟机镜像准备

1)打开当天资料文件中的镜像，拷贝到一个地方，然后解压

2)解压后，双击ContOS7-hmtt.vmx文件，前提是电脑上已经安装了VMware
1596792250207.png

  1. 修改虚拟网络地址（NAT）

1596792414694.png

①，选中VMware中的编辑

②，选择虚拟网络编辑器

③，找到NAT网卡，把网段改为200（当前挂载的虚拟机已固定ip地址）

④，修改虚拟机的网络模式为NAT,如下图
1596792578018.png

4）启动虚拟机，用户名：root 密码：itcast

可以使用工具连接
1596792717020.png
1596792660411.png

8.3 安装Nacos Server

在liunx下安装nacos必须先安装jdk8+才能运行

可以从https://github.com/alibaba/nacos/releases下载 nacos -server-$version.zip 包
1583941327841.png

或者直接使用资料文件夹下已经提供好的安装包，上传到服务器上，上传服务器Alt+P
1596811995550.png

下载后解压：

  1. unzip nacos‐server‐$version.zip 
  2. 或者 
  3. tar ‐xvf nacos‐server‐$version.tar.gz

进入安装程序的bin目录：

  1. sh startup.sh  -m standalone

如果您使用的是ubuntu系统，或者运行脚本报错提示[[符号找不到，可尝试如下运行：

  1. bash startup.sh  -m standalone

如果是Windows，启动命令：

  1. cmd startup.cmd  或者双击  startup.cmd 运行文件

启动成功，可通过浏览器访问 http://192.168.200.130:8848/nacos ，打开如下nacos控制台登录页面：
1585845952326.png

8.4 注册服务

在admin微服务中加入依赖

  1. <dependency>
  2.     <groupId>com.alibaba.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  4. </dependency>

在admin微服务中的application.yml文件中加入配置

  1. spring:
  2.   cloud:
  3.     nacos:
  4.       discovery:
  5.         server-addr: 192.168.200.130:8848

引导类中加上注解@EnableDiscoveryClient可以让该服务注册到nacos注册中心上去

启动admin微服务，启动nacos，可以查看到admin服务已经在服务列表中了