本文旨在通过springboot搭建项目,集成一些开发中常用的框架和工具,如有错误或者不足之处,欢迎指出。
文章目录
一、创建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