• SpringBoot--网上商城项目（前端搭建、首页、用户登录、盐加密、登录令牌管理）

                                                                            文章目录

    一、项目技术点

    数据表

    二、构建SpringBoot项目

    1、创建SpringBoot项目并配置pom

    配置pom  

    2、application.yml的配置

    3、首页访问

     三、首页功能

    工具类！！！

     首页数据绑定语法

     四、用户明文登录

     五、前端及数据库密码加密

    盐加密

    六、服务器客户端登录密码管理

    一、项目技术点

    前端：Freemarker、jQuery
    后端：SpringBoot、MyBatisPlus、Lombok
    中间件：Redis

    数据表

    用户表：t_user

    订单项表：t_order_item                           

    数据项表：t_dict_data

    商品表：t_goods                       

    订单表：t_order

    数据源表：t_dict_type

    二、构建SpringBoot项目

    1、创建SpringBoot项目并配置pom

     

     

    配置pom  

    1.    <parent>
    2.         <groupId>org.springframework.bootgroupId>
    3.         <artifactId>spring-boot-starter-parentartifactId>
    4.         <version>2.3.9.RELEASEversion>
    5.         <relativePath/> 
    6.     parent>

     

     导入pom依赖时，报红杠杠，是网络问题，删除重新导入或者换一个网络重新导入

    1. <properties>
    2.         <java.version>1.8java.version>
    3.     properties>
    4.     <dependencies>
    5.         
    6.         <dependency>
    7.             <groupId>org.springframework.bootgroupId>
    8.             <artifactId>spring-boot-starter-freemarkerartifactId>
    9.         dependency>
    10.  
    11.         
    12.         <dependency>
    13.             <groupId>org.springframework.bootgroupId>
    14.             <artifactId>spring-boot-starter-webartifactId>
    15.         dependency>
    16.  
    17.         
    18.         <dependency>
    19.             <groupId>mysqlgroupId>
    20.             <artifactId>mysql-connector-javaartifactId>
    21.             <scope>runtimescope>
    22.             <version>5.1.44version>
    23.         dependency>
    24.  
    25.         
    26.         <dependency>
    27.             <groupId>org.projectlombokgroupId>
    28.             <artifactId>lombokartifactId>
    29.             <optional>trueoptional>
    30.         dependency>
    31.  
    32.         
    33.         <dependency>
    34.             <groupId>org.springframework.bootgroupId>
    35.             <artifactId>spring-boot-starter-testartifactId>
    36.             <scope>testscope>
    37.             <exclusions>
    38.                 <exclusion>
    39.                     <groupId>org.junit.vintagegroupId>
    40.                     <artifactId>junit-vintage-engineartifactId>
    41.                 exclusion>
    42.             exclusions>
    43.         dependency>
    44.  
    45.         <dependency>
    46.             <groupId>junitgroupId>
    47.             <artifactId>junitartifactId>
    48.             <scope>testscope>
    49.         dependency>
    50.  
    51.         
    52.         <dependency>
    53.             <groupId>com.baomidougroupId>
    54.             <artifactId>mybatis-plus-boot-starterartifactId>
    55.             <version>3.4.0version>
    56.         dependency>
    57.         
    58.         <dependency>
    59.             <groupId>com.baomidougroupId>
    60.             <artifactId>mybatis-plus-generatorartifactId>
    61.             <version>3.4.0version>
    62.         dependency>
    63.  
    64.         
    65.         <dependency>
    66.             <groupId>com.zaxxergroupId>
    67.             <artifactId>HikariCPartifactId>
    68.         dependency>
    69.  
    70.         
    71.         <dependency>
    72.             <groupId>commons-codecgroupId>
    73.             <artifactId>commons-codecartifactId>
    74.         dependency>
    75.  
    76.         <dependency>
    77.             <groupId>org.apache.commonsgroupId>
    78.             <artifactId>commons-lang3artifactId>
    79.             <version>3.6version>
    80.         dependency>
    81.  
    82.         
    83.         <dependency>
    84.             <groupId>org.springframework.bootgroupId>
    85.             <artifactId>spring-boot-starter-validationartifactId>
    86.         dependency>
    87.  
    88.         
    89.         <dependency>
    90.             <groupId>org.springframework.bootgroupId>
    91.             <artifactId>spring-boot-starter-data-redisartifactId>
    92.         dependency>
    93.  
    94.         
    95.         <dependency>
    96.             <groupId>org.apache.commonsgroupId>
    97.             <artifactId>commons-pool2artifactId>
    98.         dependency>
    99.  
    100.         
    101.         
    102.         <dependency>
    103.             <groupId>com.alipay.sdkgroupId>
    104.             <artifactId>alipay-easysdkartifactId>
    105.             <version>2.0.1version>
    106.         dependency>
    107.     dependencies>
    108.  
    109.     <build>
    110.         <plugins>
    111.             <plugin>
    112.                 <groupId>org.springframework.bootgroupId>
    113.                 <artifactId>spring-boot-maven-pluginartifactId>
    114.             plugin>
    115.         plugins>
    116.     build>

    2、application.yml的配置

    没有下载这个插件的话，需要下载，下载后，重新启动idea哦，这应该是常识了叭~~~~~~~~~~~

      转成yml

    再将下面的配置，拷贝进去

    1. server:
    2.     port: 8081
    3.     servlet:
    4.         context-path: /
    5. spring:
    6.     datasource:
    7.         url: jdbc:mysql://localhost:3306/spbootpro?useSSL=false&useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC&characterEncoding=UTF8
    8.         driver-class-name: com.mysql.jdbc.Driver
    9.         password: 123456
    10.         username: root
    11.         hikari:
    12.             # 最小空闲连接数量
    13.             minimum-idle: 5
    14.             # 空闲连接存活最大时间，默认600000（10分钟）
    15.             idle-timeout: 180000
    16.             # 连接池最大连接数，默认是10
    17.             maximum-pool-size: 10
    18.             # 此属性控制从池返回的连接的默认自动提交行为,默认值：true
    19.             auto-commit: true
    20.             # 连接池名称
    21.             pool-name: MyHikariCP
    22.             # 此属性控制池中连接的最长生命周期，值0表示无限生命周期，默认1800000即30分钟
    23.             max-lifetime: 1800000
    24.             # 数据库连接超时时间,默认30秒，即30000
    25.             connection-timeout: 30000
    26.     freemarker:
    27.         #设置编码格式
    28.         charset: UTF-8
    29.         #后缀
    30.         suffix:
    31.         #文档类型
    32.         content-type: text/html
    33.         #模板前端
    34.         template-loader-path: classpath:/templates/
    35.         #启用模板
    36.         enabled: true
    37.     mvc:
    38.         static-path-pattern: /static/**
    39.     redis:
    40.         #服务端IP
    41.         host: 192.168.141.128
    42.         #端口
    43.         port: 6379
    44.         #密码
    45.         password: 123456
    46.         #选择数据库
    47.         database: 0
    48.         #超时时间
    49.         timeout: 10000ms
    50.         #Lettuce的连接是基于Netty的，连接实例（StatefulRedisConnection）可以在多个线程间并发访问
    51.         #Lettuce线程安全，Jedis线程非安全
    52.         lettuce:
    53.             pool:
    54.                 #最大连接数，默认8
    55.                 max-active: 8
    56.                 #最大连接阻塞等待时间，默认-1
    57.                 max-wait: 10000ms
    58.                 #最大空闲连接，默认8
    59.                 max-idle: 200
    60.                 #最小空闲连接，默认0
    61.                 min-idle: 5
    62. #mybatis-plus配置
    63. mybatis-plus:
    64.     #所对应的 XML 文件位置
    65.     mapper-locations: classpath*:/mapper/*Mapper.xml
    66.     #别名包扫描路径
    67.     type-aliases-package: com.xiaokun.spbootpro.model
    68.     configuration:
    69.         #驼峰命名规则
    70.         map-underscore-to-camel-case: true
    71. #日志配置
    72. logging:
    73.     level:
    74.         com.xiaokun.spbootpro.mapper: debug

    配置中该修该的修改一下，比如服务端IP，数据库名称什么的。 

     这个后缀不用修改也不用添加，空的方便后续开发

      编写controller层，访问首页界面

    3、首页访问

    样式，依赖都已经调整好了，导入前端页面及页面对应的js/css/images文件

    前端静态页面，导入你手上现有的就ok

     在浏览器中输入访问地址 http://localhost:8081/

    访问成功，就说明你的前端搭建好了

     三、首页功能

    将这边的静态数据变为动态数据，什么是动态数据呢？就是数据库中的数据👀 

    如果它的数据量大于6条时，只取前6条数据 

     

     导入工具类与代码生成器

    导入之前需要下载一个插件--Lombok ⬇⬇⬇

    1. package com.xiaokun.spbootpro.config;
    2.  
    3. import org.springframework.context.annotation.Bean;
    4. import org.springframework.context.annotation.Configuration;
    5. import org.springframework.data.redis.connection.RedisConnectionFactory;
    6. import org.springframework.data.redis.core.RedisTemplate;
    7. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    8. import org.springframework.data.redis.serializer.StringRedisSerializer;
    9.  
    10. @Configuration
    11. public class RedisConfig {
    12.  
    13.     @Bean
    14.     public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory){
    15.         RedisTemplate redisTemplate=new RedisTemplate<>();
    16.         redisTemplate.setStringSerializer(new StringRedisSerializer());
    17.         redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    18.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    19.         redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
    20.         redisTemplate.setConnectionFactory(connectionFactory);
    21.         redisTemplate.afterPropertiesSet();
    22.         return redisTemplate;
    23.     }
    24. }

    1. package com.xiaokun.spbootpro.exception;
    2.  
    3. import com.xiaokun.spbootpro.utils.JsonResponseStatus;
    4. import lombok.AllArgsConstructor;
    5. import lombok.Data;
    6. import lombok.NoArgsConstructor;
    7.  
    8. @Data
    9. @AllArgsConstructor
    10. @NoArgsConstructor
    11. public class BusinessException extends RuntimeException {
    12.     private JsonResponseStatus jsonResponseStatus;
    13. }
    1. package com.xiaokun.spbootpro.exception;
    2.  
    3. import com.xiaokun.spbootpro.utils.JsonResponseBody;
    4. import com.xiaokun.spbootpro.utils.JsonResponseStatus;
    5. import org.springframework.validation.BindException;
    6. import org.springframework.web.bind.annotation.ExceptionHandler;
    7. import org.springframework.web.bind.annotation.RestControllerAdvice;
    8.  
    9. @RestControllerAdvice
    10. public class GlobalExceptionHandler {
    11.  
    12.     @ExceptionHandler
    13.     public JsonResponseBody exceptionHandler(Exception e){
    14.         JsonResponseBody jsonResponseBody=null;
    15.         e.printStackTrace();
    16.         if(e instanceof BusinessException){
    17.             BusinessException ex= (BusinessException) e;
    18.             jsonResponseBody=new JsonResponseBody<>(ex.getJsonResponseStatus());
    19.         }else if(e instanceof BindException){
    20.             BindException ex= (BindException) e;
    21.             String msg = ex.getBindingResult().getAllErrors().get(0).getDefaultMessage();
    22.             jsonResponseBody=new JsonResponseBody<>(JsonResponseStatus.BIND_ERROR);
    23.             jsonResponseBody.setMsg(msg);
    24.         }else{
    25.             System.out.println("aaaaaa");
    26.         }
    27.         return jsonResponseBody;
    28.     }
    29. }

    1. package com.xiaokun.spbootpro.generator;
    2.  
    3. import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
    4. import com.baomidou.mybatisplus.core.toolkit.StringPool;
    5. import com.baomidou.mybatisplus.core.toolkit.StringUtils;
    6. import com.baomidou.mybatisplus.generator.AutoGenerator;
    7. import com.baomidou.mybatisplus.generator.InjectionConfig;
    8. import com.baomidou.mybatisplus.generator.config.*;
    9. import com.baomidou.mybatisplus.generator.config.po.TableInfo;
    10. import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
    11. import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
    12.  
    13. import java.util.ArrayList;
    14. import java.util.List;
    15. import java.util.Scanner;
    16.  
    17. public class CodeGenerator {
    18.  
    19.     /**
    20.      * 
    21.      * 读取控制台内容
    22.      * 
    23.      */
    24.     public static String scanner(String tip) {
    25.         Scanner scanner = new Scanner(System.in);
    26.         StringBuilder help = new StringBuilder();
    27.         help.append("请输入" + tip + "：");
    28.         System.out.println(help.toString());
    29.         if (scanner.hasNext()) {
    30.             String ipt = scanner.next();
    31.             if (StringUtils.isNotBlank(ipt)) {
    32.                 return ipt;
    33.             }
    34.         }
    35.         throw new MybatisPlusException("请输入正确的" + tip + "！");
    36.     }
    37.  
    38.     public static void main(String[] args) {
    39.         // 代码生成器
    40.         AutoGenerator mpg = new AutoGenerator();
    41.  
    42.         // 全局配置
    43.         GlobalConfig gc = new GlobalConfig();
    44.         String projectPath = System.getProperty("user.dir") + "/spbootpro";
    45.         gc.setOutputDir(projectPath + "/src/main/java");
    46.         gc.setAuthor("xiaokun");
    47.         gc.setOpen(false);
    48.         gc.setBaseColumnList(true);
    49.         gc.setBaseResultMap(true);
    50.         // gc.setSwagger2(true); 实体属性 Swagger2 注解
    51.         mpg.setGlobalConfig(gc);
    52.  
    53.         // 数据源配置
    54.         DataSourceConfig dsc = new DataSourceConfig();
    55.         dsc.setUrl("jdbc:mysql://localhost:3306/spbootpro?useUnicode=true&useSSL=false&characterEncoding=utf8");
    56.         // dsc.setSchemaName("public");
    57.         dsc.setDriverName("com.mysql.jdbc.Driver");
    58.         dsc.setUsername("root");
    59.         dsc.setPassword("123456");
    60.         mpg.setDataSource(dsc);
    61.  
    62.         // 包配置
    63.         PackageConfig pc = new PackageConfig();
    64.         //pc.setModuleName(scanner("模块名"));
    65.         pc.setParent("com.xiaokun.spbootpro");
    66.         //设置包名
    67.         pc.setEntity("model");
    68.         mpg.setPackageInfo(pc);
    69.  
    70.         // 自定义配置
    71.         InjectionConfig cfg = new InjectionConfig() {
    72.             @Override
    73.             public void initMap() {
    74.                 // to do nothing
    75.             }
    76.         };
    77.  
    78.         // 如果模板引擎是 freemarker
    79.         String templatePath = "/templates/mybatis-generator/mapper2.xml.ftl";
    80.         // 如果模板引擎是 velocity
    81.         // String templatePath = "/templates/mapper.xml.vm";
    82.  
    83.         // 自定义输出配置
    84.         List focList = new ArrayList<>();
    85.         // 自定义配置会被优先输出
    86.         focList.add(new FileOutConfig(templatePath) {
    87.             @Override
    88.             public String outputFile(TableInfo tableInfo) {
    89.                 // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
    90.                 return projectPath + "/src/main/resources/mapper/" + pc.getModuleName()
    91.                         + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
    92.             }
    93.         });
    94.         /*
    95.         cfg.setFileCreate(new IFileCreate() {
    96.             @Override
    97.             public boolean isCreate(ConfigBuilder configBuilder, FileType fileType, String filePath) {
    98.                 // 判断自定义文件夹是否需要创建
    99.                 checkDir("调用默认方法创建的目录，自定义目录用");
    100.                 if (fileType == FileType.MAPPER) {
    101.                     // 已经生成 mapper 文件判断存在，不想重新生成返回 false
    102.                     return !new File(filePath).exists();
    103.                 }
    104.                 // 允许生成模板文件
    105.                 return true;
    106.             }
    107.         });
    108.         */
    109.         cfg.setFileOutConfigList(focList);
    110.         mpg.setCfg(cfg);
    111.  
    112.         // 配置模板
    113.         TemplateConfig templateConfig = new TemplateConfig();
    114.  
    115.         // 配置自定义输出模板
    116.         //指定自定义模板路径，注意不要带上.ftl/.vm, 会根据使用的模板引擎自动识别
    117.         templateConfig.setMapper("templates/mybatis-generator/mapper2.java");
    118.         templateConfig.setEntity("templates/mybatis-generator/entity2.java");
    119.         templateConfig.setService("templates/mybatis-generator/service2.java");
    120.         templateConfig.setServiceImpl("templates/mybatis-generator/serviceImpl2.java");
    121.         templateConfig.setController("templates/mybatis-generator/controller2.java");
    122.         templateConfig.setXml(null);
    123.         mpg.setTemplate(templateConfig);
    124.  
    125.         // 策略配置
    126.         StrategyConfig strategy = new StrategyConfig();
    127.         strategy.setNaming(NamingStrategy.underline_to_camel);
    128.         strategy.setColumnNaming(NamingStrategy.underline_to_camel);
    129.         //strategy.setSuperEntityClass("你自己的父类实体,没有就不用设置!");
    130.         strategy.setEntityLombokModel(true);
    131.         strategy.setRestControllerStyle(true);
    132.         strategy.setEntitySerialVersionUID(false);
    133.         // 公共父类
    134.         //strategy.setSuperControllerClass("你自己的父类控制器,没有就不用设置!");
    135.         // 写于父类中的公共字段
    136.         strategy.setSuperEntityColumns("id");
    137.         strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
    138.         strategy.setControllerMappingHyphenStyle(true);
    139.         strategy.setTablePrefix("t_");
    140.         mpg.setStrategy(strategy);
    141.         mpg.setTemplateEngine(new FreemarkerTemplateEngine());
    142.         mpg.execute();
    143.     }
    144. }

    工具类！！！

     

    1. package com.xiaokun.spbootpro.utils;
    2.  
    3. import lombok.extern.slf4j.Slf4j;
    4.  
    5. import javax.servlet.http.Cookie;
    6. import javax.servlet.http.HttpServletRequest;
    7. import javax.servlet.http.HttpServletResponse;
    8. import java.io.UnsupportedEncodingException;
    9. import java.net.URLDecoder;
    10. import java.net.URLEncoder;
    11.  
    12. @Slf4j
    13. public class CookieUtils {
    14.  
    15.     /**
    16.      *
    17.      * @Description: 得到Cookie的值, 不编码
    18.      * @param request
    19.      * @param cookieName
    20.      * @return
    21.      */
    22.     public static String getCookieValue(HttpServletRequest request, String cookieName) {
    23.         return getCookieValue(request, cookieName, false);
    24.     }
    25.  
    26.     /**
    27.      *
    28.      * @Description: 得到Cookie的值
    29.      * @param request
    30.      * @param cookieName
    31.      * @param isDecoder
    32.      * @return
    33.      */
    34.     public static String getCookieValue(HttpServletRequest request, String cookieName, boolean isDecoder) {
    35.         Cookie[] cookieList = request.getCookies();
    36.         if (cookieList == null || cookieName == null) {
    37.             return null;
    38.         }
    39.         String retValue = null;
    40.         try {
    41.             for (int i = 0; i < cookieList.length; i++) {
    42.                 if (cookieList[i].getName().equals(cookieName)) {
    43.                     if (isDecoder) {
    44.                         retValue = URLDecoder.decode(cookieList[i].getValue(), "UTF-8");
    45.                     } else {
    46.                         retValue = cookieList[i].getValue();
    47.                     }
    48.                     break;
    49.                 }
    50.             }
    51.         } catch (UnsupportedEncodingException e) {
    52.             e.printStackTrace();
    53.         }
    54.         return retValue;
    55.     }
    56.  
    57.     /**
    58.      *
    59.      * @Description: 得到Cookie的值
    60.      * @param request
    61.      * @param cookieName
    62.      * @param encodeString
    63.      * @return
    64.      */
    65.     public static String getCookieValue(HttpServletRequest request, String cookieName, String encodeString) {
    66.         Cookie[] cookieList = request.getCookies();
    67.         if (cookieList == null || cookieName == null) {
    68.             return null;
    69.         }
    70.         String retValue = null;
    71.         try {
    72.             for (int i = 0; i < cookieList.length; i++) {
    73.                 if (cookieList[i].getName().equals(cookieName)) {
    74.                     retValue = URLDecoder.decode(cookieList[i].getValue(), encodeString);
    75.                     break;
    76.                 }
    77.             }
    78.         } catch (UnsupportedEncodingException e) {
    79.             e.printStackTrace();
    80.         }
    81.         return retValue;
    82.     }
    83.  
    84.     /**
    85.      *
    86.      * @Description: 设置Cookie的值 不设置生效时间默认浏览器关闭即失效,也不编码
    87.      * @param request
    88.      * @param response
    89.      * @param cookieName
    90.      * @param cookieValue
    91.      */
    92.     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
    93.                                  String cookieValue) {
    94.         setCookie(request, response, cookieName, cookieValue, -1);
    95.     }
    96.  
    97.     /**
    98.      *
    99.      * @Description: 设置Cookie的值 在指定时间内生效,但不编码
    100.      * @param request
    101.      * @param response
    102.      * @param cookieName
    103.      * @param cookieValue
    104.      * @param cookieMaxage
    105.      */
    106.     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
    107.                                  String cookieValue, int cookieMaxage) {
    108.         setCookie(request, response, cookieName, cookieValue, cookieMaxage, false);
    109.     }
    110.  
    111.     /**
    112.      *
    113.      * @Description: 设置Cookie的值 不设置生效时间,但编码
    114.      * 在服务器被创建，返回给客户端，并且保存客户端
    115.      * 如果设置了SETMAXAGE(int seconds)，会把cookie保存在客户端的硬盘中
    116.      * 如果没有设置，会默认把cookie保存在浏览器的内存中
    117.      * 一旦设置setPath()：只能通过设置的路径才能获取到当前的cookie信息
    118.      * @param request
    119.      * @param response
    120.      * @param cookieName
    121.      * @param cookieValue
    122.      * @param isEncode
    123.      */
    124.     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
    125.                                  String cookieValue, boolean isEncode) {
    126.         setCookie(request, response, cookieName, cookieValue, -1, isEncode);
    127.     }
    128.  
    129.     /**
    130.      *
    131.      * @Description: 设置Cookie的值 在指定时间内生效, 编码参数
    132.      * @param request
    133.      * @param response
    134.      * @param cookieName
    135.      * @param cookieValue
    136.      * @param cookieMaxage
    137.      * @param isEncode
    138.      */
    139.     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
    140.                                  String cookieValue, int cookieMaxage, boolean isEncode) {
    141.         doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, isEncode);
    142.     }
    143.  
    144.     /**
    145.      *
    146.      * @Description: 设置Cookie的值 在指定时间内生效, 编码参数(指定编码)
    147.      * @param request
    148.      * @param response
    149.      * @param cookieName
    150.      * @param cookieValue
    151.      * @param cookieMaxage
    152.      * @param encodeString
    153.      */
    154.     public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName,
    155.                                  String cookieValue, int cookieMaxage, String encodeString) {
    156.         doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, encodeString);
    157.     }
    158.  
    159.     /**
    160.      *
    161.      * @Description: 删除Cookie带cookie域名
    162.      * @param request
    163.      * @param response
    164.      * @param cookieName
    165.      */
    166.     public static void deleteCookie(HttpServletRequest request, HttpServletResponse response,
    167.                                     String cookieName) {
    168.         doSetCookie(request, response, cookieName, null, -1, false);
    169.     }
    170.  
    171.  
    172.     /**
    173.      *
    174.      * @Description: 设置Cookie的值，并使其在指定时间内生效
    175.      * @param request
    176.      * @param response
    177.      * @param cookieName
    178.      * @param cookieValue
    179.      * @param cookieMaxage	cookie生效的最大秒数
    180.      * @param isEncode
    181.      */
    182.     private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response,
    183.                                           String cookieName, String cookieValue, int cookieMaxage, boolean isEncode) {
    184.         try {
    185.             if (cookieValue == null) {
    186.                 cookieValue = "";
    187.             } else if (isEncode) {
    188.                 cookieValue = URLEncoder.encode(cookieValue, "utf-8");
    189.             }
    190.             Cookie cookie = new Cookie(cookieName, cookieValue);
    191.             if (cookieMaxage > 0)
    192.                 cookie.setMaxAge(cookieMaxage);
    193.             if (null != request) {// 设置域名的cookie
    194.                 String domainName = getDomainName(request);
    195.                 log.info("========== domainName: {} ==========", domainName);
    196.                 if (!"localhost".equals(domainName)) {
    197.                     cookie.setDomain(domainName);
    198.                 }
    199.             }
    200.             cookie.setPath("/");
    201.             response.addCookie(cookie);
    202.         } catch (Exception e) {
    203.             e.printStackTrace();
    204.         }
    205.     }
    206.  
    207.     /**
    208.      *
    209.      * @Description: 设置Cookie的值，并使其在指定时间内生效
    210.      * @param request
    211.      * @param response
    212.      * @param cookieName
    213.      * @param cookieValue
    214.      * @param cookieMaxage	cookie生效的最大秒数
    215.      * @param encodeString
    216.      */
    217.     private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response,
    218.                                           String cookieName, String cookieValue, int cookieMaxage, String encodeString) {
    219.         try {
    220.             if (cookieValue == null) {
    221.                 cookieValue = "";
    222.             } else {
    223.                 cookieValue = URLEncoder.encode(cookieValue, encodeString);
    224.             }
    225.             Cookie cookie = new Cookie(cookieName, cookieValue);
    226.             if (cookieMaxage > 0)
    227.                 cookie.setMaxAge(cookieMaxage);
    228.             if (null != request) {// 设置域名的cookie
    229.                 String domainName = getDomainName(request);
    230.                 log.info("========== domainName: {} ==========", domainName);
    231.                 if (!"localhost".equals(domainName)) {
    232.                     cookie.setDomain(domainName);
    233.                 }
    234.             }
    235.             cookie.setPath("/");
    236.             response.addCookie(cookie);
    237.         } catch (Exception e) {
    238.             e.printStackTrace();
    239.         }
    240.     }
    241.  
    242.     /**
    243.      *
    244.      * @Description: 得到cookie的域名
    245.      * @return
    246.      */
    247.     private static final String getDomainName(HttpServletRequest request) {
    248.         String domainName = null;
    249.  
    250.         String serverName = request.getRequestURL().toString();
    251.         if (serverName == null || serverName.equals("")) {
    252.             domainName = "";
    253.         } else {
    254.             serverName = serverName.toLowerCase();
    255.             serverName = serverName.substring(7);
    256.             final int end = serverName.indexOf("/");
    257.             serverName = serverName.substring(0, end);
    258.             if (serverName.indexOf(":") > 0) {
    259.                 String[] ary = serverName.split("\\:");
    260.                 serverName = ary[0];
    261.             }
    262.  
    263.             final String[] domains = serverName.split("\\.");
    264.             int len = domains.length;
    265.             if (len > 3 && !isIp(serverName)) {
    266.                 // www.xxx.com.cn
    267.                 domainName = "." + domains[len - 3] + "." + domains[len - 2] + "." + domains[len - 1];
    268.             } else if (len <= 3 && len > 1) {
    269.                 // xxx.com or xxx.cn
    270.                 domainName = "." + domains[len - 2] + "." + domains[len - 1];
    271.             } else {
    272.                 domainName = serverName;
    273.             }
    274.         }
    275.         return domainName;
    276.     }
    277.  
    278.     public static String trimSpaces(String IP){//去掉IP字符串前后所有的空格
    279.         while(IP.startsWith(" ")){
    280.             IP= IP.substring(1,IP.length()).trim();
    281.         }
    282.         while(IP.endsWith(" ")){
    283.             IP= IP.substring(0,IP.length()-1).trim();
    284.         }
    285.         return IP;
    286.     }
    287.  
    288.     public static boolean isIp(String IP){//判断是否是一个IP
    289.         boolean b = false;
    290.         IP = trimSpaces(IP);
    291.         if(IP.matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}")){
    292.             String s[] = IP.split("\\.");
    293.             if(Integer.parseInt(s[0])<255)
    294.                 if(Integer.parseInt(s[1])<255)
    295.                     if(Integer.parseInt(s[2])<255)
    296.                         if(Integer.parseInt(s[3])<255)
    297.                             b = true;
    298.         }
    299.         return b;
    300.     }
    301. }
    1. package com.xiaokun.spbootpro.utils;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.HashMap;
    5. import java.util.List;
    6. import java.util.Map;
    7.  
    8. public class DataUtils {
    9.     /**
    10.      * 转换方法，基于商品的排版情况（一行三列、一行四列等等）进行数据分行处理
    11.      * @param cols  一行显示几列
    12.      * @param goods 需要筛选的数据集
    13.      * @return
    14.      */
    15.     public Map> transfor(int cols, List goods){
    16.         Map> data=new HashMap<>();
    17.         List rs=new ArrayList<>();
    18.         int len=goods.size();
    19.         for (int i = 0; i < len; i++) {
    20.             rs.add(goods.get(i));
    21.             if((i+1)%cols==0){
    22.                 data.put("goods"+(i+1),rs);
    23.                 if(i==len-1)
    24.                     break;
    25.                 rs=new ArrayList<>();
    26.                 continue;
    27.             }
    28.             if(i==len-1){
    29.                 data.put("goods"+(i+1),rs);
    30.             }
    31.         }
    32.         return data;
    33.     }
    34. }

     

    1. package com.xiaokun.spbootpro.utils;
    2.  
    3. import lombok.Data;
    4.  
    5. import java.io.Serializable;
    6.  
    7. /**
    8.  * 响应封装类
    9.  */
    10. @Data
    11. public class JsonResponseBody implements Serializable {
    12.  
    13.     private String msg="OK";
    14.     private T data;
    15.     private Integer code;
    16.     private Integer total;
    17.  
    18.     public JsonResponseBody(){
    19.         this.data=null;
    20.         this.code=JsonResponseStatus.SUCCESS.getCode();
    21.     }
    22.  
    23.     public JsonResponseBody(T data){
    24.         this.data=data;
    25.         this.code=JsonResponseStatus.SUCCESS.getCode();
    26.     }
    27.  
    28.     public JsonResponseBody(T data,Integer total){
    29.         this.data=data;
    30.         this.total=total;
    31.         this.code=JsonResponseStatus.SUCCESS.getCode();
    32.     }
    33.  
    34.     public JsonResponseBody(JsonResponseStatus jsonResponseStatus){
    35.         this.msg=jsonResponseStatus.getMsg();
    36.         this.code=jsonResponseStatus.getCode();
    37.     }
    38.  
    39.     public JsonResponseBody(JsonResponseStatus jsonResponseStatus,T data){
    40.         this.data=data;
    41.         this.msg=jsonResponseStatus.getMsg();
    42.         this.code=jsonResponseStatus.getCode();
    43.     }
    44. }

     

    1. package com.xiaokun.spbootpro.utils;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Getter;
    5. import lombok.ToString;
    6.  
    7. @Getter
    8. @ToString
    9. @AllArgsConstructor
    10. public enum JsonResponseStatus {
    11.  
    12.     SUCCESS(200,"OK"),
    13.     ERROR(500,"内部错误"),
    14.  
    15.     USER_LOGIN_ERROR(100101,"用户名或者密码错误"),
    16.     USER_MOBILE_ERROR(100102,"手机号码格式错误"),
    17.     USER_PASSWORD_ERROR(100103,"用户密码错误"),
    18.     USER_USERNAME_ERROR(100104,"账号不存在"),
    19.  
    20.     BIND_ERROR(200101,"参数校验异常"),
    21.     TOKEN_EEROR(200102,"token令牌失效或已过期")
    22.     ;
    23.  
    24.     private final Integer code;
    25.     private final String msg;
    26. }
    1. package com.xiaokun.spbootpro.utils;
    2.  
    3. import org.apache.commons.codec.digest.DigestUtils;
    4. import org.springframework.stereotype.Component;
    5.  
    6. import java.util.UUID;
    7.  
    8. /**
    9.  * MD5加密
    10.  * 用户端：password=MD5(明文+固定Salt)
    11.  * 服务端：password=MD5(用户输入+随机Salt)
    12.  * 用户端MD5加密是为了防止用户密码在网络中明文传输，服务端MD5加密是为了提高密码安全性，双重保险。
    13.  */
    14. @Component
    15. public class MD5Utils {
    16.  
    17.     //加密盐，与前端一致
    18.     private static String salt="f1g2h3j4";
    19.  
    20.     /**
    21.      * md5加密
    22.      * @param src
    23.      * @return
    24.      */
    25.     public static String md5(String src){
    26.         return DigestUtils.md5Hex(src);
    27.     }
    28.  
    29.     /**
    30.      * 获取加密的盐
    31.      * @return
    32.      */
    33.     public static String createSalt(){
    34.         return UUID.randomUUID().toString().replace("-","");
    35.     }
    36.  
    37.     /**
    38.      * 将前端的明文密码通过MD5加密方式加密成后端服务所需密码
    39.      * 注意：该步骤实际是在前端完成！！！
    40.      * @param inputPass 明文密码
    41.      * @return
    42.      */
    43.     public static String inputPassToFormpass(String inputPass){
    44.         //混淆固定盐salt,安全性更可靠
    45.         String str=salt.charAt(1)+""+salt.charAt(5)+inputPass+salt.charAt(0)+""+salt.charAt(3);
    46.         return md5(str);
    47.     }
    48.  
    49.     /**
    50.      * 将后端密文密码+随机salt生成数据库的密码
    51.      * @param formPass
    52.      * @param salt
    53.      * @return
    54.      */
    55.     public static String formPassToDbPass(String formPass,String salt){
    56.         //混淆固定盐salt,安全性更可靠
    57.         String str=salt.charAt(7)+""+salt.charAt(9)+formPass+salt.charAt(1)+""+salt.charAt(5);
    58.         return md5(str);
    59.     }
    60.  
    61.     /**
    62.      * 将用户输入的密码转换成数据库的密码
    63.      * @param inputPass 明文密码
    64.      * @param salt      盐
    65.      * @return
    66.      */
    67.     public static String inputPassToDbPass(String inputPass,String salt){
    68.         String formPass = inputPassToFormpass(inputPass);
    69.         String dbPass = formPassToDbPass(formPass, salt);
    70.         return dbPass;
    71.     }
    72.  
    73.     public static void main(String[] args) {
    74.         //d7aaa28e3b8e6c88352bd5e7c23829f9
    75.         //5512a78a188b318c074a15f9b056a712
    76.         String formPass = inputPassToFormpass("123456");
    77.         System.out.println("前端加密密码："+formPass);
    78.         String salt = createSalt();
    79.         System.out.println("后端加密随机盐："+salt);
    80.         String dbPass = formPassToDbPass(formPass, salt);
    81.         System.out.println("后端加密密码："+dbPass);
    82.         System.out.println("-------------------------------------------");
    83.         String dbPass1 = inputPassToDbPass("123456", salt);
    84.         System.out.println("最终加密密码："+dbPass1);
    85.     }
    86. }

     

    1. package com.xiaokun.spbootpro.utils;
    2.  
    3. import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
    4. import com.baomidou.mybatisplus.extension.plugins.pagination.optimize.JsqlParserCountOptimize;
    5. import org.mybatis.spring.annotation.MapperScan;
    6. import org.springframework.context.annotation.Bean;
    7. import org.springframework.context.annotation.Configuration;
    8. import org.springframework.transaction.annotation.EnableTransactionManagement;
    9.  
    10. //Spring boot方式
    11. @EnableTransactionManagement
    12. @Configuration
    13. @MapperScan("com.zking.shoppingpro.service.*.mapper*")
    14. public class MybatisPlusConfig {
    15.  
    16.     @Bean
    17.     public PaginationInterceptor paginationInterceptor() {
    18.         PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
    19.         // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
    20.         // paginationInterceptor.setOverflow(false);
    21.         // 设置最大单页限制数量，默认 500 条，-1 不受限制
    22.         // paginationInterceptor.setLimit(500);
    23.         // 开启 count 的 join 优化,只针对部分 left join
    24.         paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
    25.         return paginationInterceptor;
    26.     }
    27. }
    1. package com.xiaokun.spbootpro.utils;
    2.  
    3. import javax.servlet.http.HttpServletRequest;
    4. import java.io.Serializable;
    5. import java.util.Map;
    6.  
    7. public class PageBean implements Serializable {
    8.  
    9. 	//页码
    10. 	private int page=1;
    11. 	//每页显示条数
    12. 	private int rows=10;
    13. 	//总记录数
    14. 	private int total=0;
    15. 	//是否分页标记
    16. 	private boolean pagination=true;
    17. 	//上一次请求的路径
    18. 	private String url;
    19. 	//请求参数Map集合
    20. 	private Map map;
    21. 	
    22. 	public String getUrl() {
    23. 		return url;
    24. 	}
    25. 	public void setUrl(String url) {
    26. 		this.url = url;
    27. 	}
    28. 	public Map getMap() {
    29. 		return map;
    30. 	}
    31. 	public void setMap(Map map) {
    32. 		this.map = map;
    33. 	}
    34. 	public int getPage() {
    35. 		return page;
    36. 	}
    37. 	public void setPage(int page) {
    38. 		this.page = page;
    39. 	}
    40. 	public int getRows() {
    41. 		return rows;
    42. 	}
    43. 	public void setRows(int rows) {
    44. 		this.rows = rows;
    45. 	}
    46. 	public int getTotal() {
    47. 		return total;
    48. 	}
    49. 	public void setTotal(int total) {
    50. 		this.total = total;
    51. 	}
    52. 	public boolean isPagination() {
    53. 		return pagination;
    54. 	}
    55. 	public void setPagination(boolean pagination) {
    56. 		this.pagination = pagination;
    57. 	}
    58. 	
    59. 	//重载setPage/setRows/setPagination方法
    60. 	public void setPage(String page) {
    61. 		if(null!=page&&!"".equals(page))
    62. 			this.page=Integer.parseInt(page);
    63. 	}
    64. 	public void setRows(String rows) {
    65. 		if(null!=rows&&!"".equals(rows))
    66. 			this.rows=Integer.parseInt(rows);
    67. 	}
    68. 	public void setPagination(String pagination) {
    69. 		if(null!=pagination&&!"".equals(pagination))
    70. 			this.pagination=Boolean.parseBoolean(pagination);
    71. 	}
    72. 	
    73. 	public void setRequest(HttpServletRequest req) {
    74. 		//获取前端提交的page/rows/pagination参数
    75. 		String page=req.getParameter("page");
    76. 		String rows=req.getParameter("rows");
    77. 		String pagination=req.getParameter("pagination");
    78. 		
    79. 		//设置属性
    80. 		this.setPage(page);
    81. 		this.setPagination(pagination);
    82. 		this.setRows(rows);
    83. 		
    84. 		//设置上一次请求的路径
    85. 		//第一次请求：
    86. 		//http://localhost:8080/项目名/请求路径.action?page=1
    87. 		//第二次请求：下一页  page=2
    88. 		//项目名+请求路径.action
    89. 		//req.getContextPath()+req.getServletPath()==req.getRequestURI()
    90. 		this.url=req.getRequestURI();
    91. 		
    92. 		//获取请求参数集合
    93. 		// checkbox name='hobby'
    94. 		// Map hobby==key  value==new String[]{"篮球","足球",..}
    95. 		this.map=req.getParameterMap();
    96. 	}
    97. 	
    98. 	/**
    99. 	 * 获取分页的起始位置
    100. 	 * @return
    101. 	 */
    102. 	public int getStartIndex() {
    103. 		//第1页：(1-1)*10  ==0    limit 0,10
    104. 		//第2页：(2-1)*10  ==10   limit 10,10
    105. 		//..
    106. 		return (this.page-1)*this.rows;
    107. 	}
    108. 	
    109. 	//获取末页、上一页、下一页
    110. 	/**
    111. 	 * 获取末页
    112. 	 * @return
    113. 	 */
    114. 	public int getMaxPager() {
    115. 		int maxPager=this.total/this.rows;
    116. 		if(this.total%this.rows!=0)
    117. 			maxPager++;
    118. 		return maxPager;
    119. 	}
    120. 	
    121. 	/**
    122. 	 * 获取上一页
    123. 	 * @return
    124. 	 */
    125. 	public int getPreviousPager() {
    126. 		int previousPager=this.page-1;
    127. 		if(previousPager<=1)
    128. 			previousPager=1;
    129. 		return previousPager;
    130. 	}
    131. 	
    132. 	/**
    133. 	 * 获取下一页
    134. 	 * @return
    135. 	 */
    136. 	public int getNextPager() {
    137. 		int nextPager=this.page+1;
    138. 		if(nextPager>getMaxPager())
    139. 			nextPager=getMaxPager();
    140. 		return nextPager;
    141. 	}
    142. 	@Override
    143. 	public String toString() {
    144. 		return "PageBean [page=" + page + ", rows=" + rows + ", total=" + total + ", pagination=" + pagination
    145. 				+ ", url=" + url + ", map=" + map + "]";
    146. 	}
    147. 	
    148. }
    1. package com.xiaokun.spbootpro.utils;
    2.  
    3. import org.apache.commons.lang3.StringUtils;
    4.  
    5. import java.util.regex.Matcher;
    6. import java.util.regex.Pattern;
    7.  
    8. /**
    9.  * 正则校验工具类
    10.  * @author 刘开宇
    11.  */
    12. public class ValidatorUtils {
    13.  
    14.     private static final Pattern mobile_pattern=Pattern.compile("[1]([0-9])[0-9]{9}$");
    15.  
    16.     public static boolean isMobile(String mobile){
    17.         if(StringUtils.isEmpty(mobile))
    18.             return false;
    19.     Matcher matcher = mobile_pattern.matcher(mobile);
    20.         return matcher.matches();
    21. }
    22. }

     

    1. package com.xiaokun.spbootpro.validator;
    2.  
    3. import javax.validation.Constraint;
    4. import javax.validation.Payload;
    5. import java.lang.annotation.*;
    6.  
    7. @Documented
    8. @Constraint(
    9.         validatedBy = {MobileValidator.class}
    10. )
    11. @Target({ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.TYPE_USE})
    12. @Retention(RetentionPolicy.RUNTIME)
    13. public @interface IsMobile {
    14.  
    15.     boolean required() default true;
    16.  
    17.     String message() default "手机号码格式错误！";
    18.  
    19.     Class[] groups() default {};
    20.  
    21.     Classextends Payload>[] payload() default {};
    22.  
    23. }
    1. package com.xiaokun.spbootpro.validator;
    2.  
    3.  
    4. import com.xiaokun.spbootpro.utils.ValidatorUtils;
    5.  
    6. import javax.validation.ConstraintValidator;
    7. import javax.validation.ConstraintValidatorContext;
    8.  
    9. public class MobileValidator implements ConstraintValidator {
    10.  
    11.     private boolean required=false;
    12.  
    13.     @Override
    14.     public void initialize(IsMobile constraintAnnotation) {
    15.         this.required=constraintAnnotation.required();
    16.     }
    17.  
    18.     @Override
    19.     public boolean isValid(String mobile, ConstraintValidatorContext constraintValidatorContext) {
    20.         if(!this.required)
    21.             return false;
    22.         return ValidatorUtils.isMobile(mobile);
    23.     }
    24. }

    导入模板生成类

      

    将默认生成的class文件清空，再重新生成一遍

    生成一波 

    看到文件生成完成字样是不是以为生成成功了？？不，idea虚晃一枪，吓唬你的！！

    怎么判断是否生成成功？？

    看出区别了吗~~~~~

    没有生成成功，把生成失败的空的mapper，model等文件删除重新运行就好了。 

      生成成功案例~~~~~~

    @Autowired 标注接口，注入该接口的实现类

     

    IndexController.java    
    1. package com.xiaokun.spbootpro.controller;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    4. import com.xiaokun.spbootpro.model.Goods;
    5. import com.xiaokun.spbootpro.service.IGoodsService;
    6. import com.xiaokun.spbootpro.utils.DataUtils;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.stereotype.Controller;
    9. import org.springframework.ui.Model;
    10. import org.springframework.web.bind.annotation.RequestMapping;
    11.  
    12. import java.util.List;
    13. import java.util.Map;
    14.  
    15. /**
    16.  * @author 小坤
    17.  * @create 2022-11-07-17:09
    18.  */
    19. @Controller
    20. public class IndexController {
    21.     @Autowired
    22.     private IGoodsService goodsService;
    23.  
    24.     @RequestMapping("/")
    25.     public String index(Model model){
    26.         //摆件花艺
    27.         List goods01 = goodsService.list(new QueryWrapper()
    28.                 .eq("goods_type", "01")
    29.                 .last("limit 6"));
    30.         //壁挂北欧
    31.         List goods07 = goodsService.list(new QueryWrapper()
    32.                 .eq("goods_type", "07")
    33.                 .last("limit 12"));
    34.  
    35.         //以下代码为了方便首页数据展示，方便摆放
    36.         DataUtils dataUtils=new DataUtils<>();
    37.         Map> gt01=dataUtils.transfor(3,goods01);
    38.         Map> gt07=dataUtils.transfor(4,goods07);
    39.         model.addAttribute("gt01",gt01);
    40.         model.addAttribute("gt07",gt07);
    41.  
    42.         return "index.html";
    43.     }
    44. }

    解释一下代码中的cols:3 / 4是什么意思 

    使用debug调式，看一下有没有拿到理想的展示的数据

     理想展示效果👀

     首页数据绑定语法

    小编在写这一步时，前端代码调不出，手敲的代码不变色以及会报红，不知道你们会不会有这个问题，但这个问题很好解决加入html就好了⬇⬇

     语法：

    1) list集合判空
    <#if gt01?? && gt01?size gt 0>

    2) 遍历map集合，获取所有的keys
    <#list gt01?keys as key>

    3) 根据key获取对应value值gt01[key]
    <#list gt01[key] as g>

     四、用户明文登录

    现在点击首页的登录按钮，是没有登录界面的，所以⬇⬇

    写一个公共的 controller ，先解决跳转登录的问题

    1. package com.xiaokun.spbootpro.controller;
    2.  
    3. import org.springframework.stereotype.Controller;
    4. import org.springframework.web.bind.annotation.PathVariable;
    5. import org.springframework.web.bind.annotation.RequestMapping;
    6.  
    7. /**
    8.  * @author 小坤
    9.  * @create 2022-11-08-14:31
    10.  */
    11. @Controller
    12. public class PageController {
    13.  
    14.     @RequestMapping("/page/{page}")
    15.     public String page(@PathVariable("page") String page){
    16.  
    17.         return page;
    18.     }
    19.  
    20.     @RequestMapping("/page/{dir}/{page}")
    21.     public String dir(@PathVariable("dir") String dir,@PathVariable("page") String page){
    22.  
    23.         return dir + "/" +page;
    24.     }
    25.  
    26.  
    27. }

     

    跳转没问题喽~~~~~其他页面的跳转都ok了，因为这个类是公共的

     现在可以去编写登录界面的方法一些什么的，创建一个文件包。

       

    验证是否可以使用 

     

     刷新一手，页面弹1就没问题，这样就可以放心写代码了

     login.js ⬇⬇

    1. $(function () {
    2.     alert(1);
    3.   
    4.     //登录向后台发送ajax请求
    5.     $("#login").click(function () {
    6.         let mobile = $("#mobile").val();
    7.         let password = $("#password").val();
    8.  
    9.         $.post("/user/toLogin", {
    10.             mobile: mobile,
    11.             password: password
    12.         },function (res) {
    13.             alert(res.msg)
    14.         },"json");
    15.     });
    16. });

     

    1. package com.xiaokun.spbootpro.model.dto;
    2.  
    3. import lombok.Data;
    4.  
    5. import javax.validation.constraints.NotBlank;
    6.  
    7. @Data
    8. public class UserDto {
    9.     @NotBlank(message = "手机号码不能为空！")
    10. //    @IsMobile
    11.     private String mobile;
    12.     @NotBlank(message = "密码不能为空！")
    13.     private String password;
    14. }

    编写 UserController.java 处理login.js发送的请求
    1. package com.xiaokun.spbootpro.controller;
    2.  
    3.  
    4. import com.xiaokun.spbootpro.model.dto.UserDto;
    5. import com.xiaokun.spbootpro.service.IUserService;
    6. import com.xiaokun.spbootpro.utils.JsonResponseBody;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.web.bind.annotation.RequestMapping;
    9.  
    10. import org.springframework.web.bind.annotation.RestController;
    11.  
    12. import javax.servlet.http.HttpServletRequest;
    13. import javax.servlet.http.HttpServletResponse;
    14.  
    15. /**
    16.  * 
    17.  * 用户信息表 前端控制器
    18.  * 
    19.  *
    20.  * @author xiaokun
    21.  * @since 2022-11-07
    22.  */
    23. @RestController
    24. @RequestMapping("/user")
    25. public class UserController {
    26.  
    27.     @Autowired
    28.     private IUserService userService;
    29.  
    30.     @RequestMapping("/toLogin")
    31.     public JsonResponseBody toLogin(@Valid UserDto userDto, HttpServletRequest req, HttpServletResponse resp){
    32.  
    33.         return userService.toLogin(userDto,req,resp);
    34.     }
    35.  
    36.  
    37. }

    返回JsonResponseBody 

    编写接口类 UserServiceImpl.java

    1. package com.xiaokun.spbootpro.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    4. import com.xiaokun.spbootpro.exception.BusinessException;
    5. import com.xiaokun.spbootpro.model.User;
    6. import com.xiaokun.spbootpro.mapper.UserMapper;
    7. import com.xiaokun.spbootpro.model.dto.UserDto;
    8. import com.xiaokun.spbootpro.service.IUserService;
    9. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    10. import com.xiaokun.spbootpro.utils.JsonResponseBody;
    11. import com.xiaokun.spbootpro.utils.JsonResponseStatus;
    12. import org.springframework.beans.factory.annotation.Autowired;
    13. import org.springframework.stereotype.Service;
    14.  
    15. import javax.servlet.http.HttpServletRequest;
    16. import javax.servlet.http.HttpServletResponse;
    17.  
    18. /**
    19.  * 
    20.  * 用户信息表 服务实现类
    21.  * 
    22.  *
    23.  * @author xiaokun
    24.  * @since 2022-11-07
    25.  */
    26. @Service
    27. public class UserServiceImpl extends ServiceImpl implements IUserService {
    28.     @Autowired
    29.     private UserMapper userMapper;
    30.  
    31.     @Override
    32.     public JsonResponseBody toLogin(UserDto userDto, HttpServletRequest req, HttpServletResponse resp) {
    33. //        1.5.1）判断mobile和password是否为空  @Valid注解帮我做完了
    34. //        1.5.2）判断mobile格式是否正确  @IsMobile注解帮我做完了
    35. //        1.5.3）根据用户手机号码查询用户是否存在
    36.         User user = userMapper.selectOne(new QueryWrapper()
    37.                 .eq("id", userDto.getMobile()));
    38.  
    39. //        1.5.4）校验账号
    40.         if(user==null){
    41.             throw new BusinessException(JsonResponseStatus.USER_USERNAME_ERROR);
    42.         }
    43. //        1.5.5）校验密码
    44.         if(userDto.getPassword().equals(user.getPassword())){
    45.             throw  new BusinessException(JsonResponseStatus.USER_PASSWORD_ERROR);
    46.         }
    47.         return new JsonResponseBody();
    48.     }
    49. }

    数据库明文密码内容 

     测试一波，登录的提示功能

     五、前端及数据库密码加密

    盐加密

    前端加密：防止客户端浏览器F12导致密码泄露

    后端加密：防止数据库数据泄露导致密码泄露

    加载盐加密 

    login.js变更如下

    1. $(function () {
    2.     alert(2);
    3.  
    4.     //登录向后台发送ajax请求
    5.     $("#login").click(function () {
    6.         let mobile = $("#mobile").val();
    7.         let password = $("#password").val();
    8.  
    9.         //1.密码加密
    10.         //1) 定义固定盐
    11.         let salt='f1g2h3j4';
    12.         //2) 固定盐混淆
    13.         let temp=salt.charAt(1)+""+salt.charAt(5)+password+salt.charAt(0)+""+salt.charAt(3);
    14.         //3) 使用MD5完成前端第一次加密
    15.         let pwd=md5(temp);
    16.  
    17.         $.post("/user/toLogin", {
    18.             mobile: mobile,
    19.             password: pwd
    20.         },function (res) {
    21.             if (res.code!=200){
    22.                 alert(res.msg);
    23.             }else
    24.             // alert(res.msg)
    25.                 location.href='/';
    26.         },"json");
    27.     });
    28. });

    UserServiceImpl.java变更如下

    1. package com.xiaokun.spbootpro.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    4. import com.xiaokun.spbootpro.exception.BusinessException;
    5. import com.xiaokun.spbootpro.model.User;
    6. import com.xiaokun.spbootpro.mapper.UserMapper;
    7. import com.xiaokun.spbootpro.model.dto.UserDto;
    8. import com.xiaokun.spbootpro.service.IUserService;
    9. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    10. import com.xiaokun.spbootpro.utils.JsonResponseBody;
    11. import com.xiaokun.spbootpro.utils.JsonResponseStatus;
    12. import com.xiaokun.spbootpro.utils.MD5Utils;
    13. import org.springframework.beans.factory.annotation.Autowired;
    14. import org.springframework.stereotype.Service;
    15. import sun.security.provider.MD5;
    16.  
    17. import javax.servlet.http.HttpServletRequest;
    18. import javax.servlet.http.HttpServletResponse;
    19.  
    20. /**
    21.  * 
    22.  * 用户信息表 服务实现类
    23.  * 
    24.  *
    25.  * @author xiaokun
    26.  * @since 2022-11-07
    27.  */
    28. @Service
    29. public class UserServiceImpl extends ServiceImpl implements IUserService {
    30.     @Autowired
    31.     private UserMapper userMapper;
    32.  
    33.     @Override
    34.     public JsonResponseBody toLogin(UserDto userDto, HttpServletRequest req, HttpServletResponse resp) {
    35. //        1.5.1）判断mobile和password是否为空  @Valid注解帮我做完了
    36. //        1.5.2）判断mobile格式是否正确  @IsMobile注解帮我做完了
    37. //        1.5.3）根据用户手机号码查询用户是否存在
    38.         User user = userMapper.selectOne(new QueryWrapper()
    39.                 .eq("id", userDto.getMobile()));
    40.  
    41. //        1.5.4）校验账号
    42.         if(user==null){
    43.             throw new BusinessException(JsonResponseStatus.USER_USERNAME_ERROR);
    44.         }
    45.  
    46.         //前面传递到后台的密码，要经过工具类MD5加密一次，才有可能跟数据库密码匹配上
    47.         String pwd = MD5Utils.formPassToDbPass(userDto.getPassword(), user.getSalt());
    48.  
    49. //        1.5.5）校验密码
    50.         if(!pwd.equals(user.getPassword())){
    51.             throw new BusinessException(JsonResponseStatus.USER_PASSWORD_ERROR);
    52.         }
    53.         return new JsonResponseBody();
    54.     }
    55. }

    六、服务器客户端登录密码管理

    将登录的用户数据分别保留在客户端以及服务端

    UserServiceImpl.java变更如下

    1. package com.xiaokun.spbootpro.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    4. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    5. import com.xiaokun.spbootpro.exception.BusinessException;
    6. import com.xiaokun.spbootpro.mapper.UserMapper;
    7. import com.xiaokun.spbootpro.model.User;
    8. import com.xiaokun.spbootpro.model.dto.UserDto;
    9. import com.xiaokun.spbootpro.service.IRedisService;
    10. import com.xiaokun.spbootpro.service.IUserService;
    11. import com.xiaokun.spbootpro.utils.CookieUtils;
    12. import com.xiaokun.spbootpro.utils.JsonResponseBody;
    13. import com.xiaokun.spbootpro.utils.JsonResponseStatus;
    14. import com.xiaokun.spbootpro.utils.MD5Utils;
    15. import org.springframework.beans.factory.annotation.Autowired;
    16. import org.springframework.stereotype.Service;
    17.  
    18. import javax.servlet.http.HttpServletRequest;
    19. import javax.servlet.http.HttpServletResponse;
    20. import java.util.UUID;
    21.  
    22. /**
    23.  * @author 小坤
    24.  * @create 2022-11-09-9:18
    25.  */
    26. @Service
    27. public class UserServiceImpl extends ServiceImpl implements IUserService {
    28.  
    29.     @Autowired
    30.     private UserMapper userMapper;
    31.  
    32.     @Autowired
    33.     private IRedisService redisService;
    34.  
    35.     @Override
    36.     public JsonResponseBody toLogin(UserDto userDto, HttpServletRequest req, HttpServletResponse resp) {
    37.         //1.判断账号和密码是否为空（已由JSP303完成）
    38.         //2.判断手机号码格式是否正确（自定义验证注解）
    39.         //3.根据手机号码查询用户对象信息
    40.         User user = userMapper.selectOne(new QueryWrapper()
    41.                 .eq("id", userDto.getMobile()));
    42.         //4.判断用户对象是否存在
    43.         if(null==user)
    44.             throw new BusinessException(JsonResponseStatus.USER_USERNAME_ERROR);
    45.  
    46.         //5.判断用户对象密码与输入密码是否一致
    47.         //将前端传入的第一道加密密码结合从数据库查询出来的随机盐进行加密（二道加密）
    48.         String pwd = MD5Utils.formPassToDbPass(userDto.getPassword(), user.getSalt());
    49.         if(!user.getPassword().equals(pwd))
    50.             throw new BusinessException(JsonResponseStatus.USER_PASSWORD_ERROR);
    51.  
    52.         //6.将登陆用户对象与token令牌进行绑定保存到cookie和redis
    53.         //创建登陆令牌token
    54.         String token= UUID.randomUUID().toString().replace("-","");
    55.         //将token令牌保存到cookie中
    56.         CookieUtils.setCookie(req,resp,"token",token,7200);
    57.         //将登陆token令牌与用户对象user绑定到redis中
    58.         redisService.setUserToRedis(token,user);
    59.         //将用户登陆的昵称设置到cookie中
    60.         CookieUtils.setCookie(req,resp,"nickname",user.getNickname());
    61.         return new JsonResponseBody<>();
    62.     }
    63. }
    IRedisService
    1. package com.xiaokun.spbootpro.service;
    2.  
    3. import com.xiaokun.spbootpro.model.User;
    4.  
    5. /**
    6.  * @author 小坤
    7.  * @create 2022-11-09-8:36
    8.  */
    9. public interface IRedisService {
    10.  
    11.     /**
    12.      * 将用户对象user与登陆token令牌保存到redis
    13.      * @param token 登陆令牌token
    14.      * @param user  登陆用户对象user
    15.      */
    16.     void setUserToRedis(String token, User user);
    17.  
    18.     /**
    19.      * 根据登陆token令牌到redis中获取对应的用户登陆对象信息
    20.      * @param token 登陆令牌token
    21.      * @return 登陆用户对象
    22.      */
    23.     User getUserToRedis(String token);
    24.  
    25. }
    IRedisServiceImpl
    1. package com.xiaokun.spbootpro.service.impl;
    2.  
    3. import com.xiaokun.spbootpro.model.User;
    4. import com.xiaokun.spbootpro.service.IRedisService;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.data.redis.core.RedisTemplate;
    7. import org.springframework.stereotype.Service;
    8.  
    9. import java.util.concurrent.TimeUnit;
    10.  
    11. /**
    12.  * @author 小坤
    13.  * @create 2022-11-09-8:39
    14.  */
    15. @Service
    16. public class IRedisServiceImpl implements IRedisService {
    17.     @Autowired
    18.     private RedisTemplate redisTemplate;
    19.  
    20.     @Override
    21.     public void setUserToRedis(String token, User user) {
    22.         redisTemplate.opsForValue().set("user:"+token,user,7200L, TimeUnit.SECONDS);
    23.     }
    24.  
    25.     @Override
    26.     public User getUserToRedis(String token) {
    27.         return (User)redisTemplate.opsForValue().get("user:"+token);
    28.     }
    29. }

    开启你在application.yml中使用的虚拟机或云服务器​

     并使用虚拟机连接器连接成功后启动redis

     运行测试，前端是否拿到token

  • 相关阅读:
    P01914100尹自杨
    基于ESP32调试ADS1115 16 位 ADC 模块
    【计算机毕业设计】新冠疫情隔离人员信息管理系统+vue源码
    一文讲解ARMv8内存属性与类型（Memory types and attributes）简介
    js获取当前地址栏链接参数
    Java序列化详解（基础入门）
    Vue Router的介绍
    java学习记录
    浅谈shadow dom
    什么是美颜SDK？如何创建自定义美颜直播应用？
  • 原文地址：https://blog.csdn.net/weixin_67450855/article/details/127731922