springboot整合项目所需的框架和工具

孤独的圆

已于 2022-08-08 15:06:04 修改

阅读量1.6k

点赞数 2

分类专栏：基础配置 springboot 文章标签： java

于 2021-04-27 17:23:06 首次发布

本文链接：https://blog.csdn.net/qq_36649744/article/details/116133421

版权

基础配置同时被 2 个专栏收录

9 篇文章 0 订阅

订阅专栏

springboot

4 篇文章 0 订阅

订阅专栏

本文旨在通过springboot搭建项目，集成一些开发中常用的框架和工具，如有错误或者不足之处，欢迎指出。

文章目录

一、创建springboot项目
二、连接数据库
三、整合mybatis
四、整合mybatisplus
五、整合swagger2
六、整合springmvc
七、整合logback
八、整合redis
九、springboot整合es
测试代码

一、创建springboot项目

1.1、见图，next
在这里插入图片描述
1.2、根据你的需求修改包名和项目名，主要是Java版本号，我这里选择的是Java8，然后next

1.3、直接在该界面选择一些常用的依赖：lombok，spring web，jdbc api，mysql driver

1.4、需要注意一下springboot的版本号,一般最新的springboot整合会有各种各样的问题，所以我们都是使用以前的比较稳定的版本，在这里可以不用管，生成项目之后再去修改，然后next
在这里插入图片描述
1.5、在这个页面可以修改项目名，以及项目的存放位置，需要注意的是，当你修改了项目位置之后，要注意存放地址最后是否是以你的项目名结尾，如果不是，请添加你的项目名在末尾，（不添加项目名的效果可以自行尝试）然后点击finish即可。
在这里插入图片描述
1.6、然后打开pom文件，我们可以看到springboot的版本，直接修改为你需要的版本即可。我这里修改为2.1.4.RELEASE；一个springboot项目就建好了，接下来我们需要集成开发过程中常用的框架和工具，方便我们后续的开发。
在这里插入图片描述

二、连接数据库

2.1、打开项目目录下的resources目录，resources目录下有两个目录：templates和static，这是springboot官方针对thymeleaf 模板引擎而自动生成的目录，然后根据你的喜好选择application.properties还是application.yml配置文件，官方推荐使用yml的配置文件，我这里使用的也是application.yml;
2.2、我们在创建项目的时候已经勾选了jdbc和mysql驱动的依赖：

  <dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-jdbc</artifactId>
  </dependency>
  <dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<scope>runtime</scope>
  </dependency>

在这里我们使用duird连接池，数据库连接池的意义在于，能够重复利用数据库连接，提高对请求的响应时间和服务器的性能。因此还需要导入druid连接池的依赖。

  <!-- alibaba的druid数据库连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.9</version>
        </dependency>

2.3、在application.yml配置文件中添加以下内容：
url: 将3307修改为你的数据库端口号，u2vd修改为你的数据库名称
username: 数据库用户名
password: 数据库密码

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3307/u2vd?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=Asia/Shanghai&useSSL=false
    username: root
    password: Ast4HS
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver

注意：springboot默认采用8.x版本的数据库驱动包，需要在配置文件中配置时区，（如果不配置时区，当你的时间类型的数据入库的时候会有错误哦！），5.x版本是不需要的，所以也可以选择将mysql的驱动的版本号改为5.x版本的

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
    <version>5.1.30</version>
</dependency>

关于druid连接池的配置还有很多，添加某些配置时需要导入log4j的依赖，没有特别的需求的话这部分配置可以不写，如果需要，请自行百度，这里贴出一部分配置供参考（我这里先不配置了）：

#Spring Boot 默认是不注入这些属性的，需要自己绑定
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedtatements: true

    #配置监控统计拦截的filters，stat：监控统计，wall：防御sql注入
    #需要导入log4j的依赖
    filters: stat,wall
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

2.4、在这里可以创建一个DruidConfig的配置类来进行监控（非必须，即不影响我们后续开发）

@Configuration
public class DruidConfig {
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druidDataSource(){
        return new DruidDataSource();
    }
    
    //后台监控
    @Bean
    public ServletRegistrationBean statViewServlet(){
       ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
       //后台需要有人登录，账号密码 设置
        HashMap<String, String> initParameters = new HashMap<>();
        //增加配置
        //此处的key不能更改
        initParameters.put("loginUsername","admin");  
        initParameters.put("loginPassword","123456");
        //允许谁可以访问
        initParameters.put("allow","");
        //禁止谁访问
        initParameters.put("kuangshen","192.168.220.140");
        bean.setInitParameters(initParameters);
        return bean;
    }
}

2.5 、访问http://localhost:8080/druid，登录上面设置的账号密码，可查看相关内容，到这里的话，druid就整合完了。
在这里插入图片描述

三、整合mybatis

3.1、在开始整合mybatis时，先介绍一下lombok，我们在创建项目的时候就引入了lombok的依赖，但要使用它，我们还需要在编译器中安装它的插件：
settings -> plugins -> 在搜索框输入lombok -> 安装
详情可看：SpringBoot 集成Lombok 插件

        <dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>

3.2、导入mybatis的依赖：

 <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
        </dependency>

3.3、在yml文件中添加以下内容：
mapper-locations：xml文件的存放位置

#    整合mybatis
mybatis:
  type-aliases-package: com.lcm.domain.po   
  mapper-locations: classpath:mapper/*.xml

3.4、在resources目录下增加你上述的配置的xml路径，这里即新增mapper的路径，用来存放所有的xml文件。到这里其实mybatis就整合完成了。下面推荐两个插件，这个插件可以快速生成model文件，mapper文件，和xml文件：
free mybatis plugin教程：
下面就是通过free mybatis plugin生成的文件
在这里插入图片描述
mybatis-generator插件

3.5、在启动类加上注解，路径是你的mapper文件夹所在路径，
@MapperScan(basePackages = {“com.lcm.web.mapper”})；
另外也可以在每个mapper文件上添加@mapper注解；
在这里插入图片描述
然后启动项目，启动成功说明整合成功

3.6 分页插件pagehelper
3.6.1 导入依赖

	<!-- 分页插件 -->
		<dependency>
			<groupId>com.github.pagehelper</groupId>
			<artifactId>pagehelper-spring-boot-starter</artifactId>
			<version>1.2.5</version>
		</dependency>

3.6.2 在yml文件中添加以下内容：

# pagehelper
pagehelper:
  helperDialect: mysql
  reasonable: true
  supportMethodsArguments: true
  params: count=countSql

3.6.3 使用示例

 @ApiOperation(value = "pagehelper分页查询Page方式一")
    @GetMapping("/pagehelperQuery")
    //根据isDeptAdmin的值查询用户
    public PageInfo<SysUser> seleltUserPageHeleper() {
        int pageNum = 1 ;
        int pageSize = 2 ;
        int isDeptAdmin = 1;
        PageHelper.startPage(pageNum, pageSize);
        List<SysUser> userList = sysUserMapper.selsctUserHelper(isDeptAdmin);
        return new PageInfo<SysUser>(userList);
    }

    @ApiOperation(value = "pagehelper分页查询Page方式二")
    @GetMapping("/pagehelperQuery2")
    //根据isDeptAdmin的值查询用户
    public Page<SysUser> seleltUserPageHeleper2() {
        int pageNum = 1 ;
        int pageSize = 2 ;
        int isDeptAdmin = 1;
        PageHelper.startPage(pageNum, pageSize);
        Page<SysUser> userList = sysUserMapper.selsctUserHelper2(isDeptAdmin);
        return userList;
    }

3.7、如果查询数据为对象赋值时，有属性被赋值为null，请注意你的xml文件结果集是否有误：
在这里插入图片描述
这里是通过插件自动生成的，将resultType修改为resultMap；

四、整合mybatisplus

4.1、首先给个官网地址，有不懂的可直接查看：mybatisplus官网

4.2、导入依赖：包含一些模板引擎的依赖，有兴趣可以百度

 <!-- mybaties plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.shenjia</groupId>
            <artifactId>MyBatisX</artifactId>
            <version>0.0.5</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-typehandlers-jsr310</artifactId>
            <version>1.0.1</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.1</version>
        </dependency>
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.28</version>
        </dependency>

4.3、在yml文件中添加以下内容：

mybatis-plus:
  mapper-locations: classpath:/mapper/*Mapper.xml
  type-aliases-package: com.qst.domain.po
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

4.4、在启动类加上注解，路径是你的mapper文件夹所在路径，然后启动项目，启动成功说明整合成功
@MapperScan(basePackages = {“com.lcm.web.mapper”})
在这里插入图片描述

4.5 、自动生成代码：我们在上面已经引入了mybatis-plus-generator的依赖，通过这个依赖，我们可以自动生成service、serviceimpl、model、mapper、xml文件；

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.3.1</version>
        </dependency>

4.6、在项目的test目录下新建一个CodeGeneration类，然后添加以下内容，网上有更加详细的教程，可自行百度，右键点击运行即可

package com.lcm.web;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

public class CodeGeneration {

        //main函数
        public static void main(String[] args) {

            AutoGenerator autoGenerator = new AutoGenerator();

            //全局配置
            GlobalConfig gc = new GlobalConfig();
            String oPath = System.getProperty("user.dir");//得到当前项目的路径
            gc.setOutputDir(oPath + "/src/main/java");   //生成文件输出根目录
            gc.setOpen(false);//生成完成后不弹出文件框
            gc.setFileOverride(true);  //文件覆盖
            gc.setActiveRecord(false);// 不需要ActiveRecord特性的请改为false
            gc.setEnableCache(false);// XML 二级缓存
            gc.setBaseResultMap(true);// XML ResultMap
            gc.setBaseColumnList(false);// XML columList
            //gc.setSwagger2(true); //实体属性 Swagger2 注解
            gc.setAuthor("lcm");// 作者

            // 自定义文件命名，注意 %s 会自动填充表实体属性！
            gc.setControllerName("%sController");
            gc.setServiceName("%sService");
            gc.setServiceImplName("%sServiceImpl");
            gc.setMapperName("%sMapper");
            gc.setXmlName("%sMapper");
            autoGenerator.setGlobalConfig(gc);

            // 数据源配置
            DataSourceConfig dsc = new DataSourceConfig();
            dsc.setDbType(DbType.MYSQL);   //设置数据库类型
            dsc.setDriverName("com.mysql.cj.jdbc.Driver");
            dsc.setUsername("root");
            dsc.setPassword("Ast4HS");
            dsc.setUrl("jdbc:mysql://localhost:3307/u2vd?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=Asia/Shanghai&useSSL=false");  //指定数据库
            autoGenerator.setDataSource(dsc);

            // 策略配置
            StrategyConfig strategy = new StrategyConfig();
            strategy.setNaming(NamingStrategy.underline_to_camel);      // 表名生成策略
            strategy.setColumnNaming(NamingStrategy.underline_to_camel);
            strategy.setInclude("sys_user");     // 需要生成的表
            strategy.setEntityLombokModel(true);   //使用lombok
            autoGenerator.setStrategy(strategy);

            // 包配置
            PackageConfig pc = new PackageConfig();
            pc.setParent("com.lcm.web");
            pc.setController("controller");
            pc.setService("service");
            pc.setServiceImpl("service.impl");
            pc.setMapper("mapper");
            pc.setEntity("domain.po");
            pc.setXml("mapper");
            autoGenerator.setPackageInfo(pc);

            // 执行生成
            autoGenerator.execute();
        }
    }

4.7 、上述代码生成的文件截图如下：
在这里插入图片描述
4.8、mybatisplus有一些注解，这些注解的意义可以查看官网，一般来说，通过上面自动生成代码之后，我们只要关注实际的业务需求即可。这里给一个Mybatis-Plus官网CRUD接口的教程供大家学习：CRUD接口

4.9 mybatisplus分页插件：MybatisPlusConfig，配置完成后即可使用
官网分页插件教程

package com.example.conf;

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 配置分页插件
 *
 */
@Configuration
public class MybatisPlusConfig {

    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

五、整合swagger2

5.1、这里先给一篇我之前写过的整合的教程：整合swagger2，讲的比较详细，本章整合就只是简单说明一下。

5.2、导入依赖：

    <dependency>
	    <groupId>com.spring4all</groupId>
		<artifactId>swagger-spring-boot-starter</artifactId>
		<version>1.8.0.RELEASE</version>
	</dependency>
	<dependency>
		<groupId>com.google.guava</groupId>
		<artifactId>guava</artifactId>
		<version>26.0-jre</version>
    </dependency>

5.3 、新建一个类，存放Swagger2的配置文件

package com.lcm.web.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration      // 这是控制开关
@EnableSwagger2     // 这是用了 swagger2
public class Swagger2Config {
    
    @Bean
    public Docket customDocket() {
        return new Docket(DocumentationType.SWAGGER_2)
                .select()            //select()函数返回一个ApiSelectorBuilder实例用来控制哪些接口暴露给Swagger来展现
                .apis(RequestHandlerSelectors.basePackage("com.lcm.web.controller")) //扫描指定包内所有Controller定义的Api，并产生文档内容（除了被@ApiIgnore指定的请求）。
                .paths(PathSelectors.any())
                .build()
                .apiInfo(apiInfo()); //用来创建该Api的基本信息（这些基本信息会展现在文档页面中）
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder().title("测试项目").description("接口文档").version("1.0").build();
    }

}

5.4、在yml配置文件中添加以下内容，用来控制swagger的开启和关闭,如果不配置，默认开启

swagger:
  enabled: true

5.5 完成上述操作之后，启动程序，访问 http://localhost:8080/swagger-ui.html# 即可；

六、整合springmvc

6.1 、整合springmvc很简单，导入web依赖即可，我们在创建项目的时候就已经引入了：

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

6.2、引入thymeleaf模板引擎的依赖：这个其实是不用配置的，因为现在很多项目都是前后端分离，前端一般是用vue来实现的；但对于一般的web项目可进行添加以便学习（我这里就不配置了，写出来仅供参考）

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

如果你添加了thymeleaf的依赖，可以在yml文件里添加以下内容，默认配置，也可以不添加

spring:
  thymeleaf:
    prefix: classpath:/templates/pages/
    suffix: .html

6.3 、关于springmvc的作用，请自行学习，在springboot中整合springmvc最重要的一个作用是我们可以通过WebMvcConfigurer接口针对框架进行个性化定制，其中最常用到的是自定义拦截器，而自定义拦截器最重要的是HandlerInterceptorAdapter适配器：下面贴两个链接供大家参考：
6.3.1 WebMvcConfigurer详解
6.3.2 SpringBoot之HandlerInterceptorAdapter

6.4、查看一下HandlerInterceptorAdapter的源码,一般我们只需要实现preHandle、postHandle、afterCompletion三个方法中的两个：
preHandle：在方法被调用前执行。在该方法中可以做类似校验的功能。如果返回true，则继续调用下一个拦截器。如果返回false，则中断执行，也就是说我们想调用的方法不会被执行，但是你可以修改response为你想要的响应。
postHandle：在方法执行后调用。
afterCompletion：在整个请求处理完毕后进行回调，也就是说视图渲染完毕或者调用方已经拿到响应

package org.springframework.web.servlet.handler;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.lang.Nullable;
import org.springframework.web.servlet.AsyncHandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

public abstract class HandlerInterceptorAdapter implements AsyncHandlerInterceptor {

	/**
	 * This implementation always returns {@code true}.
	 */
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return true;
	}

	/**
	 * This implementation is empty.
	 */
	@Override
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable ModelAndView modelAndView) throws Exception {
	}

	/**
	 * This implementation is empty.
	 */
	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable Exception ex) throws Exception {
	}

	/**
	 * This implementation is empty.
	 */
	@Override
	public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response,
			Object handler) throws Exception {
	}
}

6.5、自定义拦截器：新建一个package命名为：interceptor，新建一个UserAuthInterceptor 继承HandlerInterceptorAdapter，下面就可以根据你的需求在对应的方法中写校验的逻辑；

package com.lcm.web.interceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;


@Component
public class UserAuthInterceptor extends HandlerInterceptorAdapter {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        //处理用户认证的逻辑
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                                Object handler, Exception ex) throws Exception {

    }
}

6.6、新建一个WebConfig实现WebMvcConfigurer接口，添加以下内容:(即除了/api/login接口外，其他接口都要经过拦截器的处理)
addInterceptor：需要一个实现HandlerInterceptor接口的拦截器实例
addPathPatterns：用于设置拦截器的过滤路径规则；addPathPatterns(“/**”)对所有请求都拦截
excludePathPatterns：用于设置不需要拦截的过滤规则
拦截器主要用途：进行用户登录状态的拦截，日志的拦截等。

package com.lcm.web.config;


import com.lcm.web.interceptor.UserAuthInterceptor;
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;



@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    UserAuthInterceptor userAuthInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(userAuthInterceptor).addPathPatterns("/**").excludePathPatterns("/api/login");
    }
}

七、整合logback

7.1、基本介绍
默认情况下，Spring Boot会用logback来记录日志，并用INFO级别输出到控制台。新建springboot项目时，会自动导入以下依赖：

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.1.4.RELEASE</version>
	<relativePath/> <!-- lookup parent from repository -->
</parent>

通过点击spring-boot-starter-parent我们可以看到里面已经包含了logback的依赖，因此不再需要加入依赖。以下文章供参考：springboot2.0整合logback日志(详细)
但是如果你新建项目的时候没有添加web依赖的话，建议导入web依赖，方便我们启动项目查看配置日志的效果

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

7.2、logback配置文件
Spring Boot官方推荐优先使用带有-spring的文件名作为你的日志配置（如使用logback-spring.xml，而不是logback.xml），命名为logback-spring.xml的日志配置文件，将xml放至 src/main/resource下面。
也可以使用自定义的名称，比如logback-boot.xml，只需要在application.yml文件中指定即可。

#日志配置
logging:
  config: classpath:logback-boot.xml

7.3、本文创建名称为logback-boot.xml的配置文件。在yml文件中添加上述配置，然后在logback-boot.xml文件中添加以下内容：

<?xml version="1.0" encoding="UTF-8"?>
<!-- scan配置文件如果发生改变，将会被重新加载 ,60s刷新一次-->
<configuration debug="false" scan="false" scanPeriod="60 seconds">
    <springProperty scope="context" name="springAppName" source="spring.application.name"/>
    <!-- <property name="springAppName" value="1000video" /> -->
    <contextName>${springAppName}</contextName>
    <property name="log.path" value="${user.dir}/logs" />
    <!-- Console log output -->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%date [%contextName] %-5level [%logger{60}] Line:%-3L - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- Log file error output -->
    <appender name="error" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter" onMatch="ACCEPT">
            <level>ERROR</level>
        </filter>
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/${springAppName}_error.log</file>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 归档的日志文件的路径， 而2013-12-21的日志文件在由fileNamePattern指定。%d{yyyy-MM-dd}指定日期格式，%i指定索引 -->
            <fileNamePattern>${log.path}/${springAppName}_error.log-%d{yyyy-MM-dd}-%i.log</fileNamePattern>
            <!-- 除按日志记录之外，还配置了日志文件不能超过2M，若超过2M，日志文件会以索引0开始， 命名日志文件，例如log-error-2013-12-21-0.log -->
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>500MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!-- 日志文件保留天数 -->
            <MaxHistory>5</MaxHistory>
            <!-- 日志文件达到1GB之后自动清除旧的日志-->
            <totalSizeCap>1GB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>%date [%contextName] %-5level [%logger{60}] Line:%-3L - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- Log file info output -->
    <appender name="info" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter" onMatch="DENY">
            <level>INFO</level>
        </filter>
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/${springAppName}_info.log</file>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 归档的日志文件的路径， 而2013-12-21的日志文件在由fileNamePattern指定。%d{yyyy-MM-dd}指定日期格式，%i指定索引 -->
            <fileNamePattern>${log.path}/${springAppName}_info.log-%d{yyyy-MM-dd}-%i.log</fileNamePattern>
            <!-- 除按日志记录之外，还配置了日志文件不能超过2M，若超过2M，日志文件会以索引0开始， 命名日志文件，例如log-error-2013-12-21-0.log -->
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>500MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!-- 日志文件保留天数 -->
            <MaxHistory>5</MaxHistory>
            <!-- 日志文件达到1GB之后自动清除旧的日志-->
            <totalSizeCap>1GB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>%date [%contextName] %-5level [%logger{60}] Line:%-3L - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- Log file debug output -->
    <appender name="debug" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter" onMatch="DENY">
            <level>DEBUG</level>
        </filter>
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/${springAppName}_debug.log</file>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 归档的日志文件的路径， 而2013-12-21的日志文件在由fileNamePattern指定。%d{yyyy-MM-dd}指定日期格式，%i指定索引 -->
            <fileNamePattern>${log.path}/${springAppName}_debug.log-%d{yyyy-MM-dd}-%i.log</fileNamePattern>
            <!-- 除按日志记录之外，还配置了日志文件不能超过2M，若超过2M，日志文件会以索引0开始， 命名日志文件，例如log-error-2013-12-21-0.log -->
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>500MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!-- 日志文件保留天数 -->
            <MaxHistory>5</MaxHistory>
            <!-- 日志文件达到1GB之后自动清除旧的日志-->
            <totalSizeCap>1GB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>%date [%contextName] %-5level [%logger{60}] Line:%-3L - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- Level: FATAL 0 ERROR 3 WARN 4 INFO 6 DEBUG 7 -->
    <root level="INFO">
        <appender-ref ref="console" />
        <appender-ref ref="info" />
        <appender-ref ref="error" />
        <!--<appender-ref ref="debug" />-->
    </root>
</configuration>

7.4、关于上述配置文件内容，主要注意三个地方，其他配置内容一般无需更改，如有需要，可根据自己的需求修改：
7.4.1、第四行代码：

<springProperty scope="context" name="springAppName" source="spring.application.name"/>

这里的source会去读取配置文件中的项目名称，如果你没有配置，则生成的日志文件的命名就会是这样的：
在这里插入图片描述
所以我们需要在yml文件中配置以下内容：

spring:
  application:
    name: demo

添加配置之后生成的日志文件命名就是这样的：
在这里插入图片描述
7.4.2、第七行代码中的value属性值即为log文件的存储位置。

<property name="log.path" value="${user.dir}/logs" />

当value设置为 ${user.dir}/logs时，即表示在当前项目下的logs目录下生成log文件，如果logs目录不存在，会自动生成，所以此处可根据你的日志文件的存放位置进行修改
7.4.3、倒数的那几行意思是：root节点将日志级别大于等于info的交给已经配置好的名为"console、info、error、debug"的
< appender >进行处理，将信息打印到控制台上。

 <!-- Level: FATAL 0 ERROR 3 WARN 4 INFO 6 DEBUG 7 -->
    <root level="INFO">
        <appender-ref ref="console" />
        <appender-ref ref="info" />
        <appender-ref ref="error" />
        <!--<appender-ref ref="debug" />-->
    </root>

日志级别从低到高分为：TRACE < DEBUG <INFO <WARN < ERROR <FATAL 。
如果设置为 WARN ，则低于 WARN 的信息都不会输出。
Spring Boot中默认配置ERROR、WARN和INFO级别的日志输出到控制台。

//设置为INFO，即表示低于INFO的信息都不会输出,不区分大小写
 <root level="INFO">
     //设置了控制台输出的日志信息格式，注释后控制台将不会打印任何日志信息
     <appender-ref ref="console" />
      //设置了info日志信息格式
     <appender-ref ref="info" />
     //设置了error日志信息格式
     <appender-ref ref="error" />
     //设置了debug日志信息格式
     <!--<appender-ref ref="debug" />-->
 </root>

当我们把< appender-ref >相应的节点注释掉，则该级别的日志内容就不会输出。

7.5 、在开发中使用：
7.5.1、在类头上使用@slf4j注解，需要添加lombok插件，如果还没添加，可查看整合mybatis部分的内容；
在这里插入图片描述
7.5.2、手动创建Logger对象：

private final static Logger log = LoggerFactory.getLogger(TestController.class);

getLogger()中传入的类对象就是需要使用日志的类，比如我当前这个TestController类想要使用日志功能，就在构建的时候传入该类。
在这里插入图片描述

7.6、附几个链接供学习：
springboot使用logback日志框架超详细教程
 Spring Boot 日志配置(超详细)
Java日志框架：logback详解
 springboot使用logback日志框架超详细教程
 logback 配置详解（一）——logger、root

八、整合redis

8.1、加入依赖：
spring-boot-starter-data-redis与spring-boot-starter-redis的区别
如果你的spring boot的版本号是1.4.0 到1.5.0 之间，添加redis的jar包的时候添加成 spring-boot-starter-data-redis 和 spring-boot-starter-redis 是都可以的，如果你的spring boot的版本号是1.4.0 以前也就是1.3.8 版本以前，添加redis 的 jar包就必须是 spring-boot-starter-redis 的jar包。如果你的spring boot的版本号是2.x以上的，添加redis 的 jar包就必须是spring-boot-starter-data-redis；

<!-- 操作Redis 只需引入spring-boot-starter-data-redis -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
	<groupId>org.apache.commons</groupId>
	<artifactId>commons-pool2</artifactId>
</dependency>
<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
	<version>2.9.0</version>
</dependency>
<!--JSON数据格式转化-fastjson -->
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>fastjson</artifactId>
	<version>1.2.59</version>
</dependency>
<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-databind</artifactId>
</dependency>
     <!--通过redis实现session共享所需依赖-->
<dependency>
	<groupId>org.springframework.session</groupId>
	<artifactId>spring-session-data-redis</artifactId>
</dependency>

8.2、在yml文件中添加以下内容：

spring:
  redis:
    host: ${REDIS_IP:localhost}
    port: ${REDIS_PORT:6379}
    password: Ast4HS
    timeout: 6000
    jedis:
      pool:
        #连接池最大连接数（使用负值表示没有限制）
        max-active: 1000
        #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1
        #连接池中的最大空闲连接
        max-idle: 1000
        #连接池中的最小空闲连接
        min-idle: 0
    database:
     #在redis配置文件中进行配置，根据注入的bean选择不同的数据库
      base: 0
      camera: 1
  cache:
    type: redis

8.3、创建一个RedisConfig类，添加以下内容：

package com.lcm.web.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

import java.time.Duration;

@Configuration
@EnableAutoConfiguration
public class RedisConfig {

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.timeout}")
    private int timeout;

    @Value("${spring.redis.jedis.pool.max-active}")
    private int maxActive;

    @Value("${spring.redis.jedis.pool.max-wait}")
    private int maxWait;

    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.jedis.pool.min-idle}")
    private int minIdle;

    @Value("${spring.redis.database.base:0}")
    private int baseDatabase;

    @Value("${spring.redis.database.camera:1}")
    private int cameraDatabase;

    @Value("${spring.redis.database.home:2}")
    private int homeDatabase;

    @Value("${spring.redis.database.login:3}")
    private int loginDatabase;

    private JedisPoolConfig getJedisPoolConfig() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMinIdle(minIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWait);
        return jedisPoolConfig;
    }

    private RedisConnectionFactory getConnectionFactory(int database) {
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setHostName(host);
        redisStandaloneConfiguration.setPort(port);
        redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
        redisStandaloneConfiguration.setDatabase(database);
        JedisClientConfiguration.JedisClientConfigurationBuilder jedisClientConfiguration =
            JedisClientConfiguration.builder();
        jedisClientConfiguration.connectTimeout(Duration.ofMillis(timeout));
        jedisClientConfiguration.usePooling().poolConfig(getJedisPoolConfig());
        return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration.build());
    }

    /**
     * 获取redisTemplate
     */
    @SuppressWarnings("all")
    private RedisTemplate<String, Object> getRedisTemplate(int database) {
        // 设置序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        RedisTemplate<String, Object> temple = new RedisTemplate<String, Object>();
        temple.setConnectionFactory(this.getConnectionFactory(database));
        RedisSerializer stringSerializer = new StringRedisSerializer();
        temple.setKeySerializer(stringSerializer);// key序列化
        temple.setValueSerializer(jackson2JsonRedisSerializer);// value序列化
        temple.setHashKeySerializer(stringSerializer);// Hash key序列化
        temple.setHashValueSerializer(jackson2JsonRedisSerializer);// Hash value序列化
        return temple;
    }

    @Bean(name = "redisTemplate")
    public RedisTemplate<String, Object> redisTemplate() {
        return getRedisTemplate(baseDatabase);
    }

    @Bean(name = "cameraRedisTemplate")
    public RedisTemplate<String, Object> getCameraRedisTemplate() {
        return getRedisTemplate(cameraDatabase);
    }

    @Bean(name = "homeRedisTemplate")
    public RedisTemplate<String, Object> getHomeRedisTemplate() {
        return getRedisTemplate(homeDatabase);
    }

    @Bean(name = "loginRedisTemplate")
    public RedisTemplate<String, Object> getLoginRedisTemplate() {
        return getRedisTemplate(loginDatabase);
    }
}

如果不添加该配置类，那我们存入redis中的数据将会出现乱码
未创建RedisConfig时存入redis的数据
在这里插入图片描述
创建RedisConfig时存入redis的数据

8.4、对于配置文件中的该部分代码进行说明一下：通过 @Value(“${spring.redis.database.base:0}”)为属性赋值，@Value会去读取yml文件中的spring.redis.database.base的值，如果没有配置则为0，通过@Bean(name = “redisTemplate”)来注入这个属性值；

    @Value("${spring.redis.database.base:0}")
    private int baseDatabase;

    @Value("${spring.redis.database.camera:1}")
    private int cameraDatabase;

    @Value("${spring.redis.database.home:2}")
    private int homeDatabase;

    @Value("${spring.redis.database.login:3}")
    private int loginDatabase;
   
   @Bean(name = "redisTemplate")
   public RedisTemplate<String, Object> redisTemplate() {
       return getRedisTemplate(baseDatabase);
   }

   @Bean(name = "cameraRedisTemplate")
   public RedisTemplate<String, Object> getCameraRedisTemplate() {
       return getRedisTemplate(cameraDatabase);
   }

   @Bean(name = "homeRedisTemplate")
   public RedisTemplate<String, Object> getHomeRedisTemplate() {
       return getRedisTemplate(homeDatabase);
   }

   @Bean(name = "loginRedisTemplate")
   public RedisTemplate<String, Object> getLoginRedisTemplate() {
       return getRedisTemplate(loginDatabase);
   }

我们在使用的时候只要通过@Autowired自动装配方式，从IoC容器中去查找到，并返回给该属性，就可以对对应的数据库进行操作。

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private RedisTemplate cameraRedisTemplate;

8.5、为了更方便的操作redis，我们还可以创建一个RedisUtil类，添加以下内容：

package com.lcm.web.utils;

import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;

@Service
public class RedisUtils {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存设置时效时间
     *
     * @param key
     * @param value
     * @return
     *  数据插入缓存（set中的参数含义：key值，user对象，缓存存在时间10（long类型），时间单位）
     */
    public boolean set(final String key, Object value, Long expireTime, TimeUnit timeUnit) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, timeUnit);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量删除key
     *
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0) {
            redisTemplate.delete(keys);
        }
    }

    /**
     * 删除对应的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 哈希 添加
     *
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }

    /**
     * 哈希获取数据
     *
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    /**
     * 列表添加
     *
     * @param k
     * @param v
     */
    public void lPush(String k, Object v) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }

    /**
     * 列表获取
     *
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }

    /**
     * 集合添加
     *
     * @param key
     * @param value
     */
    public void add(String key, Object value) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key, value);
    }

    /**
     * 集合获取
     *
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     * 有序集合获取
     *
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }
}

该工具类仅仅引入了redisTemplate，调用该工具类的话数据会操作0数据库中的数据，在实际的开发过程中，可根据你的需求对工具类进行修改。

@Autowired
    private RedisTemplate redisTemplate;

8.6 、实现session共享请参考：
8.7、供参考：SpringBoot集成redis

九、springboot整合es

参考文档

测试代码

1、 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">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.4.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.lcm</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>demo</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<!-- mybatis -->
<!--		<dependency>-->
<!--			<groupId>org.mybatis.spring.boot</groupId>-->
<!--			<artifactId>mybatis-spring-boot-starter</artifactId>-->
<!--			<version>2.0.1</version>-->
<!--		</dependency>-->
<!--		 分页插件 -->
<!--		<dependency>-->
<!--			<groupId>com.github.pagehelper</groupId>-->
<!--			<artifactId>pagehelper-spring-boot-starter</artifactId>-->
<!--			<version>1.2.5</version>-->
<!--		</dependency>-->
		<!-- mybaties plus -->
		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-boot-starter</artifactId>
			<version>3.3.1</version>
		</dependency>
		<dependency>
			<groupId>org.shenjia</groupId>
			<artifactId>MyBatisX</artifactId>
			<version>0.0.5</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-typehandlers-jsr310</artifactId>
			<version>1.0.1</version>
		</dependency>
		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-generator</artifactId>
			<version>3.3.1</version>
		</dependency>
		<dependency>
			<groupId>org.apache.velocity</groupId>
			<artifactId>velocity-engine-core</artifactId>
			<version>2.1</version>
		</dependency>
		<dependency>
			<groupId>org.freemarker</groupId>
			<artifactId>freemarker</artifactId>
			<version>2.3.28</version>
		</dependency>
        <!--		jdbc-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</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-thymeleaf</artifactId>
		</dependency>
		<!-- druid连接池-->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid-spring-boot-starter</artifactId>
			<version>1.1.9</version>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<!-- swagger -->
		<dependency>
			<groupId>com.spring4all</groupId>
			<artifactId>swagger-spring-boot-starter</artifactId>
			<version>1.8.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>com.google.guava</groupId>
			<artifactId>guava</artifactId>
			<version>26.0-jre</version>
		</dependency>
		<!-- 操作Redis 只需引入spring-boot-starter-data-redis -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.9.0</version>
		</dependency>
		<!--JSON数据格式转化-fastjson -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.59</version>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-pool2</artifactId>
		</dependency>
       <!--通过redis实现session共享所需依赖-->
		<dependency>
			<groupId>org.springframework.session</groupId>
			<artifactId>spring-session-data-redis</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>
				<configuration>
					<excludes>
						<exclude>
							<groupId>org.projectlombok</groupId>
							<artifactId>lombok</artifactId>
						</exclude>
					</excludes>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

2、 yml文件

server:
  port: 8080
spring:
  application:
    name: demo
  datasource:
    url: jdbc:mysql://localhost:3307/u2vd?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=Asia/Shanghai&useSSL=false
    username: root
    password: Ast4HS
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
  thymeleaf:
    prefix: classpath:/templates/pages/
    suffix: .html
  redis:
    host: ${REDIS_IP:localhost}
    port: ${REDIS_PORT:6379}
    password: Ast4HS
    timeout: 6000
    jedis:
      pool:
        #连接池最大连接数（使用负值表示没有限制
        max-active: 1000
        #连接池最大阻塞等待时间（使用负值表示没有限制
        max-wait: -1
        #连接池中的最大空闲连接
        max-idle: 1000
        #连接池中的最小空闲连接
        min-idle: 0
    database:
      base: 0
      camera: 1
  cache:
    type: redis
#    整合mybatis
#mybatis:
#  type-aliases-package: com.lcm.domain.po
#  mapper-locations: classpath:mapper/*.xml
# pagehelper配置文件
#pagehelper:
#  helperDialect: mysql
#  reasonable: true
#  supportMethodsArguments: true
#  params: count=countSql
swagger:
  enabled: true
#日志配置
logging:
  config: classpath:logback-boot.xml
mybatis-plus:
  mapper-locations: classpath:/mapper/*Mapper.xml
  type-aliases-package: com.lcm.domain.po
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

3、测试demo：mybatis的相关依赖、yml配置和测试代码已注释
百度网盘链接：https://pan.baidu.com/s/1HWPjRmACdAsZ8B9lMO1ZMg
提取码：ut1j

孤独的圆

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
springboot整合项目所需的框架和工具

本文旨在通过springboot搭建项目，集成一些开发中常用的框架和工具，不涉及太多的业务代码文章目录一、创建springboot项目二、连接数据库三、整合mybatis四、整合mybatisplus五、整合swagger2六、整合springmvc七、整合logback一、创建springboot项目1.1、见图，next1.2、根据你的需求修改包名和项目名，主要是Java版本号，我这里选择的是Java8，然后next1.3、直接在该界面选择一些常用的依赖：lombok，spri
复制链接

扫一扫

专栏目录