SpringBoot编写个人博客首页、详情页

lbcsd2578833劳振轩

已于 2023-11-07 16:39:45 修改

阅读量211

点赞数

文章标签： spring boot 后端 java

于 2023-11-07 16:34:31 首次发布

本文链接：https://blog.csdn.net/jgyiuk/article/details/134269854

版权

静态资源下载地址（此出可以查看此项目的全部代码资源）

一、分页显示博客列表功能需求

二、列表显示阅读排行榜最多为15个功能需求

三、点击查看显示详情页功能需求

四、首页、详情页显示博客名字、点击博客名字能回首页功能需求

五、首页显示其他功能的按钮功能需求

Pom文件所需添加依赖

首页代码参考

首页头部代码参考

首页脚部分代码参考

首页详情页代码参考

首页功能代码参考

学习心得

静态资源下载地址（此出可以查看此项目的全部代码资源）

SpringBootTen: adadadadadada

一、分页显示博客列表

1、列表显示内容（显示图片、文章发布时间、文章标题、详情简介、文章分类）

2、文章发布时间格式为例如：2021-12-05

3、详情介绍的字数超过39字就用.....显示

4、标题超过10个字就用...替代

5、列表的内容每一页最多显示5篇文章、支持上下滑动

6、首页背景要会动，还要显示logo图

7、列表内容每一页最后一篇文章下面显示页码数，下一页、上一页，点击上一页、下一页、页码数跳转到对应页

8、点击指定文章标题跳转到指定文章详情页

9、页码只显示当前页的前后一项，同时使用“...”来代替多余的页码

二、列表显示阅读排行榜最多为15个

1、排行榜显示列表（显示文章标题、显示点击率），列表最多显示15条

2、每次点击列表里的文章标题,对应的点击率都会增加，列表按照点击率高低排行

3、点击列表标题可以跳转详情页,每个列表的文章标题超过10个字就用...替代

三、点击查看显示详情页

1、详情页显示标题、发布时间、内容、返回上一级按钮

2、详情页内容可以显示图片，点击图片可以将其放大显示

3、详情页内容的普通文本可以嵌入链接可跳转其他页面

四、首页、详情页显示博客名字、点击博客名字能回首页

1、首页、详情页显示博客名字

2、点击博客名字能回首页

五、首页显示其他功能的按钮

未登录时显示联系我按钮、显示登录按钮
登录后显示退出按钮、登录后显示用户信息按钮，显示发送邮件按钮、登录按钮不显示
登录admin权限用户首页显示后台管理按钮、退出按钮、显示用户信息按钮，显示发送邮件按钮、登录按钮不显示

Pom文件所需添加依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!-- 模型版本，保持为4.0.0 -->
    <modelVersion>4.0.0</modelVersion>

    <!-- 父级项目的信息，这里使用Spring Boot的父级项目 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.12</version> <!-- 使用Spring Boot的2.7.12版本 -->
        <relativePath/> <!-- 从仓库查找父级 -->
    </parent>

    <!-- 项目的基本信息，包括groupId、artifactId、version等 -->
    <groupId>com.example</groupId> <!-- 你的项目的组ID -->
    <artifactId>Springbootten</artifactId> <!-- 你的项目的Artifact ID -->
    <version>0.0.1-SNAPSHOT</version> <!-- 项目的版本 -->
    <name>Springbootten</name> <!-- 项目的名称 -->
    <description>Springbootten</description> <!-- 项目的描述 -->

    <!-- 指定打包方式为War包 -->
    <packaging>war</packaging>

    <!-- 项目的属性，可以在其他部分引用这些属性 -->
    <properties>
        <java.version>19</java.version> <!-- 使用Java 19版本 -->
    </properties>
<!--    <properties>-->
<!--        <maven.compiler.source>1.8</maven.compiler.source>-->
<!--        <maven.compiler.target>1.8</maven.compiler.target>-->
<!--    </properties>-->


    <!-- 项目的依赖项 -->
    <dependencies>
        <!-- Spring Boot Starter - Spring Boot的基础依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <!-- Spring Boot Starter Validation - 数据验证依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>

        <!-- Spring Boot Starter Test - 测试依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- Spring Boot Configuration Processor - 配置处理器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- Spring Boot Starter Web - Web应用依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- JUnit - 单元测试库 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- MyBatis Starter - MyBatis数据库依赖 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.1</version>
        </dependency>

        <!-- MySQL Connector - MySQL数据库驱动 -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>8.0.31</version>
        </dependency>

        <!-- Druid Spring Boot Starter - 数据库连接池依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.12</version>
        </dependency>

        <!-- Spring Boot Data JPA Starter - Spring Data JPA依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <!-- Spring Boot Redis Starter - Redis依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!-- Spring Boot Thymeleaf Starter - Thymeleaf模板引擎依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

        <!-- Apache Commons IO - IO操作工具库 -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>

        <!-- PageHelper - 数据库分页插件 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.0.0</version>
        </dependency>
        <!-- PageHelper - 数据库分页插件 -->
        <!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper-spring-boot-starter -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.4.7</version>
        </dependency>

        <!-- Apache Commons Lang3 - 字符串工具库 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>

        <!-- Markdown处理库 -->
        <dependency>
            <groupId>com.atlassian.commonmark</groupId>
            <artifactId>commonmark</artifactId>
            <version>0.10.0</version>
        </dependency>
        <!-- Markdown处理库 - 标题锚点扩展 -->
        <dependency>
            <groupId>com.atlassian.commonmark</groupId>
            <artifactId>commonmark-ext-heading-anchor</artifactId>
            <version>0.10.0</version>
        </dependency>
        <!-- Markdown处理库 - GFM表格扩展 -->
        <dependency>
            <groupId>com.atlassian.commonmark</groupId>
            <artifactId>commonmark-ext-gfm-tables</artifactId>
            <version>0.10.0</version>
        </dependency>

        <!-- emoji-java - 处理Emoji表情字符 -->
        <dependency>
            <groupId>com.vdurmont</groupId>
            <artifactId>emoji-java</artifactId>
            <version>5.1.1</version>
        </dependency>

        <!-- Spring Boot Starter Tomcat - 集成Tomcat服务器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>

        <!-- Spring Boot Starter Security - 安全管理依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

        <!-- Thymeleaf Extras SpringSecurity5 - Thymeleaf安全扩展 -->
        <dependency>
            <groupId>org.thymeleaf.extras</groupId>
            <artifactId>thymeleaf-extras-springsecurity5</artifactId>
        </dependency>

        <!-- Spring Boot Starter AMQP - 异步消息AMQP -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

        <!-- Spring Boot Starter Mail - 邮件服务依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
        </dependency>

        <!-- JUnit Platform - JUnit测试框架 -->
        <dependency>
            <groupId>org.junit.platform</groupId>
            <artifactId>junit-platform-commons</artifactId>
            <version>1.8.2</version>
            <scope>compile</scope>
        </dependency>

    </dependencies>

    <!-- 构建配置，包括插件 -->
    <build>
        <plugins>
            <!-- Spring Boot Maven插件，用于构建Spring Boot应用 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

首页代码

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<!-- 使用Thymeleaf的模板引擎，设置语言和命名空间 -->

<!-- 载入文章头部页面，位置在/client文件夹下的header模板页面，模板名称th:fragment为header -->
<div th:replace="/client/header::header(null,null)" />
<!-- 载入网页头部，通常包含网页标题等信息 -->

<body>
<!-- 视频背景容器 -->
<div data-vide-bg="/assets/video/2.mp4" class="video-container01"></div>
<!-- 通过data-vide-bg属性设置视频背景，使用video-container01类样式来控制容器样式 -->

<div class="am-g am-g-fixed blog-fixed index-page">
    <!-- 使用Amaze UI的网格布局，分成左右两栏 -->
    <div class="am-u-md-8 am-u-sm-12">
        <!-- 左栏，用于展示文章列表 -->

        <!-- 文章遍历并分页展示 -->
        <!-- 使用Thymeleaf的each指令遍历文章列表 -->
        <div th:each="article: ${articles.list}">
            <!-- 遍历每篇文章 -->

            <article class="am-g blog-entry-article">
                <!-- 单个文章的外层容器 -->

                <div class="am-u-lg-6 am-u-md-12 am-u-sm-12 blog-entry-img">
                    <!-- 左侧，用于显示文章图片 -->

                    <!-- 显示文章图片，使用Thymeleaf的图片链接，注意设置宽度 -->
                    <img width="100%" class="am-u-sm-12" th:src="@{${commons.show_thumb(article)}}" />
                </div>

                <div class="am-u-lg-6 am-u-md-12 am-u-sm-12 blog-entry-text">
                    <!-- 右侧，用于显示文章分类、发布时间、标题、摘要等信息 -->

                    <!-- 文章分类 -->
                    <span class="blog-color" style="font-size: 18px;"><a style="color: white">默认分类</a></span>
                    <span>&nbsp;&nbsp;&nbsp;</span>

                    <!-- 发布时间 -->
                    <span style="font-size: 18px; color: white" th:text="'发布于 ' + ${commons.dateFormat(article.created)}" />

                    <h2>
                        <!-- 文章标题 -->
                        <div>
                            <a style="color: #0f9ae0; font-size: 30px;"
                               th:href="${commons.permalink(article.id)}"
                               th:text="${#strings.length(article.title) > 10 ? #strings.substring(article.title, 0, 10) + '.....' : article.title}" />  <!--设置文章标题的长度上线-->
                        </div>
                    </h2>


                    <!-- 文章摘要 -->
                    <!--设置文章摘要的长度上线-->
                    <div style="font-size: 20px; color: white" th:utext="${commons.intro(article, 42)}" />

                </div>
            </article>
        </div>

        <!-- 文章分页信息 -->
        <div class="am-pagination">
            <!-- 载入分页部分，使用Thymeleaf的replace指令 -->
            <div th:replace="/comm/paging::pageNav(${articles},'上一页','下一页','page')" />
        </div>
    </div>

    <!-- 博主信息描述 -->
    <div class="am-u-md-4 am-u-sm-12 blog-sidebar">
        <!-- 右栏，用于显示博主信息和联系方式 -->

        <div class="blog-sidebar-widget blog-bor">
            <h2 class="blog-text-center blog-title"><span style="color: black;">瑟瑟</span></h2>
            <!-- 博主名字 -->

            <img th:src="@{/assets/img/me.jpg}" alt="about me" class="blog-entry-img" />
            <!-- 博主头像 -->
        </div>

        <div class="blog-sidebar-widget blog-bor">
            <h2 class="blog-text-center blog-title"><span style="color: black;">联系我</span></h2>
            <!-- 联系方式标题 -->

            <p>
                <a th:href="@{/lxw}"><span style="color: white" class="am-icon-github am-icon-fw blog-icon"></span></a>
                <a th:href="@{/lxw}"><span style="color: pink" class="am-icon-heart am-icon-fw blog-icon"></span></a>
                <a th:href="@{/lxw}"><span style="color: lightskyblue" class="am-icon-qq am-icon-fw blog-icon"></span></a>

            </p>
            <!-- 显示社交媒体图标和联系方式 -->
        </div>
    </div>

    <!-- 阅读排行榜 -->
    <div class="am-u-md-4 am-u-sm-12 blog-sidebar">
        <!-- 右栏，用于显示阅读排行榜 -->

        <div class="blog-sidebar-widget blog-bor">
            <h2 class="blog-text-center blog-title"><span style="color: black;">阅读排行榜</span></h2>
            <!-- 排行榜标题 -->

            <div style="text-align: left">
                <!-- 使用Thymeleaf的each指令遍历文章列表 -->
                <th:block th:each="article: ${articleList}">
                        <a style="color: white; font-size: 20px;"
                           th:href="${commons.permalink(article.id)}"

                           th:text="${#strings.length(article.title) > 10 ? #strings.substring(article.title, 0, 10) + '.....' : article.title}" />  <!--设置文章标题的长度上线-->


                    <span style="font-size: 10px;color: yellow" th:text="'(点击率为:'+${article.hits}+')'" ></span>
                    <hr style="margin-top: 0.6rem; margin-bottom: 1rem" />
                </th:block>
                <!-- 显示文章排行榜，包括文章标题和点击量 -->
            </div>
        </div>
    </div>
</div>

<script src="/assets/js/jquery-3.3.1.js"></script>
<script src="/assets/js/jquery.vide.js"></script>
</body>
<!-- 载入文章尾部页面，位置在/client文件夹下的footer模板页面，模板名称th:fragment为footer -->
<div th:replace="/client/footer::footer" />
</html>

首页头部代码

<!DOCTYPE html>
<html lang="en" xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity4"
      xmlns:th="http://www.thymeleaf.org" th:fragment="header(title,keywords)">
<head>
    <meta charset="utf-8"/>
    <meta http-equiv="X-UA-Compatible" content="IE=edge, chrome=1"/>
    <meta name="renderer" content="webkit"/>
    <meta name="viewport"
          content="width=device-width, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no"/>
    <meta http-equiv="Cache-Control" content="no-transform"/>
    <meta http-equiv="Cache-Control" content="no-siteapp"/>
    <link rel="shortcut icon" th:href="@{/user/img/blogl1ogo.jpg}"/>
    <link rel="apple-touch-icon" th:href="@{/user/img/apple-touch-icon.png}"/>
    <title><th:block th:text="${title ?: '首页'}"></th:block></title>
    <link th:href="@{/user/css/xcode.min.css}" rel="stylesheet"/>
    <link th:href="@{/user/css/style.min.css}" rel="stylesheet"/>
    <script th:src="@{/assets/js/jquery.min.js}"></script>
    <script th:src="@{/assets/js/amazeui.min.js}"></script>
    <link rel="stylesheet" th:href="@{/assets/css/amazeui.min.css}"/>
    <link rel="stylesheet" th:href="@{/assets/css/app.css}"/>
    <!--[if lt IE 9]>
    <script th:src="@{/back/js/html5shiv.js}"></script>
    <script th:src="@{/back/js/respond.min.js}"></script>
    <![endif]-->
</head>
<body gtools_scp_screen_capture_injected="true" th:class="${is_post}?'':'bg-
'">
<!--[if lt IE 8]>
<div class="browsehappy" role="dialog">
    当前网页 <strong>不支持</strong> 你正在使用的浏览器. 为了正常的访问, 请 <a href="http://browsehappy.com/"
                                                                               target="_blank">升级你的浏览器</a>。
</div>
<![endif]-->
<header id="header" class="header bg-white">
    <div class="navbar-container">
        <a th:href="@{/}" class="navbar-logo">瑟瑟网站 </a>
                <div class="navbar-menu">
            <form name="logoutform" th:action="@{/logout}" method="post"></form>
            <a class="header-info" sec:authorize="isAnonymous()" th:href="@{/login}">登录</a>
            <a class="header-info" sec:authorize="isAuthenticated()" href="javascript:document.logoutform.submit();">退出</a>
            <a class="header-info" sec:authorize="isAuthenticated()" th:href="@{/toupdateUser}">用户信息页面</a>
                    <a class="header-info" sec:authorize="isAuthenticated()">发送邮件按钮</a>
                    <a class="header-info" sec:authorize="hasRole('ROLE_admin')" th:href="@{/admin/index}">后台管理</a>
        </div>
        <!--        <div class="navbar-search" onclick="">-->
        <!--            <span class="icon-search"></span>-->
        <!--            <form role="search" onsubmit="return false;">-->
        <!--                <span class="search-box">-->
        <!--                    <input type="text" id="search-inp" class="input" placeholder="搜索..." maxlength="30"-->
        <!--                           autocomplete="off"/>-->
        <!--                </span>-->
        <!--            </form>-->
        <!--        </div>-->
    </div>
</header>
</body>
</html>

首页脚部分代码

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" th:fragment="footer">
<body>
<footer class="footer bg-white">
    <div class="footer-social">
        <div class="footer-container clearfix">
            <div class="social-list">
            </div>
        </div>
    </div>
    <div class="footer-meta">
        <div class="footer-container">
            <div class="meta-item meta-copyright">
                <div class="meta-copyright-info">
                    <div class="info-text">
                        <a style="display: block;margin: 0 auto;" class="info-logo">
                            <img style="display: block;margin: 0 auto;" th:src="@{/user/img/bloglogo.jpg}"/>
                        </a>
                        <p style="margin: 30px"><time class="comment-time" th:text="${#dates.format(new java.util.Date().getTime(), 'yyyy年MM月dd日hh点mm分')}"></time> &copy; Powered By<br><a th:href="@{/}" style="color: #0c79b1" rel="nofollow">瑟瑟小站</a></p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</footer>
<script th:src="@{/user/js/headroom.min.js}"></script>
<script th:src="@{/user/js/highlight.min.js}"></script>
<script th:src="@{/user/js/instantclick.min.js}"></script>
</body>
</html>

首页详情页代码

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <!-- 引入jQuery库 -->
    <script th:src="@{/assets/js/jquery.min.js}"></script>
    <!-- 引入layer.js库 -->
    <script th:src="@{/assets/js/layer.js}"></script>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0-beta3/css/all.min.css">
</head>
<!-- 包含页面头部 -->
<div th:replace="client/header::header(${article.title},null)"></div>
<body>

<!-- 返回按钮 -->
<a href="javascript:history.back()" class="back-button">
    <i class="fas fa-arrow-left"></i> 返回上一级
</a>


<!-- 主要文章内容部分 -->
<article class="main-content post-page">

    <!-- 文章标题 -->
    <div class="post-header">
        <h1 class="post-title" itemprop="name headline" th:text="${article.title}"></h1>
        <!-- 文章发布日期 -->
        <div class="post-data">
            <time th:datetime="${commons.dateFormat(article.created)}" itemprop="datePublished"
                  th:text="'发布于 '+ ${commons.dateFormat(article.created)}"></time>
        </div>
    </div>
    <br/>
    <!-- 文章内容 -->
    <div id="post-content" class="post-content content" th:utext="${commons.article(article.content)}"></div>
</article>


<!-- 包含评论部分 -->
<div th:replace="client/comments::comments"></div>


<!-- 返回按钮 -->
<a href="javascript:history.back()" class="back-button02">
    <i class="fas fa-arrow-left"></i> 返回上一级
</a>


<!-- 包含页脚部分 -->
<div th:replace="client/footer::footer"></div>



<!-- 使用layer.js实现图片缩放功能 -->
<script type="text/JavaScript">
    // 当文章中的图片被点击时，触发图片缩放功能
    $('.post-content img').on('click', function () {
        // 获取图片 URL
        var imgurl = $(this).attr('src');
        // 设置弹出层的宽度和高度，此处指定了图片为原来的1.5倍左右
        var w = this.width * 1.5 +10;
        var h = this.height * 1.5 + 50;
        // 打开弹出层
        layer.open({
            type: 1,
            title: false, // 不显示标题栏
            area: [w + "px", h + "px"],
            shadeClose: true, // 点击遮罩关闭
            content: '\<\div style="padding:20px;">' +
                '\<\img style="width:' + (w - 50) + 'px;" src=' + imgurl + '\>\<\/div>'//将弹出框的w减50
        });
    });
</script>
<script src="/assets/js/jquery-3.3.1.js"></script>
<script src="/assets/js/jquery.vide.js"></script>
</body>
</html>

首页功能代码

package com.example.springbootten.web.client;



import com.example.springbootten.model.domain.Article;
import com.example.springbootten.model.domain.Comment;
import com.example.springbootten.service.IArticleService;
import com.example.springbootten.service.ICommentService;
import com.example.springbootten.service.ISiteService;
import com.github.pagehelper.PageInfo;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;

import javax.servlet.http.HttpServletRequest;
import java.util.List;


/**
 * @BelongsProject: Springboot  //项目名
 * @BelongsPackage: com.example.springboot  //包名
 * @ClassName IndexController                //类名
 * @Author: laozaza                   //作者
 * @CreateTime: 2023-10-26  20:31  //时间
 **/
@Controller
public class IndexController {
    private static final Logger logger = LoggerFactory.getLogger(IndexController.class);

    @Autowired
    private ICommentService commentServiceImpl;
    @Autowired
    private IArticleService articleServiceImpl;
    @Autowired
    private ISiteService siteServiceImpl;

    // 博客首页，会自动跳转到文章页
    @GetMapping(value = "/")
    private String index(HttpServletRequest request) {
        return this.index(request, 1, 5);
    }

    // 文章页
    @GetMapping(value = "/page/{p}")
    public String index(HttpServletRequest request, @PathVariable("p") int page, @RequestParam(value = "count", defaultValue = "5") int count) {
        PageInfo<Article> articles = articleServiceImpl.selectArticleWithPage(page, count);
        // 获取文章热度统计信息
        List<Article> articleList = articleServiceImpl.getHeatArticles();
        request.setAttribute("articles", articles);
        request.setAttribute("articleList", articleList);
        logger.info("分页获取文章信息: 页码 "+page+",条数 "+count);
        return "client/index";
    }


    // 文章详情查询(从Redis缓存里获取)
    @GetMapping(value = "/article/{id}")
    public String getArticleById(@PathVariable("id") Integer id, HttpServletRequest request){
        Article article = articleServiceImpl.selectArticleWithId(id);
        if(article!=null){
            // 查询封装评论相关数据
            getArticleComments(request, article);
            // 更新文章点击量
            siteServiceImpl.updateStatistics(article);
            request.setAttribute("article",article);
            return "client/articleDetails";
        }else {
            logger.warn("查询文章详情结果为空，查询文章id: "+id);
            // 未找到对应文章页面，跳转到提示页
            return "comm/error_404";
        }
    }

    // 查询文章的评论信息，并补充到文章详情里面
    private void getArticleComments(HttpServletRequest request, Article article) {
        if (article.getAllowComment()) {
            // cp表示评论页码，commentPage
            String cp = request.getParameter("cp");
            cp = StringUtils.isBlank(cp) ? "1" : cp;
            request.setAttribute("cp", cp);
            PageInfo<Comment> comments = commentServiceImpl.getComments(article.getId(),Integer.parseInt(cp),3);
            request.setAttribute("cp", cp);
            request.setAttribute("comments", comments);
        }
    }

    @GetMapping(value = "/lxw")
    private String lxw(){
return"/client/lxw";
    }

    @GetMapping(value = "/video")
    private String video(){
        return"/client/video";
    }
}

package com.example.springbootten.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**
 * 自定义Redis配置类，进行序列化以及RedisTemplate设置
 */
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    /**
     *  定制Redis API模板RedisTemplate
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        // 使用JSON格式序列化对象，对缓存数据key和value进行转换
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
        // 解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);
        // 设置RedisTemplate模板API的序列化方式为JSON
        template.setDefaultSerializer(jacksonSeial);
        return template;
    }

    /**
     * 定制Redis缓存管理器RedisCacheManager，实现自定义序列化并设置缓存时效
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        // 分别创建String和JSON格式序列化对象，对缓存数据key和value进行转换
        RedisSerializer<String> strSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
        // 解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);
        // 定制缓存数据序列化方式及时效
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(70))   // 设置缓存有效期为70秒
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(strSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jacksonSeial))
                .disableCachingNullValues();   // 对空数据不进行缓存
        RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(config).build();
        return cacheManager;
    }
}

package com.example.springbootten.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.security.web.authentication.rememberme.JdbcTokenRepositoryImpl;
import org.springframework.security.web.savedrequest.HttpSessionRequestCache;
import org.springframework.security.web.savedrequest.RequestCache;
import org.springframework.security.web.savedrequest.SavedRequest;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.sql.DataSource;
import java.io.IOException;
import java.net.URL;
import java.util.Collection;

@EnableWebSecurity  // 开启MVC security安全支持
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private DataSource dataSource;
    @Value("${COOKIE.VALIDITY}")
    private Integer COOKIE_VALIDITY;

    /**
     * @author 李晓鹏
     * @date 2023/10/13 13:43
     * @description:
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 1、自定义用户访问控制
        http.authorizeRequests()
                .antMatchers("/", "/page/**", "/article/**", "/login").permitAll()
                .antMatchers("/back/**", "/assets/**", "/user/**", "/article_img/**").permitAll()
                .antMatchers("/admin/**").hasRole("admin")
                .anyRequest().authenticated();
        // 2、自定义用户登录控制
        http.formLogin()
                .loginPage("/login")
                .usernameParameter("username").passwordParameter("password")
                .successHandler(new AuthenticationSuccessHandler() {
                    @Override
                    public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
                        String url = httpServletRequest.getParameter("url");
                        // 获取被拦截的原始访问路径
                        RequestCache requestCache = new HttpSessionRequestCache();
                        SavedRequest savedRequest = requestCache.getRequest(httpServletRequest, httpServletResponse);
                        if (savedRequest != null) {
                            // 如果存在原始拦截路径，登录成功后重定向到原始访问路径
                            httpServletResponse.sendRedirect(savedRequest.getRedirectUrl());
                        } else if (url != null && !url.equals("")) {
                            // 跳转到之前所在页面
                            URL fullURL = new URL(url);
                            httpServletResponse.sendRedirect(fullURL.getPath());
                        } else {
                            // 直接登录的用户，根据用户角色分别重定向到后台首页和前台首页
                            Collection<? extends GrantedAuthority> authorities = authentication.getAuthorities();
                            boolean isAdmin = authorities.contains(new SimpleGrantedAuthority("ROLE_admin"));
                            if (isAdmin) {
                                httpServletResponse.sendRedirect("/admin");
                            } else {
                                httpServletResponse.sendRedirect("/");
                            }
                        }
                    }
                })
                // 用户登录失败处理
                .failureHandler(new AuthenticationFailureHandler() {
                    @Override
                    public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
                        // 登录失败后，取出原始页面url并追加在重定向路径上
                        String url = httpServletRequest.getParameter("url");
                        httpServletResponse.sendRedirect("/login?error&url=" + url);
                    }
                });
        // 3、设置用户登录后cookie有效期，默认值
        http.rememberMe().alwaysRemember(true).tokenValiditySeconds(COOKIE_VALIDITY);
        // 4、自定义用户退出控制
        http.logout().logoutUrl("/logout").logoutSuccessUrl("/");
        // 5、针对访问无权限页面出现的403页面进行定制处理
        http.exceptionHandling().accessDeniedHandler(new AccessDeniedHandler() {
            @Override
            public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException, ServletException {
                // 如果是权限访问异常，则进行拦截到指定错误页面
                RequestDispatcher dispatcher = httpServletRequest.getRequestDispatcher("/errorPage/comm/error_403");
                dispatcher.forward(httpServletRequest, httpServletResponse);
            }
        });
        //定制Remember-me记住我功能
        http.rememberMe()//开启记住我功能
                .rememberMeParameter("rememberme")//指示在登录时记住用户的HTTP参数
                .tokenValiditySeconds(20)//设置记住我有效期为单位为s这里设置有效期单位为秒
                .tokenRepository(tokenRepository());//对Cookie信息进行持久化管理
    }

    //持久化token存储
    @Bean
    public JdbcTokenRepositoryImpl tokenRepository() {
        JdbcTokenRepositoryImpl jr = new JdbcTokenRepositoryImpl();
        jr.setDataSource(dataSource);
        return jr;
    }

    /**
     * 重写configure(AuthenticationManagerBuilder auth)方法，进行自定义用户认证
     *
     * @param auth
     * @throws Exception
     */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        //  密码需要设置编码器
        BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
        //  使用JDBC进行身份认证
        String userSQL = "select username,password,valid from t_user where username = ?";
        String authoritySQL = "select u.username,a.authority from t_user u,t_authority a," +
                "t_user_authority ua where ua.user_id=u.id " +
                "and ua.authority_id=a.id and u.username =?";
        auth.jdbcAuthentication().passwordEncoder(encoder)
                .dataSource(dataSource)
                .usersByUsernameQuery(userSQL)
                .authoritiesByUsernameQuery(authoritySQL);
    }
}

package com.example.springbootten.web.interceptor;


import com.example.springbootten.utils.Commons;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
 * @BelongsProject: Springboot  //项目名
 * @BelongsPackage: com.example.springboot  //包名
 * @ClassName BaseInterceptor                //类名
 * @Author: laozaza                   //作者
 * @CreateTime: 2023-10-26  20:31  //时间
 **/
/**
 * 自定义的Interceptor拦截器类，用于封装请求后的数据类到request域中，供html页面使用
 * 注意：自定义Mvc的Interceptor拦截器类
 *  1、使用@Configuration注解声明
 *  2、自定义注册类将自定义的Interceptor拦截器类进行注册使用
 */
@Configuration
public class BaseInterceptor implements HandlerInterceptor {
    @Autowired
    private Commons commons;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // 用户将封装的Commons工具返回页面
        request.setAttribute("commons",commons);
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    }
}

package com.example.springbootten.web.interceptor;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/**
 * @BelongsProject: Springboot  //项目名
 * @BelongsPackage: com.example.springboot  //包名
 * @ClassName WebMvcConfig                //类名
 * @Author: laozaza                   //作者
 * @CreateTime: 2023-10-26  20:31  //时间
 **/

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Autowired
    private BaseInterceptor baseInterceptor;

    @Override
    // 重写addInterceptors()方法，注册自定义拦截器
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(baseInterceptor);
    }
}

package com.example.springbootten.utils;

import org.apache.commons.lang3.StringUtils;
import org.commonmark.Extension;
import org.commonmark.ext.gfm.tables.TablesExtension;
import org.commonmark.node.Link;
import org.commonmark.node.Node;
import org.commonmark.parser.Parser;
import org.commonmark.renderer.html.AttributeProvider;
import org.commonmark.renderer.html.HtmlRenderer;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
/**
 * @BelongsProject: Springboot  //项目名
 * @BelongsPackage: com.example.springboot  //包名
 * @ClassName MyUtils                //类名
 * @Author: laozaza                   //作者
 * @CreateTime: 2023-10-26  20:31  //时间
 **/

/**
 * 文章处理工具类
 */
public class MyUtils {

    /**
     * 从HTML中提取纯文本
     *
     * @param html HTML字符串
     * @return 提取的纯文本
     */
    public static String htmlToText(String html) {
        if (StringUtils.isNotBlank(html)) {
            // 此方法将HTML标签和空格替换为单个空格，以获得纯文本内容。
            return html.replaceAll("(?s)<[^>]*>(\\s*<[^>]*>)*", " ");
        }
        return "";
    }

    /**
     * 将Markdown格式的文本转换为HTML
     *
     * @param markdown Markdown格式的文本
     * @return 转换后的HTML文本
     */
    public static String mdToHtml(String markdown) {
        if (StringUtils.isBlank(markdown)) {
            return "";
        }
        // 创建Markdown解析器，并添加表格扩展
        List<Extension> extensions = Arrays.asList(TablesExtension.create());
        Parser parser = Parser.builder().extensions(extensions).build();
        // 解析Markdown文本并生成相应的HTML文档
        Node document = parser.parse(markdown);
        // 创建HTML渲染器，配置属性提供者以处理链接的属性
        HtmlRenderer renderer = HtmlRenderer.builder()
                .attributeProviderFactory(context -> new LinkAttributeProvider())
                .extensions(extensions).build();
        // 渲染HTML文档，进行额外处理，例如表情替换
        String content = renderer.render(document);
        content = Commons.emoji(content); // 使用emoji方法进行额外处理
        return content;
    }

    /**
     * 清除输入值中的HTML脚本和潜在的XSS攻击
     *
     * @param value 输入值
     * @return 清除HTML脚本后的值
     */
    public static String cleanXSS(String value) {
        // 以下代码通过正则表达式替换一些潜在的XSS攻击代码。
        value = value.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
        value = value.replaceAll("\\(", "&#40;").replaceAll("\\)", "&#41;");
        value = value.replaceAll("'", "&#39;");
        value = value.replaceAll("eval\\((.*)\\)", "");
        value = value.replaceAll("[\\\"\\\'][\\s]*javascript:(.*)[\\\"\\\']", "\"\"");
        value = value.replaceAll("script", "");
        return value;
    }

    // 链接属性提供者，用于设置链接的target属性为"_blank"以在新标签页中打开
    private static class LinkAttributeProvider implements AttributeProvider {
        @Override
        public void setAttributes(Node node, String tagName, Map<String, String> attributes) {
            if (node instanceof Link) {
                attributes.put("target", "_blank");
            }
        }
    }
}

package com.example.springbootten.utils;


import com.example.springbootten.model.domain.Article;
import com.vdurmont.emoji.EmojiParser;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;

/**
 * @BelongsProject: Springboot  // 项目名
 * @BelongsPackage: com.example.springboot  // 包名
 * @ClassName Commons                // 类名
 * @Author: laozaza                   // 作者
 * @CreateTime: 2023-10-26  20:31  // 时间
 **/

/**
 * 页面数据展示封装类
 */
@Component
public class Commons {
    /**
     * 网站链接
     *
     * @return
     */
    public static String site_url() {
        return site_url("/page/1");
    }

    /**
     * 返回网站链接下的全址
     *
     * @param sub 后面追加的地址
     * @return
     */
    public static String site_url(String sub) {
        return site_option("site_url") + sub;
    }

    /**
     * 网站配置项
     *
     * @param key
     * @return
     */
    public static String site_option(String key) {
        return site_option(key, "");
    }

    /**
     * 网站配置项
     *
     * @param key
     * @param defalutValue 默认值
     * @return
     */
    public static String site_option(String key, String defalutValue) {
        if (StringUtils.isBlank(key)) {
            return "";
        }
        return defalutValue;
    }

    /**
     * 截取字符串
     *
     * @param str
     * @param len
     * @return
     */
    public static String substr(String str, int len) {
        if (str.length() > len) {
            return str.substring(0, len);
        }
        return str;
    }

    /**
     * 返回日期
     *
     * @return
     */
    public static String dateFormat(Date date) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        return format.format(date);
    }

    /**
     * 返回文章链接地址
     *
     * @param aid
     * @return
     */
    public static String permalink(Integer aid) {
        return site_url("/article/" + aid.toString());
    }

    /**
     * 生成文章的摘要文本。如果文章包含分隔符"<!--more-->"，摘要将是分隔符之前的内容；如果没有分隔符，摘要将是全文的前 len 个字符，并附加省略号以指示文本被截断。
     *
     * @param article  文章对象，包含文章内容
     * @param len      摘要的最大长度
     * @return 生成的摘要文本
     */
    public static String intro(Article article, int len) {
        // 从文章对象中获取文章内容
        String value = article.getContent();

        // 检查文章内容是否包含分隔符"<!--more-->"
        int pos = value.indexOf("<!--more-->");

        if (pos != -1) {
            // 如果包含分隔符
            // 从文章内容的开头截取到分隔符位置之前的部分，形成一个子字符串
            String html = value.substring(0, pos);

            // 将子字符串转换为HTML格式，然后再转换为纯文本，去除HTML标签和其他格式
            return MyUtils.htmlToText(MyUtils.mdToHtml(html));
        } else {
            // 如果不包含分隔符
            // 将整篇文章的Markdown内容转换为HTML格式，然后再转换为纯文本，去除HTML标签和其他格式
            String text = MyUtils.htmlToText(MyUtils.mdToHtml(value));

            if (text.length() > len) {
                // 如果纯文本长度超过了 len，截取前 len 个字符，然后在末尾添加省略号"..."
                return text.substring(0, len) + "......";
            } else {
                // 如果纯文本长度未超过 len，返回生成的全文纯文本
                return text;
            }
        }
    }



    /**
     * 对文章内容进行格式转换，将Markdown为Html
     * @param value
     * @return
     */
    public static String article(String value) {
        if (StringUtils.isNotBlank(value)) {
            value = value.replace("<!--more-->", "\r\n");
            return MyUtils.mdToHtml(value);
        }
        return "";
    }

    /**
     * 显示文章缩略图，顺序为：文章第一张图 -> 随机获取
     *
     * @return
     */
    public static String show_thumb(Article article) {
        // 1. 检查文章对象是否包含有效的缩略图信息
        if (StringUtils.isNotBlank(article.getThumbnail())) {
            // 2. 如果缩略图不为空，直接返回缩略图路径
            return article.getThumbnail();
        }

        // 3. 从文章对象获取ID
        int cid = article.getId();

        // 4. 计算缩略图的大小（size）：ID对24取余
        int size = cid % 24;

        // 5. 如果size等于0，将其设置为1，确保不会为零
        size = size == 0 ? 1 : size;

        //设置一个随机数如果文章id大于16则采用图片库里随机图片
        if (size>16){
            Random random = new Random();
            int randomNumber = random.nextInt(17);
            size=randomNumber;
            // 5. 如果size等于0，将其设置为1，确保不会为零
            size = size == 0 ? 1 : size;
        }

        //  返回最终的缩略图路径
        return "/user/img/rand/" + size + ".png";
    }

    /**
     * 这种格式的字符转换为emoji表情
     *
     * @param value
     * @return
     */
    public static String emoji(String value) {
        return EmojiParser.parseToUnicode(value);
    }
}

package com.example.springbootten.service.impl;


import com.example.springbootten.dao.ArticleMapper;
import com.example.springbootten.dao.CommentMapper;
import com.example.springbootten.dao.StatisticMapper;
import com.example.springbootten.model.domain.Article;
import com.example.springbootten.model.domain.Statistic;
import com.example.springbootten.service.IArticleService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

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


/**
 * @BelongsProject: Springboot  //项目名
 * @BelongsPackage: com.example.springboot  //包名
 * @ClassName ArticleServiceImpl                //类名
 * @Author: laozaza                   //作者
 * @CreateTime: 2023-10-26  20:31  //时间
 **/

/**
 * 这是 Spring Boot 应用中的文章服务实现类，用于提供与文章相关的功能。
 */
@Service
@Transactional
public class ArticleServiceImpl implements IArticleService {
    @Autowired
    private ArticleMapper articleMapper;
    @Autowired
    private StatisticMapper statisticMapper;
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private CommentMapper commentMapper;

    // 分页查询文章列表
    @Override
    public PageInfo<Article> selectArticleWithPage(Integer page, Integer count) {
        PageHelper.startPage(page, count);
        List<Article> articleList = articleMapper.selectArticleWithPage();
        // 封装文章统计数据
        for (int i = 0; i < articleList.size(); i++) {
            Article article = articleList.get(i);
            Statistic statistic = statisticMapper.selectStatisticWithArticleId(article.getId());
            article.setHits(statistic.getHits());
            article.setCommentsNum(statistic.getCommentsNum());
        }
        PageInfo<Article> pageInfo=new PageInfo<>(articleList);
        return pageInfo;
    }

    // 统计前10的热度文章信息
    @Override
    public List<Article> getHeatArticles() {
        // 从数据库中获取文章热度统计信息
        List<Statistic> list = statisticMapper.getStatistic();
        // 创建一个用于存储前10热门文章的列表
        List<Article> articlelist = new ArrayList<>();

        // 遍历统计信息列表
        for (int i = 0; i < list.size(); i++) {
            // 从文章ID获取文章详细信息
            Article article = articleMapper.selectArticleWithId(list.get(i).getArticleId());
            // 设置文章的点击数（热度）和评论数
            article.setHits(list.get(i).getHits());
            article.setCommentsNum(list.get(i).getCommentsNum());
            // 将文章添加到热门文章列表
            articlelist.add(article);

            // 如果已经获取了前15篇文章，就跳出循环
            if (i >= 14) {
                break;
            }
        }

        // 返回前10篇热门文章的列表
        return articlelist;
    }


    // 根据id查询单个文章详情，并使用Redis进行缓存管理
    public Article selectArticleWithId(Integer id){
        Article article = null;
        Object o = redisTemplate.opsForValue().get("article_" + id);
        if(o!=null){
            article=(Article)o;
        }else{
            article = articleMapper.selectArticleWithId(id);
            if(article!=null){
                redisTemplate.opsForValue().set("article_" + id,article);
            }
        }
        return article;
    }


    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public int addArticle(Article article) {
        if (StringUtils.isEmpty(article.getCategories())){
            article.setCategories("默认分类");
        }
        article.setAllowComment(true);
        int i = articleMapper.addArticle(article);
        Statistic statistic=new Statistic(null,article.getId(),0,0);
        statisticMapper.addStatistic1(statistic);

        return i;
    }

    @Override
    public PageInfo<Article> findAllArticle(Integer pageNum, Integer pageSize) {
        PageHelper.startPage(pageNum,pageSize);
        List<Article> allArticle = articleMapper.findAllArticle();
        return new PageInfo<>(allArticle);
    }

    @Override
    public int deleteArticle(Integer id) {
        int i = articleMapper.deleteArticle(id);
        return i;
    }

    @Override
    public List<Article> findArticleByHits() {
        return articleMapper.findArticleByHits();
    }

    @Override
    public Integer countArticle() {
        Integer i = articleMapper.countArticle();
        return i;
    }

    @Override
    public Article findArticleById(Integer id) {
        return articleMapper.findArticleById(id);
    }

    @Override
    public int updateArticle(Article article) {
        int i = articleMapper.updateArticle(article);
        return i;
    }


}

学习心得

标题：Spring Boot学习心得

Spring Boot是一个用于简化Spring应用程序开发的框架，它提供了一种快速构建、易于维护的方式，使开发人员能够更专注于业务逻辑而不必处理繁杂的配置和设置。在我学习Spring Boot的过程中，我积累了不少经验和心得，下面我将分享一些我认为重要的学习心得。

### 1. 简化配置

Spring Boot通过自动配置（Auto-Configuration）来减少了开发人员的配置负担。它可以根据类路径上的库和依赖自动配置应用程序的各个组件，这大大减少了编写XML配置文件的需求。此外，Spring Boot还提供了一组预定义的starter依赖，用于快速集成常见的功能，如数据库连接、Web开发、安全性等。这使得开发者只需在项目中引入适当的starter依赖，而无需手动配置这些功能。

### 2. 内嵌Web服务器

Spring Boot默认集成了多种内嵌的Web服务器，如Tomcat、Jetty和Undertow。这意味着您可以将应用程序打包成一个可执行的JAR文件或WAR文件，而不必担心安装和配置外部Web服务器。这一特性大大简化了应用程序的部署和管理。

### 3. 基于约定的开发

Spring Boot采用了"约定优于配置"的开发理念。它定义了一些默认的约定，如项目结构、类命名规范等，使得开发人员能够快速上手并保持一致的项目结构。这有助于提高团队协作和维护性。

### 4. 外部化配置

Spring Boot支持外部化配置，可以将配置信息放在外部文件中，如application.properties或application.yml。这使得在不同环境中部署应用程序时，可以轻松切换配置，而不必修改源代码。Spring Boot还支持不同的配置文件，如application-dev.properties、application-prod.properties等，以满足不同环境的需求。

### 5. Spring Boot Starter

Spring Boot提供了各种starter依赖，这些依赖能够快速引入常见的功能。比如，如果您需要开发一个Web应用程序，只需引入spring-boot-starter-web依赖即可，它会自动配置Spring MVC、Tomcat等必要组件。这种方式简化了项目的依赖管理，减少了版本冲突的可能性。

### 6. 自定义配置

尽管Spring Boot提供了很多自动配置的功能，但它也允许开发人员进行自定义配置。通过编写自定义配置类和属性文件，您可以调整应用程序的行为以满足特定需求。这种灵活性是Spring Boot的一大优势，使得开发人员既能享受自动配置的便捷，又能根据实际情况进行个性化设置。

### 7. Spring生态系统集成

Spring Boot是建立在Spring Framework之上的，因此可以轻松集成Spring的各种组件，如Spring Data、Spring Security、Spring Cloud等。这意味着您可以在Spring Boot应用中充分利用Spring生态系统的功能，以满足不同的业务需求。

### 8. 生态系统支持

Spring Boot拥有强大的生态系统，有大量社区支持和第三方库可供选择。您可以在Spring Boot社区中找到大量的文档、教程和示例代码，以帮助您解决开发中的各种问题。此外，Spring Boot还提供了许多插件和工具，用于构建、测试和部署应用程序。

总的来说，学习Spring Boot是一项有趣而且富有挑战的任务。它的简化配置、内嵌Web服务器、基于约定的开发方式以及丰富的生态系统使得开发人员能够更加高效地开发应用程序。通过掌握Spring Boot，我深刻体会到了它对提高开发效率和降低维护成本的重要性。希望我的学习心得能够对其他想要学习Spring Boot的人有所帮助，让他们能够更快地掌握这一强大的框架，实现自己的项目和创意。