springboot+mybatis-plus简单demo搭建

一直用的jpa，突然发现mybaits也挺有意思的，搭了个简单的demo，欢迎大家指点。

目录结构

pom.xml文件

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>mylove</groupId>
    <artifactId>mylove</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-parent -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.12.RELEASE</version>
    </parent>

<!--    <properties>-->
<!--        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>-->
<!--        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>-->
<!--        <java.version>1.8</java.version>-->
<!--        <log4j.version>1.3.8.RELEASE</log4j.version>-->
<!--        <druid.version>1.0.26</druid.version>-->
<!--        <mybatis-plus.version>2.1.9</mybatis-plus.version>-->
<!--        <mybatisplus-spring-boot-starter.version>1.0.5</mybatisplus-spring-boot-starter.version>-->
<!--    </properties>-->

    <dependencies>
        <!--导入jdbc依赖的包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!--导入Springboot依赖的包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--导入mysql 依赖的包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!--添加swagger2依赖的jar包-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>

        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>

        <!--添加lombok依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>

        <!--导入mybatisPlus ，Springboot整合mybatisplus依赖的包-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatisplus-spring-boot-starter</artifactId>
            <version>1.0.5</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>2.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.github.jsqlparser</groupId>
            <artifactId>jsqlparser</artifactId>
            <version>2.1</version>
            <scope>compile</scope>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

yml文件配置

server:
  port: 8888
  max-http-header-size: 8192
spring:
  datasource:
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/demo?characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&useSSL=false&autoReconnect=true
    username: root
    password: root
mybatis-plus:
  # 如果是放在src/main/java目录下 classpath:/com/yourpackage/*/mapper/*Mapper.xml
  # 如果是放在resource目录 classpath:/mapper/*Mapper.xml
  mapper-locations: classpath:mybatis/mappers/*Mapper.xml
  #实体扫描，多个package用逗号或者分号分隔
  typeAliasesPackage: com.lanchenx.loveyuan.entity
  global-config:
    #主键类型  0:"数据库ID自增", 1:"用户输入ID",2:"全局唯一ID (数字类型唯一ID)", 3:"全局唯一ID UUID";
    id-type: 0
    #字段策略 0:"忽略判断",1:"非 NULL 判断"),2:"非空判断"
    field-strategy: 1
    #驼峰下划线转换
    #db-column-underline: true
    #刷新mapper 调试神器
    refresh-mapper: true
    #数据库大写下划线转换
    capital-mode: true
    #Sequence序列接口实现类配置
    #key-generator: com.baomidou.mybatisplus.incrementer.OracleKeyGenerator
    #逻辑删除配置（下面3个配置）
    #logic-delete-value: 1
    #logic-not-delete-value: 0
    #sql-injector: com.baomidou.mybatisplus.mapper.LogicSqlInjector
    #自定义填充策略接口实现
    #meta-object-handler: com.baomidou.springboot.MyMetaObjectHandler
  configuration:
    map-underscore-to-camel-case: true
    cache-enabled: false
    #配置JdbcTypeForNull
    jdbc-type-for-null: 'null'

logging.level.com.demo.mapper: debug

阿里连接池配置

#--------------------------
# 下面为连接池的补充设置，应用到上面所有数据源中
# 初始化大小，最小，最大
spring.datasource.initialSize=5
spring.datasource.minIdle=1
spring.datasource.maxActive=50
# 配置获取连接等待超时的时间
spring.datasource.maxWait=60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.timeBetweenEvictionRunsMillis=60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
spring.datasource.minEvictableIdleTimeMillis=300000
spring.datasource.validationQuery=SELECT 1 FROM DUAL
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
# 打开PSCache，并且指定每个连接上PSCache的大小
spring.datasource.poolPreparedStatements=false
#spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
spring.datasource.filters=stat,wall,log4j
# 通过connectProperties属性来打开mergeSql功能；慢SQL记录
spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
# 合并多个DruidDataSource的监控数据
#spring.datasource.useGlobalDataSourceStat=true

启动类

@SpringBootApplication
@EnableScheduling
@EnableAsync
@MapperScan("com.lanjchenx.loveyuan.mapper")
public class LoveyuanApplication {

    public static void main(String[] args) {
        SpringApplication.run(LoveyuanApplication.class,args);
//        new SpringApplicationBuilder(LoveyuanApplication.class)
//                .web(WebApplicationType.SERVLET)
//                .run(args);
    }
}

user表

注意：@TableName(value = “user”) 注解要加上，否则mapper里的查询可以使用，UserServiceImpl继承的ServiceImpl<UserDao, User>的封装查询失败

import com.baomidou.mybatisplus.annotations.TableName;

import java.io.Serializable;

/**
 * 用户表
 *
 * @since 2020-07-15
 */
@TableName(value = "user")
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 用户ID
     */
    private Long id;
    /**
     * 用户名
     */
    private String name;


    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                ", id=" + id +
                ", name=" + name +
                "}";
    }
}

三个配置类

swagger :

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.ParameterBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.schema.ModelRef;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Parameter;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

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

/**
 * @author chenx 2019-04-18 19:36
 */
@Configuration
@EnableSwagger2
public class SwaggerConfig {
    /**
     * 创建API应用
     * apiInfo() 增加API相关信息
     * 通过select()函数返回一个ApiSelectorBuilder实例,用来控制哪些接口暴露给Swagger来展现，
     * 本例采用指定扫描的包路径来定义指定要建立API的目录。
     *
     * @return
     */
    @Bean
    public Docket api() {
        List<Parameter> aParameters = new ArrayList<>();
        ParameterBuilder parameterBuilder = new ParameterBuilder();
        aParameters.add(parameterBuilder.parameterType("header")
                .name("DeviceID")
                .description("deviceId")
                .modelRef(new ModelRef("string"))
                .required(true)
                .build()
        );
        aParameters.add(parameterBuilder.parameterType("header")
                .name("Gs-Authorization-Token")
                .description("JWTTOKEN")
                .modelRef(new ModelRef("string"))
                .required(false)
                .build());
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("api")
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.regex("/api/v.*"))
                .build()
                .apiInfo(apiInfo())
                .globalOperationParameters(aParameters);
    }

    @Bean
    public Docket restApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("rest")
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.regex("/rest/api/.*"))
                .build()
                .apiInfo(apiInfo());
    }

    @Bean
    public Docket adminApi() {
        List<Parameter> aParameters = new ArrayList<>();
        ParameterBuilder parameterBuilder = new ParameterBuilder();
        aParameters.add(parameterBuilder.parameterType("header")
                .name("Gs-Authorization-Token")
                .description("JWTTOKEN")
                .modelRef(new ModelRef("string"))
                .required(false)
                .build());
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("admin")
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.regex("/admin/.*"))
                .build()
                .apiInfo(apiInfo()).globalOperationParameters(aParameters);
    }

    /**
     * 创建该API的基本信息（这些基本信息会展现在文档页面中）
     * 访问地址：http://项目实际地址/swagger-ui.html
     *
     * @return
     */
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("Spring Boot中使用Swagger2构建RESTful APIs")
                .description("My__Swagger")
                .termsOfServiceUrl("192.168.100.44:8089")
                .version("1.0")
                .build();
    }

}

DruidConfiguration:

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;

/**
 * @author chenxiaobo 2020-07-15 14:00
 */
@Configuration
@PropertySource(value = "classpath:druid.properties")
public class DruidConfiguration {

//    @Bean(destroyMethod = "close", initMethod = "init")
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource druidDataSource() {
        return new DruidDataSource();
    }

//
//  /**
//   * 注册一个StatViewServlet
//   *
//   * @return
//   */
//  @Bean
//  public ServletRegistrationBean druidStatViewServlet() {
//      //org.springframework.boot.context.embedded.ServletRegistrationBean提供类的进行注册.
//      ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
//
//      //添加初始化参数：initParams
//      //白名单：
//      servletRegistrationBean.addInitParameter("allow", "127.0.0.1");
//      //IP黑名单 (存在共同时，deny优先于allow) : 如果满足deny的话提示:Sorry, you are not permitted to view this page.
        servletRegistrationBean.addInitParameter("deny", "192.168.1.73");
//      //登录查看信息的账号密码.
//      servletRegistrationBean.addInitParameter("loginUsername", "admin");
//      servletRegistrationBean.addInitParameter("loginPassword", "123456");
//      //是否能够重置数据.
//      servletRegistrationBean.addInitParameter("resetEnable", "false");
//      return servletRegistrationBean;
//  }
//
//  /**
//   * 注册一个：filterRegistrationBean
//   *
//   * @return
//   */
//  @Bean
//  public FilterRegistrationBean druidStatFilter() {
//
//      FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
//
//      //添加过滤规则.
//      filterRegistrationBean.addUrlPatterns("/*");
//
//      //添加不需要忽略的格式信息.
//      filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
//      return filterRegistrationBean;
//  }
}

MybatisConfiguration:

import com.baomidou.mybatisplus.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * @author chenxiaobo 2020-07-15 14:02
 */
@Configuration
@MapperScan("com.lanjchenx.loveyuan.mapper*")
public class MybatisConfiguration {

    /*
     * 分页插件，自动识别数据库类型
     * 多租户，请参考官网【插件扩展】
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }

   /*
    * oracle数据库配置JdbcTypeForNull
    * 参考：https://gitee.com/baomidou/mybatisplus-boot-starter/issues/IHS8X
    不需要这样配置了，参考 yml:
    mybatis-plus:
      confuguration
        dbc-type-for-null: 'null'
   @Bean
   public ConfigurationCustomizer configurationCustomizer(){
       return new MybatisPlusCustomizers();
   }

   class MybatisPlusCustomizers implements ConfigurationCustomizer {

       @Override
       public void customize(org.apache.ibatis.session.Configuration configuration) {
           configuration.setJdbcTypeForNull(JdbcType.NULL);
       }
   }
   */
}

Controller

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.lanjchenx.loveyuan.entity.User;
import com.lanjchenx.loveyuan.service.UserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.List;

/**
 * 用户表 前端控制器
 *
 * @since 2020-07-15
 */
@Api(value = "UserController", tags = "订单管理")
@RestController
@RequestMapping(value = "api/v1/user")
public class UserController {

    @Resource
    private UserService userService;

    @ApiOperation(value = "获取用户详情")
    @GetMapping(value = "/getUserInfo")
    public User getUser() {
        return userService.selectById(1);
//        return userService.selectUser(1);
    }

    @ApiOperation(value = "获取用户列表")
    @GetMapping(value = "/getUserList")
    public List<User> getUserList() {
        List<User> list = userService.selectList(new EntityWrapper(new User()));
        return list;
//        return userService.selectUser(1);
    }

}

UserService 和 UserServiceImpl

import com.lanjchenx.loveyuan.entity.User;
import com.baomidou.mybatisplus.service.IService;

/**
 * 用户表 服务类
 * @since 2020-07-15
 */
public interface UserService extends IService<User> {

    User selectUser(Integer id);
}

import com.lanjchenx.loveyuan.entity.User;
import com.lanjchenx.loveyuan.mapper.UserDao;
import com.lanjchenx.loveyuan.service.UserService;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * 用户表 服务实现类
 * @since 2020-07-15
 */
@Service
public class UserServiceImpl extends ServiceImpl<UserDao, User> implements UserService {

    @Resource
    private UserDao userMapper;

    @Override
    public User selectUser(Integer id) {
        return userMapper.selectUser(id);
    }
}

UserDao 和 UserMapper.xml

注意：xml里的id标签和userDao里的方法名对应上
UserDao :

import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.lanjchenx.loveyuan.entity.User;

/**
 * 用户表 Mapper 接口
 *
 * @since 2020-07-15
 */
public interface UserDao extends BaseMapper<User> {
    User selectUser(Integer id);
}

UserMapper.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lanjchenx.loveyuan.mapper.UserDao">

    <select id="selectUser"  resultType="com.lanjchenx.loveyuan.entity.User">
      select * from user where id = #{id}
    </select>

<!--    <resultMap id="BaseResultMap" type="com.fengwenyi.mybatis_plus_example.model.Idcard">-->
<!--        <id column="id" property="id" />-->
<!--        <result column="code" property="code" />-->
<!--    </resultMap>-->

</mapper>

sql 文件

CREATE TABLE `user` (
  `id` bigint(20) NOT NULL COMMENT '用户ID',
  `name` varchar(50) DEFAULT NULL COMMENT '用户名',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户表';
INSERT INTO `demo`.`user`(`id`, `name`) VALUES (1, '张三');
INSERT INTO `demo`.`user`(`id`, `name`) VALUES (2, '李四');
INSERT INTO `demo`.`user`(`id`, `name`) VALUES (3, '王五');