目录

需求分析

页面原型展示

• 找到项目资源 - 产品原型 > 瑞吉外卖后台（管理端）- 登录.html

点开登录.html页面

• 登录页面有两个文本框需要用户输入用户名和密码，客户端要进行非空校验，单击【登录】按钮之后，表单数据以JSON格式通过AJAX请求方式发送到后台，后台控制器要编写相应的处理函数，对提交的数据进行业务处理，然后将处理结果返回给前端。

• 不妨看一看login.html页面代码

 登录页面展示

页面位置：项目/resources/backend/page/login/login.html

• 为什么Vue对象里要绑定这个用户登录数据呢？
• 因为员工表employee里有一条数据：admin与123456（MD5加密之后就成了e10adc3949ba59abbe56e057f20f883e）

 单击【登录】按钮，首先进行校验，如果校验通过，按钮标题就会变成登录中……，如果校验失败，按钮标题就依然是登录

 查看登录请求信息

按F12键进入浏览器的调试模式

• 说明单击登录按钮通过客户端校验之后，请求的URL：http://localhost:8080/employee/login
• 后面我们会在雇员控制器里编写相应的处理函数login()

@RestController // 交给Spring容器管理
@RequestMapping("/employee")
public class EmployeeController {
   
    @PostMapping("/login")
    public R login(HttpRequest request, @RequestBody Employee employee) {
        return null;
    }
}

数据模型 - 雇员表

• 查看雇员表结构

 代码开发

创建雇员实体类

• ORM（Object Relation Mapping）对象关系映射
• 雇员实体类（Employee）—— 雇员表（employee）

• 实体属性名采用驼峰命名法，关系字段名采用xml命名规范
• 如果关系字段名由多个单词用下划线连接，那么实体属性名与关系字段名就不一致，需要进行一个转换，但是这个转换工作不需要手工去操作，直接在应用属性文件（application.yml）里进行设置。

• 创建`entity`子包

• 在net.cm.entity包里创建雇员实体类 - Employee

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.Data;

import java.io.Serializable;
import java.time.LocalDateTime;

@Data // Lombok注解，注在类上，提供类的get、set、equals、hashCode、canEqual、toString方法
public class Employee implements Serializable {

    private static final long serialVersionUID = 1L;

    private Long id;

    private String username;

    private String name;

    private String password;

    private String phone;

    private String sex;

    private String idNumber; // 对应字段 - id_number

    private Integer status;

    private LocalDateTime createTime; // 对应字段 - create_time

    private LocalDateTime updateTime; // 对应字段 - update_time

    @TableField(fill = FieldFill.INSERT) // mybatis-plus注解，填充策略
    private Long createUser; // 对应字段 - create_user

    @TableField(fill = FieldFill.INSERT_UPDATE) // mybatis-plus注解，填充策略
    private Long updateUser; // 对应字段 - update_user
}

创建雇员映射器接口

• 创建mapper子包

 

创建雇员映射器接口 - EmployeeMapper

 采用了mybatis-plus插件，就不用再去创建对应的映射器配置文件

 创建雇员服务

 创建雇员服务接口实现类

 

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import net.hw.entity.Employee;
import net.hw.mapper.EmployeeMapper;
import net.hw.service.EmployeeService;
import org.springframework.stereotype.Service;

@Service // 交给Spring容器管理
public class EmployeeServiceImpl extends ServiceImpl
        implements EmployeeService {
}

创建返回结果类

 包里创建返回结果类 - R

 

package net.hw.common;

import lombok.Data;

import java.util.HashMap;
import java.util.Map;

@Data // Lombok注解，精简代码
public class R {

    private Integer code; // 编码：1成功，0和其它数字为失败
    private String msg; // 错误信息
    private T data; // 数据
    private Map map = new HashMap(); // 动态数据

    public static R success(T object) {
        R r = new R();
        r.data = object;
        r.code = 1;
        return r;
    }

    public static R error(String msg) {
        R r = new R();
        r.msg = msg;
        r.code = 0;
        return r;
    }

    public R add(String key, Object value) {
        this.map.put(key, value);
        return this;
    }
}

创建雇员控制器

• 创建controller子包

 创建雇员控制器类 - EmployeeController

 

• 基本框架代码，登录方法代码尚未编写

】

import lombok.extern.slf4j.Slf4j;
import net.hw.common.R;
import net.hw.entity.Employee;
import net.hw.service.EmployeeService;
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 javax.servlet.http.HttpServletRequest;
@Slf4j // 日志注解
@RestController // 交给Spring容器管理
@RequestMapping("/employee")
public class EmployeeController {

    @Autowired
    private EmployeeService employeeService;

    @PostMapping("/login")
    public R login(HttpServletRequest request, @RequestBody Employee employee) {
        return null;
    }
}

功能测试   修改超时配置

在resources/backend/js/request.js文件里设置超时为1000000毫秒，便于后面做断点调试

 设置断点

在EmployeeController里设置断点

 采用调试模式启动应用

 测试登录 - [成功]

浏览器访问http://localhost:8080/backend/page/login/login.html

 按F12键，打开开发者工具

 

Java里实现MD5、SHA256、SHA512、SHA1和SHA224加密

采用md5加密算

package net.hw.common;

import org.springframework.util.DigestUtils;

import java.util.Scanner;
public class Encrypt {
    public static void main(String[] args) {
        // 声明变量
        String plainText, cryptoText;
        Scanner sc = new Scanner(System.in);

        // 输入待加密字符串
        System.out.print("输入待加密字符串：");
        plainText = sc.nextLine();

        // 采用MD5加密算法进行加密
        cryptoText = DigestUtils.md5DigestAsHex(plainText.getBytes());

        // 输出MD5加密字符串
        System.out.println("加密之后的字符串：" + cryptoText);
        System.out.println("md5加密字符串长度：" + cryptoText.length());
    }
}

创建EncryptMD5类

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Scanner;
public class EncryptMD5 {

    public static void main(String[] args) {
        // 声明变量
        String plainText, cryptoText;
        Scanner sc = new Scanner(System.in);

        // 输入待加密字符串
        System.out.print("输入待加密字符串：");
        plainText = sc.nextLine();

        // 采用SHA256加密算法进行加密
        cryptoText = sha256DigestAsHex(plainText);

        // 输出SHA256加密字符串
        System.out.println("加密之后的字符串：" + cryptoText);
        System.out.println("md5加密字符串长度：" + cryptoText.length());
    }

   
    public static String sha256DigestAsHex(String text) {
        MessageDigest md;
        String encodedText = "";
        try {
            md = MessageDigest.getInstance("MD5");
            md.update(text.getBytes(StandardCharsets.UTF_8));
            encodedText = byte2Hex(md.digest());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return encodedText;
    }

   
    private static String byte2Hex(byte[] bytes) {
        StringBuilder builder = new StringBuilder();
        String temp;
        for (byte aByte : bytes) {
            temp = Integer.toHexString(aByte & 0xFF);
            if (temp.length() == 1) {
                // 得到一位的进行补0操作
                builder.append("0");
            }
            builder.append(temp);
        }
        return builder.toString();
    }
}

采用sha256加密算法

 

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Scanner;
public class EncryptSHA256 {

    public static void main(String[] args) {
        // 声明变量
        String plainText, cryptoText;
        Scanner sc = new Scanner(System.in);

        // 输入待加密字符串
        System.out.print("输入待加密字符串：");
        plainText = sc.nextLine();

        // 采用SHA256加密算法进行加密
        cryptoText = sha256DigestAsHex(plainText);

        // 输出SHA256加密字符串
        System.out.println("加密之后的字符串：" + cryptoText);
        System.out.println("sha256加密字符串长度：" + cryptoText.length());
    }

   
    public static String sha256DigestAsHex(String text) {
        MessageDigest md;
        String encodedText = "";
        try {
            md = MessageDigest.getInstance("SHA-256");
            md.update(text.getBytes(StandardCharsets.UTF_8));
            encodedText = byte2Hex(md.digest());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return encodedText;
    }

   
    private static String byte2Hex(byte[] bytes) {
        StringBuilder builder = new StringBuilder();
        String temp;
        for (byte aByte : bytes) {
            temp = Integer.toHexString(aByte & 0xFF);
            if (temp.length() == 1) {
                // 得到一位的进行补0操作
                builder.append("0");
            }
            builder.append(temp);
        }
        return builder.toString();
    }
}

采用sha512加密算法

 

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Scanner;
public class EncryptSHA512 {

    public static void main(String[] args) {
        // 声明变量
        String plainText, cryptoText;
        Scanner sc = new Scanner(System.in);

        // 输入待加密字符串
        System.out.print("输入待加密字符串：");
        plainText = sc.nextLine();

        // 采用SHA512加密算法进行加密
        cryptoText = sha512DigestAsHex(plainText);

        // 输出SHA512加密字符串
        System.out.println("加密之后的字符串：" + cryptoText);
        System.out.println("sha512加密字符串长度：" + cryptoText.length());
    }

   
    public static String sha512DigestAsHex(String text) {
        MessageDigest md;
        String encodedText = "";
        try {
            md = MessageDigest.getInstance("SHA-512");
            md.update(text.getBytes(StandardCharsets.UTF_8));
            encodedText = byte2Hex(md.digest());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return encodedText;
    }

   
    private static String byte2Hex(byte[] bytes) {
        StringBuilder builder = new StringBuilder();
        String temp;
        for (byte aByte : bytes) {
            temp = Integer.toHexString(aByte & 0xFF);
            if (temp.length() == 1) {
                // 得到一位的进行补0操作
                builder.append("0");
            }
            builder.append(temp);
        }
        return builder.toString();
    }
}

采用sha1加密算法

 

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Scanner;
public class EncryptSHA1 {

    public static void main(String[] args) {
        // 声明变量
        String plainText, cryptoText;
        Scanner sc = new Scanner(System.in);

        // 输入待加密字符串
        System.out.print("输入待加密字符串：");
        plainText = sc.nextLine();

        // 采用SHA256加密算法进行加密
        cryptoText = sha256DigestAsHex(plainText);

        // 输出SHA256加密字符串
        System.out.println("加密之后的字符串：" + cryptoText);
        System.out.println("sha1加密字符串长度：" + cryptoText.length());
    }

   
    public static String sha256DigestAsHex(String text) {
        MessageDigest md;
        String encodedText = "";
        try {
            md = MessageDigest.getInstance("SHA-1");
            md.update(text.getBytes(StandardCharsets.UTF_8));
            encodedText = byte2Hex(md.digest());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return encodedText;
    }

   
    private static String byte2Hex(byte[] bytes) {
        StringBuilder builder = new StringBuilder();
        String temp;
        for (byte aByte : bytes) {
            temp = Integer.toHexString(aByte & 0xFF);
            if (temp.length() == 1) {
                // 得到一位的进行补0操作
                builder.append("0");
            }
            builder.append(temp);
        }
        return builder.toString();
    }
}

采用sha224加密算法

 

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Scanner;
public class EncryptSHA224 {

    public static void main(String[] args) {
        // 声明变量
        String plainText, cryptoText;
        Scanner sc = new Scanner(System.in);

        // 输入待加密字符串
        System.out.print("输入待加密字符串：");
        plainText = sc.nextLine();

        // 采用SHA224加密算法进行加密
        cryptoText = sha224DigestAsHex(plainText);

        // 输出SHA224加密字符串
        System.out.println("加密之后的字符串：" + cryptoText);
        System.out.println("sha224加密字符串长度：" + cryptoText.length());
    }

   
    public static String sha224DigestAsHex(String text) {
        MessageDigest md;
        String encodedText = "";
        try {
            md = MessageDigest.getInstance("SHA-224");
            md.update(text.getBytes(StandardCharsets.UTF_8));
            encodedText = byte2Hex(md.digest());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return encodedText;
    }

   
    private static String byte2Hex(byte[] bytes) {
        StringBuilder builder = new StringBuilder();
        String temp;
        for (byte aByte : bytes) {
            temp = Integer.toHexString(aByte & 0xFF);
            if (temp.length() == 1) {
                // 得到一位的进行补0操作
                builder.append("0");
            }
            builder.append(temp);
        }
        return builder.toString();
    }
}