【SpringBoot搭建个人博客】- 框架搭建（三）

以你之姓@ 2021-09-21 07:48 508阅读 0赞

> 博客地址：[ONESTARの客栈][ONESTAR]
> 
> 源码领取方式一：
> 
>  *  扫一扫文末二维码，关注公众号，后台回复【博客】，即可领取源码
> 
> 源码领取方式二：
> 
>  *  前端页面源码地址：[https://github.com/oneStarLR/myblog-page][https_github.com_oneStarLR_myblog-page]
>  *  以jpa为持久层源码地址：[https://github.com/oneStarLR/myblog-jpa][https_github.com_oneStarLR_myblog-jpa]
>  *  以mybatis为持久层源码地址：[https://github.com/oneStarLR/myblog-mybaits][https_github.com_oneStarLR_myblog-mybaits]
> 
> 欢迎给star以鼓励(^\_−)☆

本文将从**构建SpringBoot框架**、**异常处理**、**日志处理**来讲述个人博客系统后台框架搭建，技术需求可以查看上一篇文章：[【SpringBoot搭建个人博客】- 技术需求（二）][SpringBoot_-]

### 一、构建SpringBoot框架 ###

1.使用idea快速搭建SpringBoot框架

使用idea新建项目，这里使用的是jdk1.8，选择相应组件，这里选择如下，点击下一个，选择保存路径创建好项目（对于SpringBoot不是很清楚的伙伴可以看我之前的博客[：SpringBoot 框架入门][SpringBoot]、[SpringBoot框架原理分析][SpringBoot 1]）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70][]

创建好项目后，很根据刚选择的组件自动添加依赖，当然，这里只有我们需要的一部分，还有一些依赖等用到的时候再来添加

2.配置yml文件

创建好SpringBoot项目后，框架自带的是properties文件，这里使用yml文件进行配置，所以将application.properties改为application.yml文件，并进行相关配置。 我们在开发项目的时候，一般开发环境和部署环境会不一样，为了加以区分，可以在yml配置文件中体现出来，所以分为application-dev.yml(开发环境)、application-pro.yml(部署环境)，而为了能够让SpringBoot知道用的是哪个配置文件，需要在application.yml配置文件中加以说明，并且开发和部署中相同的配置也可以在application.yml中进行配置，详细配置如下：

*  application.yml：公共配置和表明当前配置文件
 *  application-dev.yml：开发环境配置文件
 *  application-pro.yml：部署环境配置文件

application.yml

spring:
      thymeleaf:
        mode: HTML
      profiles:
        active: pro
        
    mybatis:
      type-aliases-package: com.star.entity
      mapper-locations: classpath:mapper/*.xml
      configuration:
        map-underscore-to-camel-case: true

application-dev.yml

spring:
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/myblog?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
        username: root
        password: 111111
    
    logging:
      level:
        root: info
        com.star: debug
      file: log/blog-dev.log

application-pro.yml

spring:
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/myblog?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC&serverTimezone=GMT%2B8
        username: root
        password: 111111
    
    logging:
      level:
        root: warn
        com.star: info
      file: log/blog-pro.log

在上面的配置中，可以看到，公共部分application.yml配置了thymeleaf模板、当前配置活跃文件、数据持久层的配置，开发环境和部署环境配置了数据库（两个环境的数据库用户名和密码一般会不一样），然后就是日志文件的相关配置，可以在指定文件夹下生成日志文件。

SpringBoot中有日志默认的生成以及切分，在这里我们可以重写SpringBoot默认日志配置，自定义日志大小和名称等等，在资源文件夹下添加logback-spring.xml进行配置，配置如下：

<?xml version="1.0" encoding="UTF-8" ?>
    <configuration>
        
        <include resource="org/springframework/boot/logging/logback/defaults.xml" />
        <property name="LOG_FILE" value="${LOG_FILE:-${LOG_PATH:-${LOG_TEMP:-${java.io.tmpdir:-/tmp}}}/spring.log}"/>
        <include resource="org/springframework/boot/logging/logback/console-appender.xml" />
    
        
        <appender name="TIME_FILE"
                  class="ch.qos.logback.core.rolling.RollingFileAppender">
            <encoder>
                <pattern>${FILE_LOG_PATTERN}</pattern>
            </encoder>
            <file>${LOG_FILE}</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${LOG_FILE}.%d{yyyy-MM-dd}.%i</fileNamePattern>
                
                <maxHistory>30</maxHistory>
                
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>10MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
    
            </rollingPolicy>
        </appender>
    
        <root level="INFO">
            <appender-ref ref="CONSOLE" />
            <appender-ref ref="TIME_FILE" />
        </root>
    
    </configuration>

3.运行

由于本系列博客只讲述博客后端的开发，前端不会细说，页面直接拿来用，可以直接从GitHub中下载前端页面（欢迎star）：[https://github.com/oneStarLR/myblog-page][https_github.com_oneStarLR_myblog-page] ，将前端页面导入进项目中，注意目录别放错了

至此，基本框架搭建完成，可以运行一下了，可以看到在dev和pro配置下打印的log日志以及在项目中自动生成一个log文件夹，存放dev和pro日志文件。

dev日志打印：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 1][]

pro日志打印：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 2][]

开发的时候为了能看到更多的信息，使用dev配置环境

### 二、异常处理 ###

在页面访问的时候，会有一些比较常见的异常报错信息，比如路径无法访问404异常、服务器错误500异常以及自己定义的错误页面等等，SpringBoot框架提供了处理错误页面的方法，在这里，咱们对404、500、error异常页面进行处理。

1.定义错误页面

可以在前端页面templates目录下有error文件夹，SpringBoot可以通过文件夹的名称和错误文件命名的方式找到异常页面，所以文件名称只能固定，有以下异常页面：

*  404.html
 *  500.html
 *  error.html

可以通过控制器来测试一下，在com.star文件夹下面新建controller包，创建IndexController控制器作为首页控制器，代码如下：

package com.star.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.GetMapping;
    
    /**
     * @Description: 首页控制器
     * @Date: Created in 21:01 2020/5/20
     * @Author: ONESTAR
     * @QQ群: 530311074
     * @URL: https://onestar.newstar.net.cn/
     */
    @Controller
    public class IndexController {
        //通过get方式请求路径
        @GetMapping("/")
        public String index(){
            return "index";
        }
    }

404页面测试：可以在在浏览器输入：[http://localhost:8080/][http_localhost_8080] ，可以访问到博客的首页，可以通过改变路径，如加一个无效的后缀，访问后发现跳转到我自己写的404页面

500页面测试：可以在IndexController控制器中加一句错误代码，人为的让服务器出错，如加一句：int a = 9/0; （分母不能为零，这样服务器就会出错），然后访问：[http://localhost:8080/，][http_localhost_8080 1] 发现跳转到了500页面，这就说明没有问题（记得把导致500的错误注释掉）

2.全局异常处理

对于404和500错误页面，SpringBoot可以根据页面的命名方式找到对应的文件，而自定义的错误就需要我们自己来拦截了，让代码出现问题的时候跳转到我们自己定义的错误页面，这里就需要自定义拦截器。

在com.star文件夹下面新建hander包，创建ControllerExceptionHandler错误页面拦截器，通过定义这个类来拦截所有的异常，代码如下：

package com.star.controller.hander;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.core.annotation.AnnotationUtils;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseStatus;
    import org.springframework.web.servlet.ModelAndView;
    
    import javax.servlet.http.HttpServletRequest;
    
    /**
     * @Description: 拦截异常处理
     * @Date: Created in 21:40 2020/5/20
     * @Author: ONESTAR
     * @QQ群: 530311074
     * @URL: https://onestar.newstar.net.cn/
     */
    @ControllerAdvice
    public class ControllerExceptionHandler {
    
    //    将异常记录到日志
        private final Logger logger = LoggerFactory.getLogger(this.getClass());
    
        /**
         * @Description: 处理错误信息
         * @Auther: ONESTAR
         * @Date: 21:52 2020/5/20
         * @Param: request：访问的异常URL
         * @Param: e：异常参数
         * @Return: 返回错误信息页面
         */
        @ExceptionHandler(Exception.class)
        public ModelAndView exceptionHander(HttpServletRequest request, Exception e) throws Exception {
    
    //        记录异常信息：请求的URL，异常信息
            logger.error("Requst URL : {}，Exception : {}", request.getRequestURL(),e);
    
    //        当标识了状态码的时候就不拦截
            if (AnnotationUtils.findAnnotation(e.getClass(), ResponseStatus.class) != null) {
                throw e;
            }
    
    //        将记录的异常信息返回到error页面
            ModelAndView mv = new ModelAndView();
            mv.addObject("url",request.getRequestURL());
            mv.addObject("exception", e);
            mv.setViewName("error/error");
            return mv;
        }
    }

> 分析：
> 
>  *  @ControllerAdvice表示拦截掉所有带有@Controller注解的控制器
>  *  @ExceptionHandler表明是异常处理方法
>  *  ModelAndView：返回一个页面信息
>  *  通过拦截异常信息，在日志中记录，并返回给error页面
>  *  标识了状态码的时候就不拦截，如资源找不到异常

3.资源找不到异常处理

对于资源找不到异常，一般也是要跳转到404页面的，这里就需要自定义一个异常类，专门用来应对资源找不到，在com.star文件夹下面新建NotFoundException类。

package com.star;
    
    import org.springframework.http.HttpStatus;
    import org.springframework.web.bind.annotation.ResponseStatus;
    
    /**
     * @Description: 自定义异常
     * @Author: ONESTAR
     * @Date: Created in 16:03 2020/3/25
     * @QQ群: 530311074
     * @URL: https://onestar.newstar.net.cn/
     */
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public class NotFoundException extends RuntimeException{
        public NotFoundException() {
        }
    
        public NotFoundException(String message) {
            super(message);
        }
    
        public NotFoundException(String message, Throwable cause) {
            super(message, cause);
        }
    }

> 分析：
> 
>  *  继承RuntimeException，实现继承RuntimeException的构造函数
>  *  @ResponseStatus(HttpStatus.NOT\_FOUND)注解表示资源找不到的状态码，标识了状态码的时候就不拦截

### 三、日志处理 ###

采用SpringBoot中的AOP进行日志处理，AOP可以以切面的形式拦截，将日志内容记录下来，这里记录以下日志信息：

*  访问的URL
 *  访问者的IP
 *  访问时调用的方法
 *  访问时传递的参数
 *  访问时返回的内容

**1.添加依赖**

在pom.xml中添加AOP的依赖

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

**2.切面处理**

在com.star文件夹下面新建aspect包，创建LogAspect日志切面处理类，在这里对日志进行处理，代码如下：

package com.star.aspect;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.Arrays;
    
    /**
     * @Description: 日志切面处理
     * @Date: Created in 23:31 2020/5/21
     * @Author: ONESTAR
     * @QQ群: 530311074
     * @URL: https://onestar.newstar.net.cn/
     */
    @Aspect
    @Component
    public class LogAspect {
        //获取日志信息
        private final Logger logger = LoggerFactory.getLogger(this.getClass());
    
        //定义切面，申明log()是一个切面
        @Pointcut("execution(* com.star.controller.*.*(..))")
        public void log() {}
    
        //在切面之前执行
        @Before("log()")
        public void doBefore(JoinPoint joinPoint) {
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();
            //获取URL、IP
            String url = request.getRequestURL().toString();
            String ip = request.getRemoteAddr();
            //获取请求方法
            String classMethod = joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName();
            //获取请求参数
            Object[] args = joinPoint.getArgs();
            RequestLog requestLog = new RequestLog(url, ip, classMethod, args);
            logger.info("Request : {}", requestLog);
        }
    
        //在切面之后执行
        @After("log()")
        public void doAfter() {
    //        logger.info("--------doAfter--------");
        }
    
        //返回之后拦截
        @AfterReturning(returning = "result",pointcut = "log()")
        public void doAfterRuturn(Object result) {
            logger.info("Result : {}", result);
        }
    
    //    封装请求参数
        private class RequestLog {
            private String url;
            private String ip;
            private String classMethod;
            private Object[] args;
    
            public RequestLog(String url, String ip, String classMethod, Object[] args) {
                this.url = url;
                this.ip = ip;
                this.classMethod = classMethod;
                this.args = args;
            }
    
            @Override
            public String toString() {
                return "{" +
                        "url='" + url + '\'' +
                        ", ip='" + ip + '\'' +
                        ", classMethod='" + classMethod + '\'' +
                        ", args=" + Arrays.toString(args) +
                        '}';
            }
        }
    }

分析：

*  @Aspect注解：AOP切面作用
 *  @Component注解：开启组件扫描，通过注解找到要扫描的对象
 *  @Pointcut("execution(\* com.star.controller.*.*(..))")：定义切面，申明log()是一个切面，通过execution来表示需要拦截的类，这里表示拦截控制器下面的所有类所有方法
 *  RequestLog：将请求的参数封装成一个内部类
 *  在访问页面（controller）之前，拦截请求的URL、IP、调用的方法、传递的参数、返回的内容，并记录到日志

运行项目，访问http://localhost:8080/，可以在控制台看到打印日志信息，记录了请求的URL、IP、调用的方法、传递的参数、返回的内容，并输入到了日志

![20200522170054306.jpeg][]

至此，配合前端页面，框架就搭建完成

--------------------

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 3][]

[ONESTAR]: https://onestar.newstar.net.cn/
[https_github.com_oneStarLR_myblog-page]: https://github.com/oneStarLR/myblog-page
[https_github.com_oneStarLR_myblog-jpa]: https://github.com/oneStarLR/myblog-jpa
[https_github.com_oneStarLR_myblog-mybaits]: https://github.com/oneStarLR/myblog-mybaits
[SpringBoot_-]: https://onestar.newstar.net.cn/blog/38
[SpringBoot]: https://onestar.newstar.net.cn/blog/27
[SpringBoot 1]: https://onestar.newstar.net.cn/blog/29
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70]: /images/20210920/0881474d3938499db9e082d5e9cb700c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 1]: /images/20210920/2bde1b1ae64444e59002618584d9cfc7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 2]: /images/20210920/e381719382d64d86bc8a9e23a58aaa96.png
[http_localhost_8080]: http://localhost:8080/
[http_localhost_8080 1]: http://localhost:8080/%EF%BC%8C
[20200522170054306.jpeg]: /images/20210920/5ef95a121be145c8888333f5803dc3d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09uZV9MX1N0YXI_size_16_color_FFFFFF_t_70 3]: /images/20210920/02af02455dd3489c8ea582f650957002.png