[Java知识库]springboot后端博客项目实战

文章目录

• 一.资源下载和项目搭建
• 二、功能
• • 1.首页文章列表页- - -1
  • 2. 首页文章列表页----2
  • 3.首页-最热标签
  • 4.统一异常处理
  • 5.首页-最热文章
  • 6.首页-最新文章
  • 7.首页-文章归档
  • 8 登录功能的实现(JWT)
  • 9.登录后获取用户信息
  • 10 退出登录
  • 11.注册
  • 12 登录拦截器
  • 13. ThreadLocal保存用户信息
  • 14.文章详情
  • 15. 阅读数的更新
  • 16 评论列表
  • 17.评论功能
  • 18.写文章
  • 19.发布文章
  • 20 AOP日志
  • 21 文章图片上传
  • 22.导航-文章分类
  • 23 导航-标签
  • 24 分类文章列表
  • 25.标签文章列表
  • 26 导航栏-文章归档

Gitee地址 :文章些许混乱,以库为准😰

修改数据库ms_comment的articleId为bigInt,不然文章id会超出范围

前端项目运行命令

npm install
npm run build
npm run dev

创建一个项目,如果是平时开发的，首先都要导入如下依赖

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
        <relativePath/>
    </parent>
    
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>


    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

如果创建的项目报如下错误的话，请你降低SpringBoot版本

Error starting ApplicationContext. To display the conditions report re-run your application with 'debug' enabled.
2021-08-15 20:58:31.515 ERROR 4684 --- [           main] o.s.boot.SpringApplication               : Application run failed

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'spring.sql.init-org.springframework.boot.autoconfigure.sql.init.SqlInitializationProperties': Lookup method resolution failed; nested exception is java.lang.IllegalStateException: Failed to introspect Class [org.springframework.boot.autoconfigure.sql.init.SqlInitializationProperties] from ClassLoader [sun.misc.Launcher$AppClassLoader@18b4aac2]
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.determineCandidateConstructors(AutowiredAnnotationBeanPostProcessor.java:289) ~[spring-beans-5.3.7.jar:5.3.7]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.determineConstructorsFromBeanPostProcessors(AbstractAutowireCapableBeanFactory.java:1284) ~[spring-beans-5.3.7.jar:5.3.7]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:1201) ~[spring-beans-5.3.7.jar:5.3.7]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:564) ~[spring-beans-5.3.7.jar:5.3.7]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:524) ~[spring-beans-5.3.7.jar:5.3.7]
	at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:335) ~[spring-beans-5.3.7.jar:5.3.7]
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:234) ~[spring-beans-5.3.7.jar:5.3.7]
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:333) ~[spring-beans-5.3.7.jar:5.3.7]
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:208) ~[spring-beans-5.3.7.jar:5.3.7]
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:944) ~[spring-beans-5.3.7.jar:5.3.7]
	at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:918) ~[spring-context-5.3.7.jar:5.3.7]
	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:583) ~[spring-context-5.3.7.jar:5.3.7]
	at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.refresh(ServletWebServerApplicationContext.java:145) ~[spring-boot-2.5.0.jar:2.5.0]
	at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:758) [spring-boot-2.5.0.jar:2.5.0]
	at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:438) [spring-boot-2.5.0.jar:2.5.0]
	at org.springframework.boot.SpringApplication.run(SpringApplication.java:337) [spring-boot-2.5.0.jar:2.5.0]
	at org.springframework.boot.SpringApplication.run(SpringApplication.java:1336) [spring-boot-2.5.0.jar:2.5.0]
	at org.springframework.boot.SpringApplication.run(SpringApplication.java:1325) [spring-boot-2.5.0.jar:2.5.0]
	at cn.mldn.admin.AdminApp.main(AdminApp.java:11) [classes/:na]
Caused by: java.lang.IllegalStateException: Failed to introspect Class [org.springframework.boot.autoconfigure.sql.init.SqlInitializationProperties] from ClassLoader [sun.misc.Launcher$AppClassLoader@18b4aac2]
	at org.springframework.util.ReflectionUtils.getDeclaredMethods(ReflectionUtils.java:481) ~[spring-core-5.3.7.jar:5.3.7]
	at org.springframework.util.ReflectionUtils.doWithLocalMethods(ReflectionUtils.java:321) ~[spring-core-5.3.7.jar:5.3.7]
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.determineCandidateConstructors(AutowiredAnnotationBeanPostProcessor.java:267) ~[spring-beans-5.3.7.jar:5.3.7]
	... 18 common frames omitted
Caused by: java.lang.NoClassDefFoundError: org/springframework/boot/sql/init/DatabaseInitializationMode
	at java.lang.Class.getDeclaredMethods0(Native Method) ~[na:1.8.0_241]
	at java.lang.Class.privateGetDeclaredMethods(Class.java:2701) ~[na:1.8.0_241]
	at java.lang.Class.getDeclaredMethods(Class.java:1975) ~[na:1.8.0_241]
	at org.springframework.util.ReflectionUtils.getDeclaredMethods(ReflectionUtils.java:463) ~[spring-core-5.3.7.jar:5.3.7]
	... 20 common frames omitted
Caused by: java.lang.ClassNotFoundException: org.springframework.boot.sql.init.DatabaseInitializationMode
	at java.net.URLClassLoader.findClass(URLClassLoader.java:382) ~[na:1.8.0_241]
	at java.lang.ClassLoader.loadClass(ClassLoader.java:418) ~[na:1.8.0_241]
	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:355) ~[na:1.8.0_241]
	at java.lang.ClassLoader.loadClass(ClassLoader.java:351) ~[na:1.8.0_241]
	... 24 common frames omitted

一.资源下载和项目搭建

1. 下载前端项目（这个的话，可以去QQ群下载）

2. 搭建项目（用idea创建项目）
   1）idea create new xxxx在里面一系列的操作
   2）导入依赖

   a -----：parent和properties的导入	```
   

<!--parent的解释https://blog.csdn.net/niceyoo/article/details/91852502-->
	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
        <relativePath/>
    </parent>

    <!--定义一些属性的问题-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

b--导入其他的依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lum</groupId>
    <artifactId>blog-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>blog</module>
    </modules>
    <packaging>pom</packaging>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencyManagement>
        <dependencies>

            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.76</version>
            </dependency>

            <dependency>
                <groupId>commons-collections</groupId>
                <artifactId>commons-collections</artifactId>
                <version>3.2.2</version>
            </dependency>

            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.4.3</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/joda-time/joda-time -->
            <dependency>
                <groupId>joda-time</groupId>
                <artifactId>joda-time</artifactId>
                <version>2.10.10</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

1. 创建子模块blog-api
   1)为什么创建子模块:方便以后分模块开发
   2)导入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>blog-parent</artifactId>
        <groupId>com.lum</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>blog</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <!-- 排除 默认使用的logback  -->
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- log4j2 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>
<!--这个就是AOP的问题了撒，不用多说-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
<!--这个是邮箱的处理-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
        </dependency>
  <!--这个导入进来就是进程一直在进行-->       
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

<!--JSON的格式问题了-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>
<!--mysql的操作了-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
<!--可以看到json中信息-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
<!--跟java.lang这个包的作用类似，Commons Lang这一组API也是提供一些基础的、通用的操作和处理，如自动生成toString()的结果、自动实现hashCode()和equals()方法、数组操作、枚举、日期和时间的处理等等。-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
<!--StringUtils就是这个提供的，用来有时候验证什么是否为空呀-->
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.2</version>
        </dependency>
 <!--像Md5加密呀-->        
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
        </dependency>
<!--mybatis的配置-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>
   <!--是关于Data注解的-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    <!--时间处理的类-->
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.10.10</version>
        </dependency>
  <!--验证-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

        <dependency>
            <groupId>com.qiniu</groupId>
            <artifactId>qiniu-java-sdk</artifactId>
            <version>[7.7.0, 7.7.99]</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-extension</artifactId>
            <version>3.4.2</version>
        </dependency>
        <dependency>
            <groupId>commons-configuration</groupId>
            <artifactId>commons-configuration</artifactId>
            <version>1.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>2.5.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot</artifactId>
            <version>2.5.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.3.8</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.73</version>
        </dependency>
    </dependencies>
</project>

1. 编写application.properties文件

server.port=8888

#配置项目名称
spring.application.name=blog
server.servlet.context-path=/api
#数据库的设置
spring.datasource.url=jdbc:mysql://localhost:3306/blog?useUnicode=true&characterEncoding=UTF-8&serverTimeZone=UTC
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

#Mybaties-plus
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
mybatis-plus.global-config.db-config.table-prefix=ms_

1. 编写启动类BlogApplication.java

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class BlogApplication {
   
     
     
    public static void main(String[] args) {
   
     
     
        SpringApplication.run(BlogApplication.class);
    }
}

1. 然后因为引入了上面的Mybatis-plus,所有有如下配置
   在项目中创建config文件夹，然后创建MybatisplusConfig.java并且写如下代码：

package com.lum.blog.config;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@MapperScan("com.lum.blog.mapper")
public class MyBatiesPlusConfig {
   
     
     
}

1. 启动BlogApplication测试
   
   成功即可，可能会失败，大多是maven依赖关系没有对，仔细比对！
2. 在项目中，肯定要用到分页的，所有要用到Mybatis的分页插件。对MybatisPlusConfig做出如下修改：

//Mybatis-plus分页插件
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
   
     
     
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor( new PaginationInnerInterceptor());
        return mybatisPlusInterceptor;
    }

1. 创建WebMmvConfig.java文件
   这里先配置跨域的问题，因为前端和后端是分离了的，前端前端端口访问是跨域的，所有要配置跨域的问题。

package com.lum.blog.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
   
     
     
   //做跨域配置，为什么要做这个跨域的配置呢，因为比如：我前端的端口号是8080，而我后端接口是8888
   @Override
   public void addCorsMappings(CorsRegistry registry) {
   
     
     

       //addMapping就是所有的文件，allowedOrigins指的是可以那个地址可以访问
       registry.addMapping("/**").allowedOrigins("http://localhost:8080");
   }
}

😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉😉

二、功能

1.首页文章列表页- - -1

1.1接口说明

接口url：/articles
请求方式：post请求
请求参数：

返回数据：

~~~json
{
   
     
     
    "success": true,
    "code": 200,
    "msg": "success",
    "data": [
        {
   
     
     
            "id": 1,
            "title": "springboot介绍以及入门案例",
            "summary": "通过Spring Boot实现的服务，只需要依靠一个Java类，把它打包成jar，并通过`java -jar`命令就可以运行起来。\r\n\r\n这一切相较于传统Spring应用来说，已经变得非常的轻便、简单。",
            "commentCounts": 2,
            "viewCounts": 54,
            "weight": 1,
            "createDate": "2021-06-26 15:58",
            "author": "lum",
            "body": null,
            "tags": [
                {
   
     
     
                    "id": 5,
                    "avatar": null,
                    "tagName": "444"
                },
                {
   
     
     
                    "id": 7,
                    "avatar": null,
                    "tagName": "22"
                },
                {
   
     
     
                    "id": 8,
                    "avatar": null,
                    "tagName": "11"
                }
            ],
            "categorys": null
        },
        {
   
     
     
            "id": 9,
            "title": "Vue.js 是什么",
            "summary": "Vue (读音 /vju?/，类似于 view) 是一套用于构建用户界面的渐进式框架。",
            "commentCounts": 0,
            "viewCounts": 3,
            "weight": 0,
            "createDate": "2609-06-27 11:25",
            "author": "12",
            "body": null,
            "tags": [
                {
   
     
     
                    "id": 7,
                    "avatar": null,
                    "tagName": "22"
                }
            ],
            "categorys": null
        },
        {
   
     
     
            "id": 10,
            "title": "Element相关",
            "summary": "本节将介绍如何在项目中使用 Element。",
            "commentCounts": 0,
            "viewCounts": 3,
            "weight": 0,
            "createDate": "2609-06-27 11:25",
            "author": "12",
            "body": null,
            "tags": [
                {
   
     
     
                    "id": 5,
                    "avatar": null,
                    "tagName": "444"
                },
                {
   
     
     
                    "id": 6,
                    "avatar": null,
                    "tagName": "33"
                },
                {
   
     
     
                    "id": 7,
                    "avatar": null,
                    "tagName": "22"
                },
                {
   
     
     
                    "id": 8,
                    "avatar": null,
                    "tagName": "11"
                }
            ],
            "categorys": null
        }
    ]
}

1.2表结构
既然我们有了前端和页面要返回的数据，那我们的用户什么的，肯定都要和类有关系

返回数据的文章数据表
~~~sql
CREATE TABLE `blog`.`ms_article`  (
  `id` bigint(0) NOT NULL AUTO_INCREMENT,
  `comment_counts` int(0) NULL DEFAULT NULL COMMENT '评论数量',
  `create_date` bigint(0) NULL DEFAULT NULL COMMENT '创建时间',
  `summary` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '简介',
  `title` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '标题',
  `view_counts` int(0) NULL DEFAULT NULL COMMENT '浏览数量',
  `weight` int(0) NOT NULL COMMENT '是否置顶',
  `author_id` bigint(0) NULL DEFAULT NULL COMMENT '作者id',
  `body_id` bigint(0) NULL DEFAULT NULL COMMENT '内容id',
  `category_id` int(0) NULL DEFAULT NULL COMMENT '类别id',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 25 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
~~~

//标签表，由文章可以查看其他的
~~~sql
CREATE TABLE `blog`.`ms_tag`  (
  `id` bigint(0) NOT NULL AUTO_INCREMENT,
  `article_id` bigint(0) NOT NULL,
  `tag_id` bigint(0) NOT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `article_id`(`article_id`) USING BTREE,
  INDEX `tag_id`(`tag_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
~~~

//用户数据表
~~~sql
CREATE TABLE `blog`.`ms_sys_user`  (
  `id` bigint(0) NOT NULL AUTO_INCREMENT,
  `account` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '账号',
  `admin` bit(1) NULL DEFAULT NULL COMMENT '是否管理员',
  `avatar` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '头像',
  `create_date` bigint(0) NULL DEFAULT NULL COMMENT '注册时间',
  `deleted` bit(1) NULL DEFAULT NULL COMMENT '是否删除',
  `email` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '邮箱',
  `last_login` bigint(0) NULL DEFAULT NULL COMMENT '最后登录时间',
  `mobile_phone_number` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '手机号',
  `nickname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '昵称',
  `password` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '密码',
  `salt` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '加密盐',
  `status` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '状态',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 16 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

1.3 Dao开发
com.lum.blog.dao.pojo.Article.java

package com.lum.blog.dao.pojo;

import lombok.Data;
/*
博客管理
 */
@Data
public class Article {
   
     
     

    public static final int Article_TOP = 1;

    public static final int Article_Common = 0;

    private Long id;

    private String title;

    private String summary;

    private int commentCounts;

    private int viewCounts;

    /**
     * 作者id
     */
    private Long authorId;
    /**
     * 内容id
     */
    private Long bodyId;
    /**
     *类别id
     */
    private Long categoryId;

    /**
     * 置顶
     */
    private int weight = Article_Common;


    /**
     * 创建时间
     */
    private Long createDate;
}

com.lum.blog.dao.pojo.SysUser.java

package com.lum.blog.dao.pojo;
import lombok.Data;

/*
用户管理
 */
@Data
public class SysUser {
   
     
     

    private Long id;

    private String account;

    private Integer admin;

    private String avatar;

    private Long createDate;

    private Integer deleted;

    private String email;

    private Long lastLogin;

    private String mobilePhoneNumber;

    private String nickname;

    private String password;

    private String salt;

    private String status;
}

com.lum.blog.dao.pojo.Tag.java

package com.lum.blog.dao.pojo;

import lombok.Data;
/*
标签管理
 */
@Data
public class Tag {
   
     
     

    private Long id;

    private String avatar;

    private String tagName;

}

1.4对应的Mapper的创建

package com.lum.blog.dao.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.lum.blog.dao.pojo.Article;


public interface ArticleMapper extends BaseMapper<Article> {
   
     
     

}

*******************************************************************

package com.lum.blog.dao.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.lum.blog.dao.pojo.SysUser;

public interface SysUserMapper extends BaseMapper<SysUser> {
   
     
     
}


*******************************************************************



package com.lum.blog.dao.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.lum.blog.dao.pojo.Tag;

public interface TagMapper extends BaseMapper<Tag> {
   
     
     
}

1.5mapper创建好了，该Controller了

创建ArticleController，这个代表的是文章类的控制器

package com.lum.blog.controller;

import com.lum.blog.vo.Result;
import com.lum.blog.vo.params.PageParams;
import org.springframework.web.bind.annotation.*;

//使用json数据进行交互
@RestController
@RequestMapping("articles")
public class ArticleController {
   
     
     

        //为什么用post请求,因为前面的接口说明post请求
        //对于另外的参数,建立vo下面的PageParams类专门表示参数

        /**
         * 首页文章列表
         * @param pageParams
         * return 返回承担返回数据Result的类
         */
        @PostMapping
        public Result listArticle(@RequestBody PageParams pageParams){
   
     
     
            //对于接受的参数问题,这里是RequestBody接收
            return articleService.listArticle(pageParams);
        }

}

1）这里就有补充了，我们传入的参数，是PageParms类代表，在
com.lum.Blog下面创建vo的目录，然后创建PageParms的类

package com.lum.blog.vo.params;

import lombok.Data;

//承担着返回页数和数量的类
@Data
public class PageParams {
   
     
     
	private int page = 1;

	private int pageSize = 10;
}

2)返回的数据Result的类

package com.lum.blog.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//承担着返回首页文章列表的类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Result {
   
     
     
    //代表是否成功
    private boolean success;

    //代表我们的编码
    private int code;

    //代表的是消息
    private String msg;

    //代表的是数据
    private Object data;


    //代表成功
    public static Result success(Object data) {
   
     
     
        return new Result(true , 200, "success" ,data);
    }

    //代表失败的
    public static Result Fail(int code, String msg) {
   
     
     
        //没有数据可以返回，所有data是null
        return new Result(false , code, msg,null);
    }
}

1）首先我们编写的DAO层和数据库里面的表名字要对应起来。
2）然后就是编写的XXX-Mapper层层要继承BaseMapper<xxx类名>。
3）然后就是我们一般不再编写他的xxxMapper.xml而是要配置的是 xxxService+xxxServiceImpl，如果要编写xxxMapper.xml和Mybatis一样的配置

1.6 service
从上面中，我们就可以看出，我们已经开发差不多了，但是想返回数据了，但是listArticle这个方法却没有Service来读取数据，所以来开发Service和数据读取的方法

1）首先来编写这个Service层，在src/main/java下面建立service文件夹并且在下面ArticleService文件和Impl文件夹

package com.lum.blog.service;

import com.lum.blog.vo.Result;
import com.lum.blog.vo.params.PageParams;

public interface ArticleService {
   
     
     
    /**
     * 分页查询 文章列表
     * @param pageParams
     * @return
     */
    Result listArticle(PageParams pageParams);
}

2）再来编写他的Impl文件ArticleServiceImpl文件

package com.lum.blog.service.Impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.lum.blog.dao.mapper.ArticleMapper;
import com.lum.blog.dao.pojo.Article;
import com.lum.blog.service.ArticleService;
import com.lum.blog.vo.ArticleVo;
import com.lum.blog.vo.Result;
import com.lum.blog.vo.params.PageParams;
import org.joda.time.DateTime;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class ArticleServiceImpl implements ArticleService {
   
     
     
    @Autowired
    private ArticleMapper articleMapper;

    @Override
    public Result listArticle(PageParams pageParams) {
   
     
     
        //1. 这个是分页查询的类（代表着分离模式），要传入的是页面的页数和页面总数
        Page<Article> page = new Page<Article>(pageParams.getPage(),pageParams.getPageSize());

        //2. LambdaQueryWrapper是MybatisPlus提供的，需要就导入这个包就可以了
        LambdaQueryWrapper<Article> queryWrapper = new LambdaQueryWrapper<>();

        //3. 这里是根据字体排序
        //queryWrapper.orderByDesc(Article::getWeight);
        //4. 这里设置的是根据时间排序
        //queryWrapper.orderByDesc(Article::getCreateDate);
        //5. 这个方法    default Children orderByDesc(boolean condition, R column, R... columns) {是可变长参数的
        queryWrapper.orderByDesc(Article::getWeight,Article::getCreateDate);

        // 因为articleMapper继承了BaseMapper了的，所有设查询的参数和查询出来的排序方式
        Page<Article> articlePage = articleMapper.selectPage(page, queryWrapper);

        //这个就是我们查询出来的数据的数组了
        List<Article> records = articlePage.getRecords();

        //因为页面展示出来的数据不一定和数据库一样，所有我们要做一个转换
       //将在查出数据库的数组复制到articleVo中实现解耦合,vo和页面数据交互
        List<ArticleVo> articleVoList = copyList(records);

        return Result.success(articleVoList);
    }

    private List<ArticleVo> copyList(List<Article> records) {
   
     
     
        List<ArticleVo> articleVoList = new ArrayList<>();
        for (Article record : records) {
   
     
     
            articleVoList.add(copy(record));
        }
        return articleVoList;
    }

    //这个方法是主要点是BeanUtils，又Spring提供的，专门用来拷贝的，想Article和articlevo相同属性的拷贝过来返回
    private ArticleVo copy(Article article) {
   
     
     
        ArticleVo articleVo = new ArticleVo();
        BeanUtils.copyProperties(article,articleVo);

        articleVo.setCreateDate(new DateTime(article.getCreateDate()).toString("yyyy-MM-dd HH:mm"));
        return articleVo;
    }
}

其中需要创建ArticleVo和TagVo

package com.lum.blog.vo;

import lombok.Data;

import java.util.List;

@Data
public class ArticleVo {
   
     
     

    private Long id;

    private String title;

    private String summary;  //简介

    private int commentCounts;

    private int ViewCounts;

    private int weight;   //置顶

    private String createDate;  //创建时间

    private String author;
    
//暂时不需要
//    private ArticleBodyVo body;

    private List<TagVo> tags;
    
//暂时不需要
//    private List<CategoryVo> categories;
}

package com.lum.blog.vo;

import lombok.Data;

@Data
public class TagVo {
   
     
     

    private Long id;

    private String tagName;
}

vo和页面交互的数据不应该和数据库映射对象进行耦合,最好分开

这里补充一下这个articleVo，这个类，因为平时我们开发出来的东西，到时候要
到数据库里面找数据嘛，然后找出来不一定一样，要把它一样的拷贝，不一样的返回null

总结：有了以上的配置之后，页面的内容就可以展示了

2. 首页文章列表页----2

问题引入：在之前开发的首页内容显示中，文章下面是没有标签,作者的信息等内容的，要开发下面有内容

2.1在ArticleServiceImpl中实现
思考:并不是所有的接口都需要标签,作者信息

增加两个boolean isTag,isAuthor来进行判断

在copyList中增加代码

private List<ArticleVo> copyList(List<Article> records,boolean isTag,boolean isAuthor) {
   
     
     
        List<ArticleVo> articleVoList = new ArrayList<>();
        for (Article record : records) {
   
     
     
            articleVoList.add(copy(record,isTag,isAuthor));
        }
        return articleVoList;
    }

在copy中增加代码

//这个方法是主要点是BeanUtils，又Spring提供的，专门用来拷贝的，想Article和articleVo相同属性的拷贝过来返回
    private ArticleVo copy(Article article,boolean isTag,boolean isAuthor) {
   
     
     
        ArticleVo articleVo = new ArticleVo();
        BeanUtils.copyProperties(article,articleVo);

        articleVo.setCreateDate(new DateTime(article.getCreateDate()).toString("yyyy-MM-dd HH:mm"));
        /*
        并不是所有的接口都需要标签,作者信息
        增加两个参数boolean isTag,boolean isAuthor
         */
		//需要开发tagService
        if (isTag) {
   
     
     
            Long articleId = article.getId();
            articleVo.setTags(tagService.findTagsByArticleId(articleId));
        }
        //需要开发authorService
        if (isAuthor) {
   
     
     
            Long authorId = article.getAuthorId();
            articleVo.setAuthor(sysUserService.findUserById(authorId).getNickname());
        }
        return articleVo;
    }

2.2标签tag
编写TagService

package com.lum.blog.service;

import com.lum.blog.vo.TagVo;

import java.util.List;

public interface TagService {
   
     
     

    List<TagVo> findTagsByArticleId(Long articleId);
}

编写实现类TagServiceImpl

package com.lum.blog.service.Impl;

import com.lum.blog.dao.mapper.TagMapper;
import com.lum.blog.dao.pojo.Tag;
import com.lum.blog.service.TagService;
import com.lum.blog.vo.TagVo;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class TagServiceImpl implements TagService {
   
     
     

    @Autowired
     private TagMapper tagMapper;

    /*copyList传递tag*/
    public TagVo copy(Tag tag){
   
     
     
        TagVo tagVo = new TagVo();
        BeanUtils.copyProperties(tag,tagVo);
        return tagVo;
    }

    public List<TagVo> copyList(List<Tag> tagList) {
   
     
     
        List<TagVo> tagVoList = new ArrayList<>();
        for (Tag tag : tagList) {
   
     
     
            tagVoList.add(copy(tag));
        }
        return tagVoList;
    }
/**********************************/
    @Override
    public List<TagVo> findTagsByArticleId(Long articleId) {
   
     
     
        /* MyBatisPlus无法实现多表查询 */
        List<Tag> tags=tagMapper.findTagsByArticleId(articleId);
        return copyList(tags);
    }
}

编写TagMapper

package com.lum.blog.dao.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.lum.blog.dao.pojo.Tag;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public interface TagMapper extends BaseMapper<Tag> {
   
     
     
    /**
     * 根据文章id查询标签列表
     * @param articleId
     * @return
     */
    List<Tag> findTagsByArticleId(Long articleId);
}

在resourse下建立TagMapper.xml
路径与接口包一致(com.lum.blog.dao.mapper)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.lum.blog.dao.mapper.TagMapper">

<!--    List<Tag> findTagsByArticleId(Long articleId);-->
    <select id="findTagsByArticleId" parameterType="long" resultType="com.lum.blog.dao.pojo.Tag">
        select id,avatar,tag_name as tagName from ms_tag
        where id in
        (select tag_id from ms_article_tag where article_id=#{articleId})

    </select>
</mapper>

parameterType="long"对应List findTagsByArticleId(Long articleId)的articleId

select id,avatar,tag_name as tagName from ms_tag
where id in
(select tag_id from ms_article_tag where article_id=#{articleId})
在关联表中查询标签的id,auatar,tagName

可以在application.properties中mybatis-plus开启驼峰命名

mybatis-plus.configuration.map-underscore-to-camel-case=true

这样SQL语句就不需要as别名。

接下来将TagService注入到ArticleImpl中实现

if (isTag) {
   
     
     
            Long articleId = article.getId();
            articleVo.setTags(tagService.findTagsByArticleId(articleId));
        }

2.3作者author
建立接口SysUserService

package com.lum.blog.service;

import com.lum.blog.dao.pojo.SysUser;

public interface SysUserService {
   
     
     

    SysUser findUserById(Long id);


}

编写实现类SysUserServiceImpl

package com.lum.blog.service.Impl;

import com.lum.blog.dao.mapper.SysUserMapper;
import com.lum.blog.dao.pojo.SysUser;
import com.lum.blog.service.SysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class SysUserServiceImpl implements SysUserService {
   
     
     

    @Autowired
    private SysUserMapper sysUserMapper;

    @Override
    public SysUser findUserById(Long id) {
   
     
     
        /*防止出现id为空的情况*/
        SysUser sysUser = sysUserMapper.selectById(id);
        if (sysUser == null) {
   
     
     
            sysUser = new SysUser();
            sysUser.setNickname("鹿鸣");

        }
        return sysUser;
    }

}

注入SysUserMapper,然后编写查询

将SysUserService注入到文章实现类ArticleServiceImpl中

if (isAuthor) {
   
     
     
            Long authorId = article.getAuthorId();
            articleVo.setAuthor(sysUserService.findUserById(authorId).getNickname());
        }

在SysUserImpl中编写如果出现空的情况处理办法

public SysUser findUserById(Long id) {
   
     
     
        /*防止出现id为空的情况*/
        SysUser sysUser = sysUserMapper.selectById(id);
        if (sysUser == null) {
   
     
     
            sysUser = new SysUser();
            sysUser.setNickname("lum");

        }
        return sysUser;
    }

在copyList中加入返回值istag,isauthor

List<ArticleVo> articleVoList = copyList(records,true,true);

for (Article record : records) {
   
     
     
            articleVoList.add(copy(record,isTag,isAuthor));
        }

在前方代码中已经有体现在哪加😁

进行测试

3.首页-最热标签

1.标签所拥有的文章数量最多
    2.查询 根据tag_id分组,技术,从大到小排,取前limit个

3.1 接口说明
接口url：/tag/hot
请求方式：Get
请求参数：无
返回数据：

{
   
     
     
	"successs":true
	"code"200
	"msg":"success"
	"data"[
		{
   
     
     
		"id":1,
		"tagName":"最热"
		}
	]
}

3.2编码
先写controller
创建TagsController

package com.lum.blog.controller;

import com.lum.blog.service.TagService;
import com.lum.blog.vo.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("tags")
public class TagsController {
   
     
     

    @Autowired
    private TagService tagService;

    @GetMapping("hot")
    public Result hot() {
   
     
     
        int limit =6;  //最热6个
        return tagService.hots(limit);
    }
}

在tagService实现hots方法

package com.lum.blog.service;

import com.lum.blog.vo.Result;
import com.lum.blog.vo.TagVo;

import java.util.List;

public interface TagService {
   
     
     

    List<TagVo> findTagsByArticleId(Long articleId);

    Result hots(int limit);
}

首先分析SQL语句

select tag_id
from ms_article_tag
group by tag_id
order by count(*) limit 2

TagServiceImpl实现 Result hots(int limit)

@Override
    public Result hots(int limit) {
   
     
     
        /**
         * 1.标签所拥有的文章数量最多
         * 2.查询 根据tag_id分组,技术,从大到小排序,取前limit个
         */
        List<Long> tagIds= tagMapper.findHotsTagId(limit);
        return null;
    }

在TagMapper中创建findHostTagId(limit)方法

/**
     * 查询最热标签前limit条
     * @param limit
     * @return
     */
    List<Long> findHotsTagId(int limit);

在资源文件TagMapper中生成findHotsTagId并添加==parameterType=“int”==属性以及sql语句

<select id="findHotsTagId" parameterType="int" resultType="java.lang.Long">
        select tag_id
        from ms_article_tag
        group by tag_id
        order by count(*) limit 6
    </select>

这时查询出最热的tagId,需要根据tagid查询tagName,Tag
继续Result hot

@Override
    public Result hots(int limit) {
   
     
     
        /**
         * 1.标签所拥有的文章数量最多
         * 2.查询 根据tag_id分组,技术,从大到小排序,取前limit个
         */
        List<Long> tagIds= tagMapper.findHotsTagId(limit);

        /*判断tagIds是否为空*/
        if(CollectionUtils.isEmpty(tagIds)){
   
     
     
            return Result.success(Collections.emptyList());
        }
//        需求的是tagId和tagName tag对象
//        select * from tag where id in (1,2,3)
        List<Tag> tagList= tagMapper.findTagsByIds(tagIds);
        return Result.success(tagList);
    }

所以需要在TagMapper.java中添加方法

/**
     * 根据tagId查询Tag对象
     * @param tagIds
     * @return
     */
    List<Tag> findTagsByIds(List<Long> tagIds);

在资源TagMapper.xml中添加

<!--    List<Tag> findTagsByIds(List<Long> tagIds);-->
    <select id="findTagsByIds" parameterType="list" resultType="com.lum.blog.dao.pojo.Tag">
        select id,tag_name from ms_tag
        where id in
        <foreach collection="tagIds" item="tagId" separator="," open="(" close=")">
            #{tagId}
        </foreach>
    </select>

3.3进行测试

4.统一异常处理

创建handler(com.lum.blog下.)包并创建AllExceptionHandler类

package com.lum.blog.handler;


import com.lum.blog.vo.Result;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

@ControllerAdvice
//对加了@ControllerAdvice的方法进行拦截处理 AOP实现
public class AllExceptionHandler {
   
     
     

    @ExceptionHandler(Exception.class)   //进行异常处理,处理Exception.class异常
    @ResponseBody                        //返回Json数据
    public Result doExceptionHandler(Exception e){
   
     
     
        e.printStackTrace();
        return Result.fail(-999,"系统异常");
    }
}

在controller代码中加入错误代码,进行测试

5.首页-最热文章

5.1接口说明
接口url: /articles/hot
请求方式:POST
请求参数:

返回数据:

{
   
     
     
  "success": true,
    "code": 200,
    "msg": "success",
    "data": [
        {
   
     
     
            "id": 1,
            "title": "springboot介绍以及入门案例",
         },
         {
   
     
     
           "id": 2,
            "title": "springboot介绍以及入门案例",
         }  
            ]
}

5.2 Controller
在ArticleController中增加PostMapper,返回最热的文章

/**
     * 首页最热文章
     * @return
     */
    @PostMapping("hot")
    public Result hotArticle(){
   
     
     
        int limit=5;
        return articleService.hotArticle(limit);
    }

5.3Service

在articleService创建对应的方法.hotArticle(limit);

Result hotArticle(int limit);

在articleServiceImpl中实现 Result hotArticle(int limit) 进行sql查询并copyList返回

@Override
    public Result hotArticle(int limit) {
   
     
     
        LambdaQueryWrapper<Article> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.orderByDesc(Article::getViewCounts);
        queryWrapper.select(Article::getId,Article::getTitle);
        queryWrapper.last("limit"+limit);
        //select id,title from article order by view_counts desc limit 5
        List<Article> articles = articleMapper.selectList(queryWrapper);

        return Result.success(copyList(articles,false,false));
    }

5.4进行测试

6.首页-最新文章

6.1接口说明
接口url: /articles/new
请求方式:POST
请求参数:

返回数据:

{
   
     
     
  "success": true,
    "code": 200,
    "msg": "success",
    "data": [
        {
   
     
     
            "id": 1,
            "title": "springboot介绍以及入门案例",
         },
         {
   
     
     
           "id": 2,
            "title": "springboot介绍以及入门案例",
         }  
            ]
}

6.2 Controller
在ArticleController中增加PostMapper,返回最热的文章

/**
     * 首页最热文章
     * @return
     */
    @PostMapping("new")
    public Result newArticle(){
   
     
     
        int limit=5;
        return articleService.newArticle(limit);
    }

6.3Service

在articleService创建对应的方法.hotArticle(limit);

Result newArticle(int limit);

在articleServiceImpl中实现 Result hotArticle(int limit) 进行sql查询并copyList返回

@Override
    public Result newArticle(int limit) {
   
     
     
        LambdaQueryWrapper<Article> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.orderByDesc(Article::getCreateDate);
        queryWrapper.select(Article::getId,Article::getTitle);
        queryWrapper.last("limit"+limit);
        //select id,title from article order by CreateDate desc limit 5
        List<Article> articles = articleMapper.selectList(queryWrapper);

        return Result.success(copyList(articles,false,false));
    }

6.4 进行测试

7.首页-文章归档

文章根据日期的年月进行归档处理
因为数据库的create_date为bigint类型需要/1000得到时间戳,再经过FROM_UNIXTIME进行格式转换
SQL语句为

select year(FROM_UNIXTIME(create_date/1000)) year,month(FROM_UNIXTIME(create_date/1000)) month, count(*) count from ms_article group by year,month;

7.1 接口说明
接口url: /articles/listArtchives
请求方式:POST
请求参数:

返回数据:

{
   
     
     
  "success": true,
    "code": 200,
    "msg": "success",
    "data": [
        {
   
     
     
            "year": "2021",
            "mouth": "6",
            "count"2
         }
            ]
}

7.2 Controller
ArticleController类

/**
     * 首页文章归档
     * @return
     */
    @PostMapping("listArchives")
    public Result listArchives(){
   
     
     
        return articleService.listArchives();
    }

7.3 Service

ArticleService

/**
     * 文章归档
     * @return
     */
    Result listArchives();

在ArticleServiceImpl中实现

/*文章归档*/
    @Override
    public Result listArchives() {
   
     
     
       List<Archives> archivesList = articleMapper.listArchives();
        return Result.success(archivesList);
    }

7.4 mapper

因为文章归档返回的数据不是数据库的直接数据,临时使用,不属于pojo对象
所以创建dos包存放非持久化数据

创建Archives类归档信息

package com.lum.blog.dao.dos;

import lombok.Data;

@Data
public class Archives {
   
     
     
    private Integer year;

    private Integer month;

    private Long count;
}

创建Articlemapper

package com.lum.blog.dao.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.lum.blog.dao.dos.Archives;
import com.lum.blog.dao.pojo.Article;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public interface ArticleMapper extends BaseMapper<Article> {
   
     
     

    List<Archives> listArchives();
}

在资源包mapper创建ArticleMapper.xml实现listArchives()

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.lum.blog.dao.mapper.ArticleMapper">
    <select id="listArchives" resultType="com.lum.blog.dao.dos.Archives">
        select year(FROM_UNIXTIME(create_date/1000)) year,month(FROM_UNIXTIME(create_date/1000)) month, count(*) count
        from ms_article
        group by year,month;
    </select>
</mapper>

7.5 进行测试

8 登录功能的实现(JWT)

8.1接口说明
接口url：/login

请求方式：POST

请求参数：

返回的数据

{
   
     
     
    "success": true,
    "code": 200,
    "msg": "success",
    "data": "token"
}

8.2JWT技术实现
JSON Web Token (JWT)，它是目前最流行的跨域身份验证解决方案

JWT的精髓在于：“去中心化”，数据是保存在客户端的。

jwt可以生成一个加密token,作为用户登陆的令牌,当用户登陆成功后,发放给客户端.
请求需要登陆的资源和接口时,将token携带,后端验证token是否合法.

jwt有三部分组成:

• Header,{“type”:“JWT”,“alg”:“HS256”}固定

• playload,存放自定义信息 比如,用户id,过期时间等,可以被解密,不能存放敏感信息

• 签证 前两点加上密钥加密组成,只要密钥不丢失,可以认为是安全的

  (alg:HS256是算法)
  

jwt验证,主要就是验证签证部分,是否合法

导入依赖包

<dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

创建工具类JWTUtils

package com.lum.blog.utils;

import io.jsonwebtoken.Jwt;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

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

public class JWTUtils {
   
     
     
    private static final String jwtToken = "12345Lum!@#$%";			//密钥

    public static String createToken(Long userId){
   
     
     
        Map<String, Object> claims = new HashMap<>();
        claims.put("userId",userId);
        JwtBuilder jwtBuilder = Jwts.builder()
                .signWith(SignatureAlgorithm.HS256,jwtToken)  //签发算法,密钥为jwtToken
                .setClaims(claims)//body数据,唯一,自行设置
                .setIssuedAt(new Date())  //设置签发时间
                .setExpiration(new Date(System.currentTimeMillis() + 24 * 60 * 60  *1000));  //一天都有效时间
        return jwtBuilder.compact();
    }

    public static Map<String,Object> checkToken(String token){
   
     
     
        try {
   
     
     
            Jwt parser = Jwts.parser().setSigningKey(jwtToken).parse(token);  //解析jwtToken
            return (Map<String, Object>) parser.getBody();
        }catch ( Exception e) {
   
     
     
            e.printStackTrace();
        }
        return null;
    }


    /*测试jwt*/
    public static void main(String[] args) {
   
     
     
        String token = JWTUtils.createToken(100L);
        System.out.println(token);
        Map<String, Object> map = JWTUtils.checkToken(token);
        System.out.println(map.get("userId"));
    }
}

8.3Controller
在controller层创建LoginController进行登陆控制

package com.lum.blog.controller;

import com.lum.blog.service.LoginService;
import com.lum.blog.vo.Result;
import com.lum.blog.vo.params.LoginParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/login")
public class LoginController {
   
     
     

//    @Autowired
//    private SysUserService sysUserService;
//    不建议,每个Service都有单独的业务

    @Autowired
    private LoginService loginService;

    @PostMapping
    public Result login(@RequestBody LoginParam loginParam){
   
     
     
        //登陆验证用户 访问用户表
        return loginService.login(loginParam);

    }

}

需要在Service层编写业务

8.4Service

创建LoginService编写业务

package com.lum.blog.service;

import com.lum.blog.vo.Result;
import com.lum.blog.vo.params.LoginParam;

public interface LoginService {
   
     
     

    /**
     * 登陆功能
     * @param loginParam
     * @return
     */
    Result login(LoginParam loginParam);
}

在vo包的param参数包编写登录用到的参数登录参数

在LoginServiceImpl中实现login方法

package com.lum.blog.service.Impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.lum.blog.dao.pojo.SysUser;
import com.lum.blog.service.LoginService;
import com.lum.blog.service.SysUserService;
import com.lum.blog.utils.JWTUtils;
import com.lum.blog.vo.ErrorCode;
import com.lum.blog.vo.Result;
import com.lum.blog.vo.params.LoginParam;
import org.apache.commons.codec.digest.DigestUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class LoginServiceImpl implements LoginService {
   
     
     

    @Autowired
    private SysUserService sysUserService;//需要用到用户表

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    private static final String salt="lum!@#";


    @Override
    public Result login(LoginParam loginParam) {
   
     
     

        /**
         * 1.检查参数是否合法
         * 2.根据用户名和密码区user表中查询是否存在
         * 3.如果不存在 登陆失败
         * 4.如果存在，使用jwt 生成 token 返回给前端
         * 5.token放入redis中，redis映射token和user信息，设置过期时间，先认证token是否合法，再认证redis中是否存在
         */
        String account = loginParam.getAccount();
        String password = loginParam.getPassword();
        if (StringUtils.isBlank(account)||StringUtils.isBlank(password)) {
   
     
     
            return Result.fail(ErrorCode.PARAMS_ERROR.getCode(),ErrorCode.PARAMS_ERROR.getMsg());
        }
        password = DigestUtils.md5Hex(password + salt); //密码加盐
        SysUser sysUser = sysUserService.findUser(account,password);
        if (sysUser == null) {
   
     
     
            return Result.fail(ErrorCode.ACCOUNT_PWD_NOT_EXIST.getCode(), ErrorCode.ACCOUNT_PWD_NOT_EXIST.getMsg());
        }
        String token = JWTUtils.createToken(sysUser.getId());
        redisTemplate.opsForValue().set("TOKEN_"+token, JSON.toJSONString(sysUser),1, TimeUnit.DAYS); //过期时间
        return Result.success(token);
    }
}

在这里先判断用户名或者密码是否为空,空的话返回统一错误码

if (StringUtils.isBlank(account)||StringUtils.isBlank(password)) {
   
     
     
            return Result.fail(ErrorCode.PARAMS_ERROR.getCode(),ErrorCode.PARAMS_ERROR.getMsg());
        }

再对密码进行加盐处理

private static final String salt="lum!@#";

password = DigestUtils.md5Hex(password + salt); //密码加盐

需要用到redis来作缓存和数据库的中介
进行application.properties中redis配置
设置token和过期时间

redisTemplate.opsForValue().set("TOKEN_"+token, JSON.toJSONString(sysUser),1, TimeUnit.DAYS);

8.5,登录参数,redis配置,统一错误码

LoginParam登录参数

package com.lum.blog.vo.params;

import lombok.Data;

@Data
public class LoginParam {
   
     
     

    private String account;

    private String password;
}

redis配置

#redis配置
spring.redis.host=localhost
spring.redis.port=6379

统一错误码

在vo包下创建ErrorCode

package com.lum.blog.vo;

public enum ErrorCode {
   
     
     

    PARAMS_ERROR(10001,"参数有误"),
    ACCOUNT_PWD_NOT_EXIST(10002,"用户密码不存在喔!"),
    TOKEN_ERROR(10003,"Token不合法"),
    ACCOUNT_EXIST(10004,"账号已存在"),
    NO_PERMISSION(70001,"无访问权限"),
    SESSION_TIME_OUT(90001,"会话超时"),
    NO_LOGIN(90002,"未登录"),;


    private int code;
    private String msg;

    ErrorCode(int code, String msg) {
   
     
     
        this.code = code;
        this.msg = msg;
    }

    public int getCode() {
   
     
     
        return code;
    }

    public void setCode(int code) {
   
     
     
        this.code = code;
    }

    public String getMsg() {
   
     
     
        return msg;
    }

    public void setMsg(String msg) {
   
     
     
        this.msg = msg;
    }
}

8.6 进行测试

使用postman进行测试,因为登录后,需要跳转页面,进行token认证,有接口未完成,换端会出问题,
token前端获取到之后,会存储storage中b5,本地存储

redis-ci中使用 key * 也可查询token

9.登录后获取用户信息

9.1接口说明
接口url:/users/currentUser
请求方式:Get
请求参数:

9.2 Controller
创建UserController进行用户信息返回

package com.lum.blog.controller;


import com.lum.blog.service.SysUserService;
import com.lum.blog.vo.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("users")
public class UserController {
   
     
     

    @Autowired
    private SysUserService sysUserService;

    //users/currentUser
    @GetMapping("currentUser")
    public Result currentUser(@RequestHeader("Authorization") String token) {
   
     
       //请求头

        return sysUserService.findUserByToken(token);
    }


}

9.3 Service
在SysUserService接口添加findUserByToken(String token)方法

/*根据token查询用户信息*/
    Result findUserByToken(String token);

在实现类中编写findUserByToken(String token),需要在vo包创建LoginUserVo

@Override
    public Result findUserByToken(String token) {
   
     
     
        /**
         * 1.根据token合法性
         * 是否为空,解析是否成功,redis是否存在
         * 2.如果校验失败,返回错误
         * 3.如果成功,返回对应结果 LoginUserVo
         *
         */
        SysUser sysUser = loginService.checkToken(token);
        if (sysUser == null) {
   
     
     
            return Result.fail(ErrorCode.TOKEN_ERROR.getCode(),ErrorCode.TOKEN_ERROR.getMsg());
        }
        //理论上应该写TokenService处理,此处简单处理
        LoginUserVo loginUserVo = new LoginUserVo();
        loginUserVo.setId(sysUser.getId());
        loginUserVo.setNickname(sysUser.getNickname());
        loginUserVo.setAccount(sysUser.getAccount());
        loginUserVo.setAvatar(sysUser.getAvatar());
        return Result.success(loginUserVo);
    }

LoginUserVo

package com.lum.blog.vo;

import lombok.Data;

@Data
public class LoginUserVo {
   
     
     

    private  Long id;

    private String account;

    private String nickname;

    private String avatar; //头像
}

编写LoginService接口添加checkToken检查Token是否为空,不为空继续判断redis中userJson是否为空,不为空返回user对象

SysUser checkToken(String token);

在LoginServiceImpl中实现方法checkToken

@Override
    public SysUser checkToken(String token) {
   
     
     
        if (StringUtils.isBlank(token)){
   
     
     
            return null;
        }
        Map<String, Object> checkToken = JWTUtils.checkToken(token);
        if (checkToken == null) {
   
     
     
            return null;
        }
        String userJson = redisTemplate.opsForValue().get("TOKEN_" + token);
        if(StringUtils.isBlank(userJson)){
   
     
     
            return null;
        }
        SysUser sysUser = JSON.parseObject(userJson, SysUser.class);
        return sysUser;
    }

在SysUserServiceImpl中添加查找用户

@Override
    public SysUser findUser(String account, String password) {
   
     
     
        LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SysUser::getAccount,account);
        queryWrapper.eq(SysUser::getPassword,password);//进行加密
        queryWrapper.select(SysUser::getAccount,SysUser::getId,SysUser::getAvatar,SysUser::getNickname);//查询需要的
        queryWrapper.last("limit 1");//为了加快速度,只查一个

        return sysUserMapper.selectOne(queryWrapper);
    }

9.4进行测试

10 退出登录

前端清除token,后端清除redis中数据
10.1接口说明
接口url:/logout
请求方式:Get
请求参数:

10.2 Controller
创建LogoutController

package com.lum.blog.controller;

import com.lum.blog.service.LoginService;
import com.lum.blog.vo.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/logout")
public class LogoutController {
   
     
     

    @Autowired
    private LoginService loginService;

    @GetMapping
    public Result logout(@RequestHeader("Authorization") String token){
   
     
     
        return loginService.logout(token);

    }

}

10.3Service
在LoginService接口中创建logout方法

/**
     * 退出登录
     * @param token
     * @return
     */
    Result logout(String token);

在实现类中完成方法
将redis中的token删除即可

@Override
    public Result logout(String token) {
   
     
     
        redisTemplate.delete("TOKEN_" + token);
        return Result.success(null);
    }