• 博客系统（ssm版本）

    在前面的文章中给大家介绍过博客系统的servlet版本，但是servlet的技术非常的老旧，我们在企业中用的都是springboot相关的框架，本章内容就是讲述如何一步一步的利用ssm的技术来实现博客系统。

    目录

    前期配置

    创建数据库

    配置文件

    公共文件

    返回数据类

    全局变量

    Session类

    加密类——加盐加密

    加盐加密

    统一处理

    统一数据返回类

    登录拦截器

    拦截规则

    信息类

    个人信息类

    文章类

    个人文章类

    映射层mapper

    UserMapper

    ArticleMapper

    mybatis

    ArticleMapper.xml

    UserMapper.xml

    服务层service

    ArticleService

    UserService

    核心——控制层controller

    UserController

    注册功能

    登录功能

    查询个人信息

    注销功能

    根据用户id查找用户信息

    ArticleController

    返回用户文章列表

    删除文章功能

    查看文章详情功能

    实现阅读量功能

    添加文章

    修改文章

    根据分页来查询列表

    前期配置

    当我们创建完一个spring项目之后我们首先就是要准备好相关的配置文件以及创建好数据库。

    创建数据库

    1. -- 创建数据库
    2. drop database if exists mycnblog;
    3. create database mycnblog DEFAULT CHARACTER SET utf8mb4;
    4.  
    5. -- 使用数据数据
    6. use mycnblog;
    7.  
    8. -- 创建表[用户表]
    9. drop table if exists  userinfo;
    10. create table userinfo(
    11.     id int primary key auto_increment,
    12.     username varchar(100) not null unique,
    13.     password varchar(100) not null,
    14.     photo varchar(500) default '',
    15.     createtime datetime default now(),
    16.     updatetime datetime default now(),
    17.     `state` int default 1
    18. ) default charset 'utf8mb4';
    19.  
    20. -- 创建文章表
    21. drop table if exists  articleinfo;
    22. create table articleinfo(
    23.     id int primary key auto_increment,
    24.     title varchar(100) not null,
    25.     content text not null,
    26.     createtime datetime default now(),
    27.     updatetime datetime default now(),
    28.     uid int not null,
    29.     rcount int not null default 1,
    30.     `state` int default 1
    31. )default charset 'utf8mb4';
    32.  
    33. -- 创建视频表
    34. drop table if exists videoinfo;
    35. create table videoinfo(
    36.   	vid int primary key,
    37.   	`title` varchar(250),
    38.   	`url` varchar(1000),
    39. 		createtime datetime default now(),
    40. 		updatetime datetime default now(),
    41.   	uid int
    42. )default charset 'utf8mb4';
    43.  
    44. -- 添加一个用户信息
    45. INSERT INTO `mycnblog`.`userinfo` (`id`, `username`, `password`, `photo`, `createtime`, `updatetime`, `state`) VALUES 
    46. (1, 'admin', 'admin', '', '2021-12-06 17:10:48', '2021-12-06 17:10:48', 1);
    47.  
    48. -- 文章添加测试数据
    49. insert into articleinfo(title,content,uid)
    50.     values('Java','Java正文',1);
    51.     
    52. -- 添加视频
    53. insert into videoinfo(vid,title,url,uid) values(1,'java title','http://www.baidu.com',1);

    配置文件

    1. # 生产环境配置文件
    2. spring:
    3.   datasource:
    4.     url: jdbc:mysql://127.0.0.1:3306/mycnblog?characterEncoding=utf8&useSSL=false
    5.     username: "root"
    6.     password: 
    7.     driver-class-name: com.mysql.cj.jdbc.Driver
    8.   redis:
    9.     host: 127.0.0.1
    10.     port: 6379
    11.     database: 1
    12.   session:
    13.     store-type: redis
    14.     redis:
    15.       flush-mode: on_save
    16.       namespace: spring:session
    17. # 设置过期时间
    18. server:
    19.   port: 8081
    20.   servlet:
    21.     session:
    22.       timeout: 1800
    23. # 配置 mybatis xml 保存路径
    24. mybatis:
    25.   mapper-locations: classpath:mybatis/**Mapper.xml
    26.   configuration:
    27.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    28.  
    29. logging:
    30.   level:
    31.     com:
    32.       example:
    33.         demo: debug
    34.  
    35.

    接着将我们的前端文件给导入static中。

     如此一来我们就创建完项目并且连接上我们的mysql数据库了，接下来就是去实现我们的相关的代码了。

    公共文件

     common包顾名思义就是存放我们的公共的类，这些类可能在不同的层面都会用到所以我们将这些都会用到的类放在了一起。

    返回数据类

    我们在实现前端的交互的时候，我们肯定需要规定好前后端数据传输的格式，我们后端传一个什么类型的数据，我们前端接受一个什么格式的数据，所以我们统一的规定好这些格式之后可以大大的减少前后端的联调时间。

    1. package com.example.demo.common;
    2.  
    3. /**
    4.  * Created with IntelliJ IDEA.
    5.  * Description:
    6.  * User: 86184
    7.  * Date: 2023-05-16
    8.  * Time: 22:27
    9.  */
    10.  
    11. import lombok.Data;
    12.  
    13. import java.io.Serializable;
    14.  
    15. /**
    16. * 统一数据格式返回
    17. */
    18. @Data
    19. public class AjaxResult implements Serializable { //实现序列化的接口
    20.     //状态码
    21.     private Integer code;
    22.     //状态码描述信息
    23.     private String msg;
    24.     //返回的数据
    25.     private Object data;
    26.  
    27.     /**
    28.      *  操作成功返回的结果
    29.      */
    30.     public static AjaxResult success(Object data) {
    31.         AjaxResult result = new AjaxResult();
    32.         result.setCode(200);
    33.         result.setMsg("");
    34.         result.setData(data);
    35.         return result;
    36.     }
    37.     public static AjaxResult success(int code, Object data) {
    38.         AjaxResult result = new AjaxResult();
    39.         result.setCode(code);
    40.         result.setMsg("");
    41.         result.setData(data);
    42.         return result;
    43.     }
    44.     public static AjaxResult success(int code, String msg, Object data) {
    45.         AjaxResult result = new AjaxResult();
    46.         result.setCode(code);
    47.         result.setMsg(msg);
    48.         result.setData(data);
    49.         return result;
    50.     }
    51.     /**
    52.      * 返回失败的结果
    53.      */
    54.     public static AjaxResult fail(int code, String msg) {
    55.         AjaxResult result = new AjaxResult();
    56.         result.setCode(code);
    57.         result.setMsg(msg);
    58.         result.setData(null);
    59.         return result;
    60.     }
    61.     public static AjaxResult fail(int code, String msg, Object data) {
    62.         AjaxResult result = new AjaxResult();
    63.         result.setCode(code);
    64.         result.setMsg(msg);
    65.         result.setData(data);
    66.         return result;
    67.     }
    68.  
    69. }

    这里我们定义了一个AjaxResult的类其中该类实现了Serializable接口，实现了这个接口表示该类的对象可以通过序列化机制转换为字节流，并且可以在网络上传输、存储到文件中或在不同的Java虚拟机之间进行传递。序列化是将对象转换为字节序列的过程，反序列化则是将字节序列转换回对象的过程。

    1. 该类包括我们的状态码，状态码的描述信息，以及返回的数据。
    2. 该类重载了一些静态的返回方法分别表示我们返回成功或者返回失败的情况。

    全局变量

    1. package com.example.demo.common;
    2.  
    3. /**
    4.  * Created with IntelliJ IDEA.
    5.  * Description:
    6.  * User: 86184
    7.  * Date: 2023-05-17
    8.  * Time: 16:27
    9.  */
    10. // 存放全局变量
    11. public class AppVariable {
    12.     //session的名称
    13.     public static final String USER_SESSION_KEY = "USER_SESSION_KEY";
    14. }

    此类存放我们的全局变量。

    Session类

    1. package com.example.demo.common;
    2.  
    3. import com.example.demo.entity.Userinfo;
    4.  
    5. import javax.servlet.http.HttpServletRequest;
    6. import javax.servlet.http.HttpSession;
    7.  
    8. /**
    9.  * Created with IntelliJ IDEA.
    10.  * Description:当前登录用户相关的操作
    11.  * User: 86184
    12.  * Date: 2023-05-17
    13.  * Time: 23:48
    14.  */
    15. public class UserSessionUtils {
    16.     public static Userinfo getSessionUser(HttpServletRequest request) {
    17.         HttpSession session = request.getSession(false);
    18.         if (session != null && session.getAttribute(AppVariable.USER_SESSION_KEY)!=null) {
    19.             //说明用户已经正常登录了
    20.             return (Userinfo) session.getAttribute(AppVariable.USER_SESSION_KEY);
    21.         }
    22.         return null;
    23.     }
    24. }

    这里我们准备了一个session工具类，该类主要是返回我们是否存储了session，然后将此session中的userinfo给取出来然后返回。这里我们可以看到我们用的是一个静态的方法这就方便我们的调用了，用的时候不需要去注入或者new了。

    加密类——加盐加密

    1. package com.example.demo.common;
    2.  
    3. import org.springframework.util.DigestUtils;
    4. import org.springframework.util.StringUtils;
    5.  
    6. import java.util.UUID;
    7.  
    8. /**
    9.  * Created with IntelliJ IDEA.
    10.  * Description:密码加密工具类
    11.  * User: 86184
    12.  * Date: 2023-05-21
    13.  * Time: 21:40
    14.  */
    15. public class PasswordUtils {
    16.     // 1.加盐并且生成密码
    17.     public static String encrypt(String password){
    18.         // a.产生盐值(32)位
    19.         String salt = UUID.randomUUID().toString().replace("-","");
    20.         // b.生成加盐之后的密码
    21.         String saltPassword = DigestUtils.md5DigestAsHex((salt+password).getBytes());
    22.         // c.生成最终的密码(保存到数据库中的密钥)【约定格式为32位盐+$+32位加盐之后的密码】
    23.         String finalPassword = salt+"$"+saltPassword;
    24.         return finalPassword;
    25.     }
    26.     // 2.生成加盐的密码(重载方法一)
    27.     public static String encrypt(String password, String salt){
    28.         // 1.生成加盐之后的密码
    29.         String saltPassword = DigestUtils.md5DigestAsHex((salt+password).getBytes());
    30.         // 2.生成最终的密码(保存到数据库中的密钥)【约定格式为32位盐+$+32位加盐之后的密码】
    31.         String finalPassword = salt+"$"+saltPassword;
    32.         return finalPassword;
    33.     }
    34.     // 3.密码验证
    35.     public static boolean check(String inputPassword, String finalPassword){
    36.         if (StringUtils.hasLength(inputPassword)&&StringUtils.hasLength(finalPassword)&&finalPassword.length()==65){
    37.             // 1.得到盐值
    38.             String salt = finalPassword.split("\\$")[0];
    39.             // 2.将输入的密码进行加盐加密
    40.             String confirmPassword = PasswordUtils.encrypt(inputPassword,salt);
    41.             // 3.对比两个最终密码是否相等
    42.             return confirmPassword.equals(finalPassword);
    43.         }
    44.         return false;
    45.     }
    46.  
    47. }

    加盐加密

    一般情况下如果我们的密码没有进行加密的话是非常的危险的，一旦被拖库了是非常的危险的，我们的用户信息，特别是密码会全部被别人获取，所以我们就需要防止这种情况的产生，想要防止密码被人看到的话就得对我们的密码进行加密然后将加密后的密码存入数据库中去，这样的好处就是即使我的密码被你看到了你也不知道原密码是多少。

    md5: md5是一种比较常用的加密方式它是将任意长度的输入通过一个算法然后生成一个128位的输出，通常情况下是用32位的16进制来表示，其特点其加密是不可逆的即加密之后不能通过加密的数据来推测出未加密的密码。

    缺点：md5的加密虽然是不可逆的当时还是有一个致命的问题即我们每次对同一个密码的加密其结果是固定的那么如果我们穷举出所有的字符的话那么我们就可以推测出所有的密码了，这就是我们的彩虹表，彩虹表里面以类似键值对的方式将我们的密码以及md5加密的密码存储起来然后不断的去完善这各彩虹表，对于绝大多数的密码我们都可以通过彩虹表来找到的，这就存在一定的风险了。

    加盐原理：加盐算法可以解决md5被暴力破解的问题，我们在用md5算法对我们的密码进行加密的时候会给原密码加上一个随机数也就是我们的盐，这样即使是同一个密码加盐之后生成的加密密码也不一样所以就大大增加了密码破译的成本。

    统一处理

    我们创建了一个config的包，这个包里面存放的是我们我么统一处理的相关类包括我们的统一登录验证，统一数据返回，统一异常处理等。

    统一数据返回类

    1. package com.example.demo.config;
    2.  
    3. /**
    4.  * Created with IntelliJ IDEA.
    5.  * Description:
    6.  * User: 86184
    7.  * Date: 2023-05-16
    8.  * Time: 23:02
    9.  */
    10.  
    11. import com.example.demo.common.AjaxResult;
    12. import com.fasterxml.jackson.databind.ObjectMapper;
    13. import lombok.SneakyThrows;
    14. import org.springframework.beans.factory.annotation.Autowired;
    15. import org.springframework.core.MethodParameter;
    16. import org.springframework.http.MediaType;
    17. import org.springframework.http.server.ServerHttpRequest;
    18. import org.springframework.http.server.ServerHttpResponse;
    19. import org.springframework.web.bind.annotation.ControllerAdvice;
    20. import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
    21.  
    22. /**
    23.  * 实现统一返回的保底类
    24.  * 说明：在返回数据之前，检测数据类型是否为统一的对象，如果不是，封装成统一的对象
    25.  */
    26. @ControllerAdvice
    27. public class ResponseAdvice implements ResponseBodyAdvice {
    28.     @Autowired
    29.     private ObjectMapper objectMapper;
    30.     /**
    31.      * 开关，如果是true才会调用beforeBodyWrite
    32.      */
    33.     @Override
    34.     public boolean supports(MethodParameter returnType, Class converterType) {
    35.         return true;
    36.     }
    37.     // 对数据的格式进行校验和封装
    38.     @SneakyThrows
    39.     @Override
    40.     public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
    41.         if (body instanceof AjaxResult) return body;
    42.         //对String类型进行特殊的处理
    43.         if (body instanceof String) {
    44.             return objectMapper.writeValueAsString(AjaxResult.success(body));
    45.         }
    46.         return AjaxResult.success(body);
    47.     }
    48. }

    先前我们只是准备好了统一返回的类，但是为了以防万一我们做了一个保底类通ControllerAdvice注解将其作用与我们的控制器中。

    1. 该类实现了ResponseBodyAdvice 接口允许在返回数据之前对返回的数据进行校验和修改。
    2. 对String类型的数据进行了特殊的处理，String类型不同与我们一般的类型我们注入了ObjectMapper对象将我们的String类型转换成json格式。

    登录拦截器

    1. package com.example.demo.config;
    2.  
    3. import com.example.demo.common.AppVariable;
    4. import com.example.demo.entity.Userinfo;
    5. import org.springframework.web.servlet.HandlerInterceptor;
    6.  
    7. import javax.servlet.http.HttpServletRequest;
    8. import javax.servlet.http.HttpServletResponse;
    9. import javax.servlet.http.HttpSession;
    10.  
    11. /**
    12.  * Created with IntelliJ IDEA.
    13.  * Description:
    14.  * User: 86184
    15.  * Date: 2023-05-17
    16.  * Time: 16:34
    17.  */
    18.  
    19. /**
    20.  * 登录拦截器
    21.  */
    22. public class LoginInterceptor implements HandlerInterceptor {
    23.     @Override
    24.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    25.         HttpSession session = request.getSession(false);
    26.         if (session!=null && session.getAttribute(AppVariable.USER_SESSION_KEY)!=null) {
    27.             //用户已经登录
    28. //            System.out.println(((Userinfo)session.getAttribute(AppVariable.USER_SESSION_KEY)).getUsername());
    29.             return true;
    30.         }
    31.         //调整到登录界面
    32.         response.sendRedirect("/login.html");
    33.         return false;
    34.     }
    35. }

    我们在进入一个页面的时候可能需要查看我们当前的用户有没有登录，所以我们需要对我们的有误登录做一个拦截。

    拦截处理如下：我们首先需要获取当前的session，然后判断有没有存储指定的session，如果存在的话那就返回true意味着继续执行后续的代码，如果不是那就直接跳转到登录的页面，后续的代码自然也就不执行了返回false。

    拦截规则

    1. package com.example.demo.config;
    2.  
    3. import org.springframework.context.annotation.Configuration;
    4. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    5. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    6.  
    7. /**
    8.  * Created with IntelliJ IDEA.
    9.  * Description:
    10.  * User: 86184
    11.  * Date: 2023-05-17
    12.  * Time: 16:58
    13.  */
    14. @Configuration
    15. public class AppConfig implements WebMvcConfigurer {
    16.     @Override
    17.     public void addInterceptors(InterceptorRegistry registry) {
    18.         registry.addInterceptor(new LoginInterceptor())
    19.                 .addPathPatterns("/**")
    20.                 .excludePathPatterns("/css/**")
    21.                 .excludePathPatterns("/editor.md/**")
    22.                 .excludePathPatterns("/img/**")
    23.                 .excludePathPatterns("/js/**")
    24.                 .excludePathPatterns("/login.html")
    25.                 .excludePathPatterns("/reg.html")
    26.                 .excludePathPatterns("/art/detail")
    27.                 .excludePathPatterns("/blog_content.html")
    28.                 .excludePathPatterns("/user/login")
    29.                 .excludePathPatterns("/user/logout")
    30.                 .excludePathPatterns("/user/getuserbyid")
    31.                 .excludePathPatterns("/user/reg")
    32.                 .excludePathPatterns("/art/listbypage")
    33.                 .excludePathPatterns("/art/incr-rcount");
    34.     }
    35. }

    我们在实际的时候不是对所有的请求都去进行一个拦截的我们会拦截部分的请求然后同样的也是会放开一些的请求，此类就是用来处理我们需要拦截哪些放开哪些东西，并且我们加入congiguration的注解会随着框架的启动而生效。

    信息类

     这里我们创建了一个entity的包，包里面的类对应着我们各个表的数据成员以及我们想要返回的特殊数据集合。

    个人信息类

    1. package com.example.demo.entity;
    2.  
    3. import lombok.Data;
    4.  
    5. import java.time.LocalDateTime;
    6.  
    7. /**
    8.  * Created with IntelliJ IDEA.
    9.  * Description:
    10.  * User: 86184
    11.  * Date: 2023-05-17
    12.  * Time: 10:53
    13.  */
    14. @Data
    15. public class Userinfo {
    16.     private Integer id;
    17.     private String username;
    18.     private String password;
    19.     private String photo;
    20.     private LocalDateTime createtime;
    21.     private LocalDateTime uptatetime;
    22. }

    用户信息类顾名思义就是我们单个用户信息的类对应着我们数据库中的userinfo这张表。

    文章类

    1. package com.example.demo.entity;
    2.  
    3. import com.fasterxml.jackson.annotation.JsonFormat;
    4. import lombok.Data;
    5.  
    6. import java.time.LocalDateTime;
    7.  
    8. /**
    9.  * Created with IntelliJ IDEA.
    10.  * Description:
    11.  * User: 86184
    12.  * Date: 2023-05-18
    13.  * Time: 10:47
    14.  */
    15. @Data
    16. public class ArticleInfo {
    17.     private Integer id;
    18.     private String title;
    19.     private String content;
    20.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
    21.     private LocalDateTime createtime;
    22.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
    23.     private LocalDateTime updatetime;
    24.     private Integer uid;
    25.     private Integer rcount;
    26.     private Integer state;
    27.  
    28. }

    该类定义了我们的文章类，此类中是我们文章的相关信息，其中包括我们的文章id文章的目录还有文章的内容等。

    个人文章类

    1. package com.example.demo.entity;
    2.  
    3. import lombok.Data;
    4.  
    5. /**
    6.  * Created with IntelliJ IDEA.
    7.  * Description:
    8.  * User: 86184
    9.  * Date: 2023-05-17
    10.  * Time: 19:49
    11.  */
    12. @Data
    13. public class UserinfoVO extends Userinfo{
    14.     private Integer artCount;// 本人发表的文章总数
    15. }

    我们的个人文章类相比个人信息类多了一个artCount的字段用于记录我们当前用户的文章数量。

    该类主要用于处理下面这个界面：

    映射层mapper

     我们创建了一个mapper的包，包里面放了一些映射我们sql语句的接口。

    UserMapper

    1. package com.example.demo.mapper;
    2.  
    3. import com.example.demo.entity.Userinfo;
    4. import org.apache.ibatis.annotations.Mapper;
    5. import org.apache.ibatis.annotations.Param;
    6.  
    7. /**
    8.  * Created with IntelliJ IDEA.
    9.  * Description:
    10.  * User: 86184
    11.  * Date: 2023-05-17
    12.  * Time: 10:48
    13.  */
    14. //定义响应的sql接口
    15. @Mapper
    16. public interface UserMapper {
    17.     // 注册
    18.     int reg(Userinfo userinfo);
    19.  
    20.     // 根据用户查询 userinfo 对象
    21.     Userinfo getUserByName(@Param("username") String username);
    22.  
    23.     //根据用户信息查询用户的信息
    24.     Userinfo getUserById(@Param("id") Integer id);
    25.  
    26.  
    27. }

    userMapper里面存放着关于userinfo表的一些sql的接口。

    ArticleMapper

    1. package com.example.demo.mapper;
    2.  
    3. import com.example.demo.entity.ArticleInfo;
    4. import org.apache.ibatis.annotations.Mapper;
    5. import org.apache.ibatis.annotations.Param;
    6.  
    7. import java.util.List;
    8.  
    9. /**
    10.  * Created with IntelliJ IDEA.
    11.  * Description:定义sql接口
    12.  * User: 86184
    13.  * Date: 2023-05-17
    14.  * Time: 19:30
    15.  */
    16. @Mapper
    17. public interface ArticleMapper {
    18.     //根据用户id返回作品的数量
    19.     int getArtCountByUid(@Param("uid") Integer uid);
    20.     //根据用户的id返回用户的所有文章
    21.     List getMyList(@Param("uid") Integer uid);
    22.     //删除文章
    23.     int del(@Param("id")Integer id,@Param("uid")Integer uid);
    24.     //得到文章详情
    25.     ArticleInfo getDetail(@Param("id") Integer id);
    26.     // 更新文章的数量+1
    27.     int incrRCount(@Param("id") Integer id);
    28.     // 添加文章操作
    29.     int add(ArticleInfo articleInfo);
    30.     // 更新文章操作
    31.     int update(ArticleInfo articleInfo);
    32.     // 实现分页的sql
    33.     List getListByPage(@Param("psize") Integer psize, @Param("offsize") Integer offsize);
    34.     // 查找总页数
    35.     int getCount();
    36. }

    此类用来处理我们关于文章sql的一些映射。

    mybatis

     mybatis包中存放着我们的xml文件也就是来实现我们的sql接口里面的查询。

    ArticleMapper.xml

    这是关于文章操作的sql语句。

    1. "1.0" encoding="UTF-8"?>
    2. mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    4. <mapper namespace="com.example.demo.mapper.ArticleMapper">
    5.     <select id="getArtCountByUid" resultType="Integer">
    6.         select count(*) from articleinfo where uid = #{uid};
    7.     select>
    9.     <select id="getMyList" resultType="com.example.demo.entity.ArticleInfo">
    10.         select * from articleinfo where uid=#{uid}
    11.     select>
    12.     <delete id="del">
    13.         delete from articleinfo where id=#{id} and uid=#{uid}
    14.     delete>
    15.     <select id="getDetail" resultType="com.example.demo.entity.ArticleInfo">
    16.         select * from articleinfo where id=#{id}
    17.     select>
    18.     <update id="incrRCount">
    19.         update articleinfo set rcount=rcount+1 where id=#{id}
    20.     update>
    21.     <insert id="add">
    22.         insert into articleinfo(title,content,uid,updatetime,createtime) values(#{title},#{content},#{uid},#{updatetime},#{createtime})
    23.     insert>
    24.     <update id="update">
    25.         update articleinfo set title=#{title},content=#{content},updatetime=#{updatetime}
    26.         where id=#{id} and uid=#{uid}
    27.     update>
    28.     <select id="getListByPage" resultType="com.example.demo.entity.ArticleInfo">
    29.         select * from articleinfo limit #{psize} offset #{offsize}
    30.     select>
    31.     <select id="getCount" resultType="Integer">
    32.         select count(*) from articleinfo;
    33.     select>
    34. mapper>

    UserMapper.xml

    这是关于用户操作的sql语句。

    1. "1.0" encoding="UTF-8"?>
    2. mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    4. <mapper namespace="com.example.demo.mapper.UserMapper">
    5.     <insert id="reg">
    6.         insert into userinfo(username,password) values(#{username},#{password})
    7.     insert>
    8.     <select id="getUserByName" resultType="com.example.demo.entity.Userinfo">
    9.         select * from userinfo where username=#{username}
    10.     select>
    11.     <select id="getUserById" resultType="com.example.demo.entity.Userinfo">
    12.         select * from userinfo where id=#{id}
    13.     select>
    14. mapper>

    服务层service

    服务层负责将我们的写好sql语句封装成方法进而方便我们控制层的调用，因为我们的接口层一次性只处理一个sql操作，当我们某一个功能想要完成两个甚至以上的操作的时候就需要我们的service层将这些sql操作给封装起来然后调用起来将会很方便。

    ArticleService

    1. package com.example.demo.service;
    2.  
    3. import com.example.demo.entity.ArticleInfo;
    4. import com.example.demo.mapper.ArticleMapper;
    5. import org.springframework.stereotype.Service;
    6.  
    7. import javax.annotation.Resource;
    8. import java.util.List;
    9.  
    10. /**
    11.  * Created with IntelliJ IDEA.
    12.  * Description:服务层代码，提供sql查询结果
    13.  * User: 86184
    14.  * Date: 2023-05-17
    15.  * Time: 19:45
    16.  */
    17. @Service
    18. public class ArticleService {
    19.     @Resource
    20.     private ArticleMapper articleMapper;
    21.     public int getArtCountByUid(Integer uid) {
    22.         return articleMapper.getArtCountByUid(uid);
    23.     }
    24.     public List getMyList(Integer uid) {
    25.         return articleMapper.getMyList(uid);
    26.     }
    27.     public int del(Integer id,Integer uid) {
    28.         return articleMapper.del(id,uid);
    29.     }
    30.     public ArticleInfo getDetail(Integer id) {
    31.         return articleMapper.getDetail(id);
    32.     }
    33.     public int incrRCount(Integer id) {
    34.         return articleMapper.incrRCount(id);
    35.     }
    36.     public int add(ArticleInfo articleInfo) {
    37.         return articleMapper.add(articleInfo);
    38.     }
    39.     public int update(ArticleInfo articleInfo) {
    40.         return articleMapper.update(articleInfo);
    41.     }
    42.     public List getListByPage(Integer psize, Integer offsize){
    43.         return articleMapper.getListByPage(psize, offsize);
    44.     }
    45.     public int getCount() {
    46.         return articleMapper.getCount();
    47.     }
    48. }

    UserService

    1. package com.example.demo.service;
    2.  
    3. import com.example.demo.entity.Userinfo;
    4. import com.example.demo.mapper.UserMapper;
    5. import org.springframework.stereotype.Service;
    6.  
    7. import javax.annotation.Resource;
    8.  
    9. /**
    10.  * Created with IntelliJ IDEA.
    11.  * Description:
    12.  * User: 86184
    13.  * Date: 2023-05-17
    14.  * Time: 11:45
    15.  */
    16. //服务层的代码
    17. @Service
    18. public class UserService {
    19.     @Resource
    20.     private UserMapper userMapper;
    21.     // 用户注册
    22.     public int reg(Userinfo userinfo) {
    23.         return userMapper.reg(userinfo);
    24.     }
    25.     // 根据用户姓名获取用户信息
    26.     public Userinfo getUserByName(String username) {
    27.         return userMapper.getUserByName(username);
    28.     }
    29.     // 根据用户id 获取用户信息
    30.     public Userinfo getUserById(Integer id) {
    31.         return userMapper.getUserById(id);
    32.     }
    33. }

    核心——控制层controller

    控制层也是我们最为核心的一层，负责我们各种逻辑的时间。

    UserController

    注册功能

    1.     @RequestMapping("/reg")
    2.     public AjaxResult reg(Userinfo userinfo) {
    3.         // 非空校验
    4.         if (userinfo==null || !StringUtils.hasLength(userinfo.getUsername())||!StringUtils.hasLength(userinfo.getPassword())) {
    5.             return AjaxResult.fail(-1,"非法参数");
    6.         }
    7.         return AjaxResult.success(userService.reg(userinfo));
    8.     }

    在实现注册功能的时候：

    1. 前端在经过一系列的校验之后会给我们传过来一组json数据。
    2. 我们用userinfo接受这个数据然后对其进行一个参数的校验。
    3. 调用数据库然后将数据插入其中。

    插入语句：

    1.     <insert id="reg">
    2.         insert into userinfo(username,password) values(#{username},#{password})
    3.     insert>

    登录功能

    1.     @RequestMapping("/login")
    2.     public AjaxResult login(HttpServletRequest request, String username, String password) {
    3.         // 1.非空校验
    4.         if (!StringUtils.hasLength(username)||!StringUtils.hasLength(password)) {
    5.             return AjaxResult.fail(-1,"非法请求");
    6.         }
    7.         // 2.查询数据库
    8.         Userinfo userinfo = userService.getUserByName(username);
    9.         if (userinfo != null && userinfo.getId()>0) {
    10.             // 有效的用户名
    11.             // 两个密码完全相同
    12.             if (password.equals(userinfo.getPassword())) {
    13.                 // 登录成功
    14.                 // 将用户存储到session中
    15.                 HttpSession session = request.getSession();
    16.                 session.setAttribute(AppVariable.USER_SESSION_KEY,userinfo);
    17.  
    18.                 userinfo.setPassword("");// 返回数据之前将敏感的信息给隐藏起来
    19.                 return AjaxResult.success(userinfo);
    20.             }
    21.         }
    22.         return AjaxResult.success(0,null);
    23.     }

    对于登录功能：

    1. 首先先进行一个非空校验，判断一下我们传进来的用户名和密码是否为空。
    2. 拿着我们传进来的用户名进行一个查询，查询到我们当前用户的基本信息。
    3. 把我们拿到的用户的基本信息中的password与传给我们的password进行一个对比。
    4. 将用户的密码给置空然后返回数据到前端。

    查询个人信息

    1.     @RequestMapping("/showinfo")
    2.     public AjaxResult showInfo(HttpServletRequest request) {
    3.         UserinfoVO userinfoVO = new UserinfoVO();
    4.         //1.得到当前登录的用户
    5.         Userinfo userinfo = UserSessionUtils.getSessionUser(request);
    6.         if (userinfo==null) {
    7.             return AjaxResult.fail(-1,"非法请求");
    8.         }
    9.         //spring提供的深拷贝
    10.         BeanUtils.copyProperties(userinfo, userinfoVO);
    11.         //2.得到用户发表文章的总数
    12.         int count = articleService.getArtCountByUid(userinfo.getId());
    13.         userinfoVO.setArtCount(count);
    14.         return AjaxResult.success(userinfoVO);
    15.     }

    这块代码实现的功能为返回我们当前登录用户的个人信息，包括用户名和当前的文章数量。

    这里我们需要返回用户的文章数量，所以先从我们的session中获取到当前的用户，接着我们用了一个spring所提供的深拷贝的方法将我们的userinfo拷贝给userinfoVO类，接着利用我们的用户id通过sql语句查询到文章的数量。

    sql语句：

    1.     <select id="getArtCountByUid" resultType="Integer">
    2.         select count(*) from articleinfo where uid = #{uid};
    3.     select>

    最后将我们的文章数给设置到userinfoVO中里面去。

    注销功能

    1.     //注销功能
    2.     @RequestMapping("/logout")
    3.     public AjaxResult logout(HttpSession session) {
    4.         session.removeAttribute(AppVariable.USER_SESSION_KEY);
    5.         return AjaxResult.success(1);
    6.     }

    在我们登录完了之后可能需要去注销我们的登录，这个时候我们就需要去实现我们的登录功能了，其实现的方式也很简单，就是将我们的session给移除就可以了。

    根据用户id查找用户信息

    1.     @RequestMapping("/getuserbyid")
    2.     public AjaxResult getUserById(Integer id) {
    3.         if (id==null || id<=0) {
    4.             // 无参数
    5.             return AjaxResult.fail(-1,"非法参数");
    6.         }
    7.         // 查询到当前用户的信息
    8.         Userinfo userinfo = userService.getUserById(id);
    9.         if (userinfo==null||userinfo.getId()<=0){
    10.             // 无参数
    11.             return AjaxResult.fail(-1,"非法参数");
    12.         }
    13.         // 去除userinfo中的敏感信息
    14.         userinfo.setPassword("");
    15.         UserinfoVO userinfoVO = new UserinfoVO();
    16.         // 拷贝数据
    17.         BeanUtils.copyProperties(userinfo,userinfoVO);
    18.         // 查询当前用户发表的文章数
    19.         userinfoVO.setArtCount(articleService.getArtCountByUid(id));
    20.         return AjaxResult.success(userinfoVO);
    21.  
    22.     }

    在我们的文章列表页面的时候会有很多的文章，当我们点击一条文章的时候然后我们就需要获取此用户的信息了。

    ArticleController

    我们的ArticleController主要是用来处理我们的文章信息的其对应的是我们的文章表，也就是说用来操作我们的文章表以此来返回我们的文章表中的相关的数据。

    返回用户文章列表

    1.     @Autowired
    2.     private ArticleService articleService;
    3.     @RequestMapping("/mylist")
    4.     public AjaxResult getMyList(HttpServletRequest request) {
    5.         Userinfo userinfo = UserSessionUtils.getSessionUser(request);
    6.         if (userinfo==null) {
    7.             return AjaxResult.fail(-1,"非法请求");
    8.  
    9.         }
    10.         List list = articleService.getMyList(userinfo.getId());
    11.         return AjaxResult.success(list);
    12.     }

    在我们处理这个功能的时候我们的思路是首先通过session获取到我们当前用户的id然后拿着这个去查询我们当前用户的所有文章。

    sql语句：

    2.     <select id="getMyList" resultType="com.example.demo.entity.ArticleInfo">
    3.         select * from articleinfo where uid=#{uid}
    4.     select>

    删除文章功能

    1.     @RequestMapping("/del")
    2.     public AjaxResult del(HttpServletRequest request,Integer id) {
    3.         if (id==null||id<=0) {
    4.             //参数有误
    5.             return AjaxResult.fail(-1,"参数异常");
    6.         }
    7.         Userinfo userinfo = UserSessionUtils.getSessionUser(request);
    8.         if (userinfo==null) {
    9.             return AjaxResult.fail(-2,"用户未登录");
    10.         }
    11.         return AjaxResult.success(articleService.del(id,userinfo.getId()));
    12.     }

    删除文章的功能首先还是要先做相应的参数校验，接着就是通过sql去删除数据库中的数据了，我们在删除的时候需要传进来两个参数，一个是我们文章的id一个是我们当前登录用户的id，我们带着这两个id去数据库中去查询，也就是说我们文章id必须有对应的作者的id否则我们就会查询不到相应的数据所以删除的时候影响行数就是0了，我们前端在得到这个0后就会提示删除有误。

    sql语句:

    1.     <delete id="del">
    2.         delete from articleinfo where id=#{id} and uid=#{uid}
    3.     delete>

    查看文章详情功能

    1.     @RequestMapping("/detail")
    2.     public AjaxResult getDetail(Integer id) {
    3.         if (id==null||id<=0) {
    4.             return AjaxResult.fail(-1,"非法参数");
    5.         }
    6.         return AjaxResult.success(articleService.getDetail(id));
    7.     }

    查看文章的详情功能就比较的容易了，我们只需要根据我们的用户id来查询当前的文章。

    sql语句：

    1.     <select id="getDetail" resultType="com.example.demo.entity.ArticleInfo">
    2.         select * from articleinfo where id=#{id}
    3.     select>

    实现阅读量功能

    1.     // 阅读加1
    2.     @RequestMapping("incr-rcount")
    3.     public AjaxResult incrRCount(Integer id) {
    4.         if (id!=null&& id>0) {
    5.             return AjaxResult.success(articleService.incrRCount(id));
    6.         }
    7.         return AjaxResult.success(-1,"未知错误");
    8.     }

    此接口用户处理我们的访问量的功能，当我们访问一篇文章的时候如果我们刷新该文章那么该文章的访问量就会加1，实现该功能的时候我们可以用一条sql完成。

    update articleinfo set rcount=rcount+1 where id=#{id}

    添加文章

    1.     //添加文章
    2.     @RequestMapping("/add")
    3.     public AjaxResult add(ArticleInfo articleInfo,HttpServletRequest request) {
    4.         //1.非空校验
    5.         if (articleInfo==null||!StringUtils.hasLength(articleInfo.getTitle())||!StringUtils.hasLength(articleInfo.getContent())){
    6.             //非法参数
    7.             return AjaxResult.fail(-1,"非法参数");
    8.         }
    9.         //2.数据库添加操作
    10.         //a得到当前登录用户的uid
    11.         Userinfo userinfo = UserSessionUtils.getSessionUser(request);
    12.         if (userinfo==null||userinfo.getId()<=0) {
    13.             //无效的登录用户
    14.             return AjaxResult.fail(-2,"无效的登录用户");
    15.         }
    16.         //设置用户的id
    17.         articleInfo.setUid(userinfo.getId());
    18.         articleInfo.setUpdatetime(LocalDateTime.now());
    19.         //b添加数据库并且返回结果
    20.         return AjaxResult.success(articleService.add(articleInfo));
    21.     }

    添加文章的接口：先做一些非空校验然后通过session得到当前用户的一些信息，最后将请求中的相关信息写入数据库。

    修改文章

    1.     // 更新文章
    2.     @RequestMapping("/update")
    3.     public AjaxResult update(HttpServletRequest request,ArticleInfo articleInfo) {
    4.         // 非空校验
    5.         if (articleInfo==null||!StringUtils.hasLength(articleInfo.getTitle())||!StringUtils.hasLength(articleInfo.getContent())||articleInfo.getId()==null){
    6.             // 非法参数
    7.             return AjaxResult.fail(-1,"非法参数");
    8.         }
    9.         //得到当前用户的id
    10.         Userinfo userinfo = UserSessionUtils.getSessionUser(request);
    11.         if (userinfo==null&&userinfo.getId()==null){
    12.             //无效用户
    13.             return AjaxResult.fail(-2,"无效用户");
    14.         }
    15.         // 设置uid用户后面的查询判断文章是否是当前的作者
    16.         articleInfo.setUid(userinfo.getId());
    17.         articleInfo.setUpdatetime(LocalDateTime.now());
    18.         return AjaxResult.success(articleService.update(articleInfo));
    19.  
    20.     }

    根据分页来查询列表

    1.     // 根据分页来查询列表
    2.     @RequestMapping("/listbypage")
    3.     public AjaxResult getListByPage(Integer pindex, Integer psize){
    4.         // 1.参数矫正
    5.         if (pindex == null || pindex <= 1){
    6.             pindex = 1;
    7.         }
    8.         if (psize == null || psize <=1 ){
    9.             psize = 2;
    10.         }
    11.         // 分页公式的值（即从何处开始查找）
    12.         int offset = (pindex - 1) * psize;
    13.         // 当前列表的信息
    14.         List list = articleService.getListByPage(psize,offset);
    15.         // 当前列表的总页数
    16.         // 1.查询总条数
    17.         int tatalCount = articleService.getCount();
    18.         // 2.总数量/psize
    19.         double pcountdb = tatalCount/(psize*1.0);
    20.         // 3.得到总页数
    21.         int pcount = (int) Math.ceil(pcountdb);
    22.         HashMap result = new HashMap<>();
    23.         result.put("list",list);
    24.         result.put("pcount",pcount);
    25.         return AjaxResult.success(result);
    26.     }

    在实现分页查询的时候我们首先需要知道我们一共有多少页，然后得知道我们当前的页面是多少还有我们每次查询的时候需要显示多少页，所以在实现这个功能的时候我们想要通过一条sql去实现是不现实的，所以我们可以通过两条sql其中一条语句返回我们数据库中文章的总数，还有一条语句负责查询我们当前页面的文章。

    select * from articleinfo limit #{psize} offset #{offsize}

    psize用来控制我们查询的条数，offsize用来控制我们何处开始查询，最后通过hashmap将查询的数据和总条数一起返回。

  • 相关阅读:
    python虚拟环境
    关于原型交互设计文档的一些建议
    大数据驱动业务增长：数据分析和洞察力的新纪元
    基于卷积神经网络的猫种类的识别
    python socket编程1 - socket创建参数说明及参考规范
    【智能优化算法】基于蝙蝠优化算法求解多目标优化问题附matlab代码
    软件包管理—源码包管理—源码包与RPM包区别
    python+pywinauto—PC端自动化(一)启动程序及菜单控件操作
    电脑加域win10
    stm32f4xx-GPIO
  • 原文地址：https://blog.csdn.net/m0_56911284/article/details/130765390