从零开始构建前后端分离脚手架(一):基本的环境搭建

最新推荐文章于 2023-11-08 16:54:07 发布

sink zhang

最新推荐文章于 2023-11-08 16:54:07 发布

阅读量849

点赞数 1

分类专栏：项目开发文章标签： spring

本文链接：https://blog.csdn.net/Zhangjiangyuan/article/details/106264587

版权

项目开发专栏收录该内容

14 篇文章 0 订阅

订阅专栏

概述

学的越多忘记的越多，有些东西需要总结一下，今天从零开始以springboot为基础，搭建一个前后端分离的单体应用，由于篇幅较大，主要分成四五篇文章，自己写的如果有什么问题欢迎指出

主要使用技术

项目是前后端分离的，并没有使用vue来构建，使用ajax的一个工具类包装来作为前后端之间的协调接口，为了巩固下基础持久层使用mybatis框架，并不使用mybatis-plus，所有数据的传递格式都是用json进行传递

构建项目

导入相应的jar包以及依赖

创建项目的时候先直接拖入主要的依赖，目的就是图方便，以后需要用到的时候再补充以及添加
基本依赖
引入以后可能用到的依赖
fastJson主要用来做json字符串的格式化相对jackson封装比较完善

        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.68</version>
        </dependency>

druid日志监控

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.22</version>
</dependency>

整合持久层

创建数据库

新建数据库名为divide,并连接上idea
在这里插入图片描述

权限管理

权限管理主要是人员和权限之间的关系，但是用户直接和权限打交道，那么权限的赋值，权限的撤销以及权限的变动会非常的麻烦，这样引入了，角色，给角色赋权限，然后给用户分配角色, 这样，就构造成“用户-角色-权限”的授权模型。在这种模型中，用户与角色之间、角色与权限之间，通常都是多对多的关系,如果用户权限过多分配角色麻烦，可以使用用户组

用户、角色、权限数据库设计

主要涉及的有一下五张表，用户和角色以及角色和权限之间的关系是多对多

用户表（用于存储用户的所有信息）User

权限表（用于存储所有的权限）Permission

角色表（用于存储所有的角色）Role

用户和角色的关联表（用户和角色的关联）User_Role

角色和权限的关联表（角色和权限的关联）Role_Permission

创建对应的表

根据数据库的设计在idea中创建相应的表
在这里插入图片描述

整合druid

server.port=8080
spring.application.name=divide

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.druid.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.druid.url=jdbc:mysql://123.207.115.84:3306/divide?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.druid.username=root
spring.datasource.druid.password=lynu
spring.datasource.druid.initial-size=5
spring.datasource.druid.max-active=20
spring.datasource.druid.min-idle=5
spring.datasource.druid.max-wait=60000
spring.datasource.druid.pool-prepared-statements=true
spring.datasource.druid.max-pool-prepared-statement-per-connection-size=20
spring.datasource.druid.validation-query=SELECT 1 FROM DUAL
spring.datasource.druid.validation-query-timeout=30000
spring.datasource.druid.test-on-borrow=false
spring.datasource.druid.test-on-return=false
spring.datasource.druid.test-while-idle=true
spring.datasource.druid.time-between-eviction-runs-millis=60000
spring.datasource.druid.min-evictable-idle-time-millis=300000
spring.datasource.druid.filters=stat,wall
spring.datasource.druid.stat-view-servlet.login-username=admin
spring.datasource.druid.stat-view-servlet.login-password=666666

并配置mybatis配置文件的扫描路径

mybatis.mapper-locations=classpath:mapper/*.xml

使用EasyCode插件生成持久层相应的文件，自带中文提示特别友好
在这里插入图片描述
启动类中配置扫描@MapperScan("com.example.demo.dao")

持久层测试

测试mybatis

由于项目逻辑简单，主要搭建的是一个骨架，因此暂时直接忽略业务层，来调用dao层的接口进行测试
在这里插入图片描述
如图正常打印，则springboot与mybatis整合成功

测试druid

进入druid监控平台，在登录界面输入.propertis文件中配置的相应的账号密码，成功进入系统
在这里插入图片描述

配置Swagger

swagger是前后端交互的桥梁，也是说是前后端联调的重要工具，可以进行接口的测试以及数据的校验，以后的数据的联调就是用swagger进行全局的统一处理，以后测试就使用swagger进行测试
swagger主要是在开发阶段需要开启，可以进行前后端的联调，项目上线的时候要及时关闭，因此我们需要配置一个swagger的开关，可以方便开启和关闭swagger,因此配置：

swagger2.enable=true

然后在项目中配置swagger配置类,为了让整合更有通用性以及清晰度，在Swagger文档核心对象中分别配置了前台api页面，以及后台api页面，将所有的api接口分开
在这里插入图片描述
具体配置代码如下：

package com.example.demo.config;

import com.google.common.base.Predicates;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Value("${swagger2.enable}")
    private boolean enable;


    //生成swagger文档核心对象
    @Bean
    public Docket webApiConfig(){
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("webApi")
                .apiInfo(webApiInfo())
                .select()
                .paths(Predicates.and(PathSelectors.regex("/api/.*")))
                .build();
    }

    @Bean
    public Docket adminApiConfig(){
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("adminApi")
                .apiInfo(adminApiInfo())
                .select()
                .paths(Predicates.and(PathSelectors.regex("/admin/.*")))
                .build();
    }

    private ApiInfo webApiInfo(){
        return new ApiInfoBuilder()
                .title("网站的API文档")
                .description("本文档描述了前台的api接口定义")
                .version("1.0")
                .contact(new Contact("zjy", "zjycast.club", "55317332@qq.com"))
                .build();
    }

    private ApiInfo adminApiInfo(){
        return new ApiInfoBuilder()
                .title("后台管理系统的API文档")
                .description("本文档描述了后台管理的api接口定义")
                .version("1.0")
                .contact(new Contact("zjy", "zjycast.club", "2309968146@qq.com"))
                .build();
    }
}

测试swagger

测试swaggger，测试成功
在这里插入图片描述

日志整合处理

sprongboot使用的默认日志框架是Logback。

可以在application.properties配置简单日志属性，也可以单独配置logback.xml格式，还可以使用log4j来管理。
自带的日志配置简单粗暴，修改application.properties

#logging
logging.file=${logging.path}/${spring.application.name}.log
logging.path=logs
logging.level.root=info
mybatis.mapper-locations=classpath:mapper/*.xml

下面介绍如何使用log4j来作为日志管理

第一步：引入log4j依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j</artifactId>
            <version>1.3.8.RELEASE</version>
</dependency>

第二步：创建一个log4j.properties的配置文件

#log4j.rootLogger=CONSOLE,info,error,DEBUG
log4j.rootLogger=info,error,CONSOLE,DEBUG
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender     
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout     
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n     
log4j.logger.info=info
log4j.appender.info=org.apache.log4j.DailyRollingFileAppender
log4j.appender.info.layout=org.apache.log4j.PatternLayout     
log4j.appender.info.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.info.datePattern='.'yyyy-MM-dd
log4j.appender.info.Threshold = info   
log4j.appender.info.append=true   
#log4j.appender.info.File=/home/admin/pms-api-services/logs/info/api_services_info
log4j.appender.info.File=/Users/dddd/Documents/testspace/pms-api-services/logs/info/api_services_info
log4j.logger.error=error  
log4j.appender.error=org.apache.log4j.DailyRollingFileAppender
log4j.appender.error.layout=org.apache.log4j.PatternLayout     
log4j.appender.error.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.error.datePattern='.'yyyy-MM-dd
log4j.appender.error.Threshold = error   
log4j.appender.error.append=true   
#log4j.appender.error.File=/home/admin/pms-api-services/logs/error/api_services_error
log4j.appender.error.File=/Users/dddd/Documents/testspace/pms-api-services/logs/error/api_services_error
log4j.logger.DEBUG=DEBUG
log4j.appender.DEBUG=org.apache.log4j.DailyRollingFileAppender
log4j.appender.DEBUG.layout=org.apache.log4j.PatternLayout     
log4j.appender.DEBUG.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.DEBUG.datePattern='.'yyyy-MM-dd
log4j.appender.DEBUG.Threshold = DEBUG   
log4j.appender.DEBUG.append=true   
#log4j.appender.DEBUG.File=/home/admin/pms-api-services/logs/debug/api_services_debug
log4j.appender.DEBUG.File=/Users/dddd/Documents/testspace/pms-api-services/logs/debug/api_services_debug

第三步：整合测试

在这里插入图片描述
在控制台上打印输出，测试成功

全局统一处理

为了统一前后端数据格式，所以将前后端之间数据传递格式统一处理起来，返回格式使用map进行存取，这样的话数据包装起来比较简洁，然后再使用枚举统一封装异常，返回成功和失败直接使用静态方法进行封装，主要枚举的异常如下：

  SUCCESS(true, 20000,"成功"),
    UNKNOWN_REASON(false, 20001, "未知错误"),

    BAD_SQL_GRAMMAR(false, 21001, "sql语法错误"),
    JSON_PARSE_ERROR(false, 21002, "json解析异常"),
    PARAM_ERROR(false, 21003, "参数不正确"),

    FILE_UPLOAD_ERROR(false, 21004, "文件上传错误"),
    FILE_DELETE_ERROR(false, 21005, "文件刪除错误"),
    EXCEL_DATA_IMPORT_ERROR(false, 21006, "Excel数据导入错误"),

    VIDEO_UPLOAD_ALIYUN_ERROR(false, 22001, "视频上传至阿里云失败"),
    VIDEO_UPLOAD_TOMCAT_ERROR(false, 22002, "视频上传至业务服务器失败"),
    VIDEO_DELETE_ALIYUN_ERROR(false, 22003, "阿里云视频文件删除失败"),
    FETCH_VIDEO_UPLOADAUTH_ERROR(false, 22004, "获取上传地址和凭证失败"),
    REFRESH_VIDEO_UPLOADAUTH_ERROR(false, 22005, "刷新上传地址和凭证失败"),
    FETCH_PLAYAUTH_ERROR(false, 22006, "获取播放凭证失败"),

    URL_ENCODE_ERROR(false, 23001, "URL编码失败"),
    ILLEGAL_CALLBACK_REQUEST_ERROR(false, 23002, "非法回调请求"),
    FETCH_ACCESSTOKEN_FAILD(false, 23003, "获取accessToken失败"),
    FETCH_USERINFO_ERROR(false, 23004, "获取用户信息失败"),
    LOGIN_ERROR(false, 23005, "登录失败"),

    COMMENT_EMPTY(false, 24006, "评论内容必须填写"),

    PAY_RUN(false, 25000, "支付中"),
    PAY_UNIFIEDORDER_ERROR(false, 25001, "统一下单错误"),
    PAY_ORDERQUERY_ERROR(false, 25002, "查询支付结果错误"),

    ORDER_EXIST_ERROR(false, 25003, "课程已购买"),

    GATEWAY_ERROR(false, 26000, "服务不能访问"),

    CODE_ERROR(false, 28000, "验证码错误"),

    LOGIN_PHONE_ERROR(false, 28009, "手机号码不正确"),
    LOGIN_MOBILE_ERROR(false, 28001, "账号不正确"),
    LOGIN_PASSWORD_ERROR(false, 28008, "密码不正确"),
    LOGIN_DISABLED_ERROR(false, 28002, "该用户已被禁用"),
    REGISTER_MOBLE_ERROR(false, 28003, "手机号已被注册"),
    LOGIN_AUTH(false, 28004, "需要登录"),
    LOGIN_ACL(false, 28005, "没有权限"),
    SMS_SEND_ERROR(false, 28006, "短信发送失败"),
    SMS_SEND_ERROR_BUSINESS_LIMIT_CONTROL(false, 28007, "短信发送过于频繁");

数据封装类：

package com.example.demo.utils;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

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

/**
 * @author helen
 * @since 2019/12/25
 */
@Data
@ApiModel(value = "全局统一返回结果")
public class R {

    @ApiModelProperty(value = "是否成功")
    private Boolean success;

    @ApiModelProperty(value = "返回码")
    private Integer code;

    @ApiModelProperty(value = "返回消息")
    private String message;

    @ApiModelProperty(value = "返回数据")
    private Map<String, Object> data = new HashMap<String, Object>();

    public R(){}

    public static R ok(){
        R r = new R();
        r.setSuccess(ResultCodeEnum.SUCCESS.getSuccess());
        r.setCode(ResultCodeEnum.SUCCESS.getCode());
        r.setMessage(ResultCodeEnum.SUCCESS.getMessage());
        return r;
    }

    public static R error(){
        R r = new R();
        r.setSuccess(ResultCodeEnum.UNKNOWN_REASON.getSuccess());
        r.setCode(ResultCodeEnum.UNKNOWN_REASON.getCode());
        r.setMessage(ResultCodeEnum.UNKNOWN_REASON.getMessage());
        return r;
    }

    public static R setResult(ResultCodeEnum resultCodeEnum){
        R r = new R();
        r.setSuccess(resultCodeEnum.getSuccess());
        r.setCode(resultCodeEnum.getCode());
        r.setMessage(resultCodeEnum.getMessage());
        return r;
    }

    public R success(Boolean success){
        this.setSuccess(success);
        return this;
    }

    public R message(String message){
        this.setMessage(message);
        return this;
    }

    public R code(Integer code){
        this.setCode(code);
        return this;
    }

    public R data(String key, Object value){
        this.data.put(key, value);
        return this;
    }

    public R data(Map<String, Object> map){
        this.setData(map);
        return this;
    }
}

测试

@GetMapping("/test01") public R test02(){ return R.ok().message("成功"); }
在swagger中进行测试测试成功

异常统一处理

传统的异常处理通常使用try catch 代码块，但是这样有一个很大的缺点，代码冗余，因此使用springboot在封装的异常处理类，一旦发生异常就会自动被扑捉到代码块中，首先封装对异常处理的工具类：ExceptionUtils.java

public class ExceptionUtils {

    public static String getMessage(Exception e) {
        StringWriter sw = null;
        PrintWriter pw = null;
        try {
            sw = new StringWriter();
            pw = new PrintWriter(sw);
            // 将出错的栈信息输出到printWriter中
            e.printStackTrace(pw);
            pw.flush();
            sw.flush();
        } finally {
            if (sw != null) {
                try {
                    sw.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
            if (pw != null) {
                pw.close();
            }
        }
        return sw.toString();
    }
}

然后封装异常处理函数，其中分离出两种特殊的异常，如果不是这两种异常，就会会被最大的异常处理函数扑捉，当然也可以往下细分

 @ExceptionHandler(Exception.class)
    @ResponseBody
    public R error(Exception e){
//        e.printStackTrace();
        log.error(ExceptionUtils.getMessage(e));
        return R.error();
    }

    @ExceptionHandler(BadSqlGrammarException.class)
    @ResponseBody
    public R error(BadSqlGrammarException e){
        log.error(ExceptionUtils.getMessage(e));
        return R.setResult(ResultCodeEnum.BAD_SQL_GRAMMAR);
    }

    @ExceptionHandler(HttpMessageNotReadableException.class)
    @ResponseBody
    public R error(HttpMessageNotReadableException e){
        log.error(ExceptionUtils.getMessage(e));
        return R.setResult(ResultCodeEnum.JSON_PARSE_ERROR);
    }

sink zhang

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
从零开始构建前后端分离脚手架(一):基本的环境搭建

概述最近发现自己学的越多忘记的越多，有些东西要总结一下，不然一不用就忘记的更快，今天从零开始以springboot为基础，搭建一个前后端分离的单体应用，算巩固一下基础吧，本文的解决方案不一定是最优方案，后期会慢慢优化以及修改注意：本教程粒度不是太细，针对有一定经验的进行学习，有些基础细节有所忽略，版本问题的话，按照我的版本构建，不会出错主要使用技术项目是前后端分离的，并没有使用vue来构建，使用ajax的一个工具类包装之后，作为前后端之间的通信协调接口，持久层使用mybatis而没有使用mybati
复制链接

扫一扫