springboot2.x整合mybatis、druid、tk.mybatis及pagehelper

最新推荐文章于 2020-12-30 14:01:56 发布
最新推荐文章于 2020-12-30 14:01:56 发布
阅读量990 收藏
点赞数 1
分类专栏： Springboot 文章标签： springboot 2.x mybatis tk.mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjy511295494/article/details/97390191
版权

前言

由于使用nacos作为配置中心，方便配置统一管理，因此尽可能简化application.yml中的配置，改用注解的方式进行配置。

1.添加依赖

我用的spring-boot是2.1.6.RELEASE版本

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.6.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  
  <dependency>
      <groupId>tk.mybatis</groupId>
      <artifactId>mapper-spring-boot-starter</artifactId>
  </dependency>
  
  <!--数据库持久化相关 begin-->
  <dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
  </dependency>

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

  <!-- 分页插件 -->
  <dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
  </dependency>
  
  <!-- alibaba的druid数据库连接池 -->
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
  </dependency>
  <!--数据库持久化相关 end-->

用起步依赖是因为他们是你使用的springboot版本的最佳实践，一版情况下不需要考虑依赖之间兼容性的问题

2.数据源

从nacos中取出数据库配置

@Data
@RefreshScope
@Configuration
public class JdbcMapper {

  @Value("${jdbc.driverClassName}")
  private String driverClassName;
  @Value("${jdbc.url}")
  private String url;
  @Value("${jdbc.username}")
  private String username;
  @Value("${jdbc.password}")
  private String password;
  @Value("${jdbc.initialSize}")
  private Integer initialSize;
  @Value("${jdbc.maxActive}")
  private Integer maxActive;
  @Value("${jdbc.minPoolSize}")
  private Integer minPoolSize;
  @Value("${jdbc.maxWait}")
  private Long maxWait;
  @Value("${jdbc.minIdle}")
  private Integer minIdle;
  @Value("${jdbc.timeBetweenEvictionRunsMillis}")
  private Long timeBetweenEvictionRunsMillis;
  @Value("${jdbc.minEvictableIdleTimeMillis}")
  private Long minEvictableIdleTimeMillis;
  @Value("${jdbc.validationQuery}")
  private String validationQuery;
  @Value("${jdbc.testWhileIdle}")
  private Boolean testWhileIdle;
  @Value("${jdbc.testOnBorrow}")
  private Boolean testOnBorrow;
  @Value("${jdbc.testOnReturn}")
  private Boolean testOnReturn;
  @Value("${jdbc.maxOpenPreparedStatements}")
  private Integer maxOpenPreparedStatements;
  @Value("${jdbc.removeAbandoned}")
  private Boolean removeAbandoned;
  @Value("${jdbc.removeAbandonedTimeout}")
  private Integer removeAbandonedTimeout;
  @Value("${jdbc.logAbandoned}")
  private Boolean logAbandoned;
  @Value("${jdbc.poolPreparedStatements}")
  private Boolean poolPreparedStatements;
  @Value("${jdbc.filters}")
  private String filters;
  @Value("${jdbc.dbName}")
  private String dbName;
}

创建数据库连接池

@Configuration
public class DatabaseConfig {

  @Autowired
  @Lazy
  private JdbcMapper jdbcMapper;

  @Bean(name = "mysqlSource")
  @Primary
  public DataSource dataSource() {
    DruidDataSource datasource = new DruidDataSource();
    datasource.setDriverClassName(jdbcMapper.getDriverClassName());
    datasource.setUrl(jdbcMapper.getUrl());
    datasource.setUsername(jdbcMapper.getUsername());
    datasource.setPassword(jdbcMapper.getPassword());
    datasource.setInitialSize(jdbcMapper.getInitialSize());
    datasource.setMaxActive(jdbcMapper.getMaxActive());
    datasource.setMaxWait(jdbcMapper.getMaxWait());
    datasource.setMinIdle(jdbcMapper.getMinIdle());
    datasource.setTimeBetweenEvictionRunsMillis(jdbcMapper.getTimeBetweenEvictionRunsMillis());
    datasource.setMinEvictableIdleTimeMillis(jdbcMapper.getMinEvictableIdleTimeMillis());
    datasource.setValidationQuery(jdbcMapper.getValidationQuery());
    datasource.setTestWhileIdle(jdbcMapper.getTestWhileIdle());
    datasource.setTestOnBorrow(jdbcMapper.getTestOnBorrow());
    datasource.setTestOnReturn(jdbcMapper.getTestOnReturn());
    datasource.setMaxOpenPreparedStatements(jdbcMapper.getMaxOpenPreparedStatements());
    datasource.setRemoveAbandoned(jdbcMapper.getRemoveAbandoned());
    datasource.setRemoveAbandonedTimeout(jdbcMapper.getRemoveAbandonedTimeout());
    datasource.setLogAbandoned(jdbcMapper.getLogAbandoned());
    List<Filter> list = new ArrayList();
    list.add(new StatFilter());
    WallFilter wallFilter = new WallFilter();
    WallConfig config = new WallConfig();
    config.setMultiStatementAllow(true);
    wallFilter.setConfig(config);
    list.add(wallFilter);
    datasource.setProxyFilters(list);

    return datasource;

  }


  @Bean
  public ServletRegistrationBean druidServlet() {
    ServletRegistrationBean reg = new ServletRegistrationBean();
    reg.setServlet(new StatViewServlet());
    reg.addUrlMappings("/druid/base/*");
    reg.addInitParameter("loginUsername", "druid");
    reg.addInitParameter("loginPassword", "jiajian123456");
    return reg;
  }

  @Bean
  public FilterRegistrationBean filterRegistrationBean() {
    FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
    filterRegistrationBean.setFilter(new WebStatFilter());
    filterRegistrationBean.addUrlPatterns("/*");
    filterRegistrationBean
        .addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
    filterRegistrationBean.addInitParameter("profileEnable", "true");
    filterRegistrationBean.addInitParameter("principalCookieName", "USER_COOKIE");
    filterRegistrationBean.addInitParameter("principalSessionName", "USER_SESSION");
    return filterRegistrationBean;
  }

}

3.mybatis配置

@Configuration
@EnableTransactionManagement
@MapperScan("com.capture.provider.mapper")
public class MyBatisConfig {

    @Resource
    DataSource dataSource;

    @Bean
    @Primary
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setTypeAliasesPackage("com.capture.model.po");
        //分页插件
        PageInterceptor pageHelper = new PageInterceptor();
        Properties properties = new Properties();
        properties.setProperty("reasonable", "true");
        properties.setProperty("supportMethodsArguments", "true");
        properties.setProperty("helperDialect", "mysql");
        properties.setProperty("params", "count=countSql");
        pageHelper.setProperties(properties);

        //添加插件
        sessionFactory.setPlugins(new Interceptor[]{pageHelper});

        //添加XML目录
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        try {
            sessionFactory.setMapperLocations(resolver.getResources("classpath:mapper/*.xml"));
            return sessionFactory.getObject();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }


    @Bean
    @Primary
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }


    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dataSource);
    }


}

创建会话工厂时添加分页插件，指定mybatis的xml所在的位置
注意在MyBatisConfig类的上面添加的@MapperScan注解是tk.mybatis的注解，用来指定mapper接口所在的位置，用org.mybatis的@MapperScan注解是不能实现tk.mybatis提供的功能的

4.tk.mybatis使用

1.创建数据操作接口

public interface BaseMapper <T> extends tk.mybatis.mapper.common.BaseMapper<T>, MySqlMapper<T>,
    IdsMapper<T>, ConditionMapper<T>,ExampleMapper<T>,RowBoundsMapper<T> {

}

2.创建通用service层接口

/**
 * 通用接口
 *
 * @param <T> the type parameter @author paascloud.net@gmail.com
 *
 * @author paascloud.net@gmail.com
 */
public interface IBaseService<T> {
	/**
	 * 根据实体中的属性值进行查询, 查询条件使用等号  @param record the record
	 *
	 * @param record the record
	 *
	 * @return the list
	 */
	List<T> select(T record);

	/**
	 * 根据主键字段进行查询, 方法参数必须包含完整的主键属性, 查询条件使用等号  @param key the key
	 *
	 * @param key the key
	 *
	 * @return the t
	 */
	T selectByPrimaryKey(Object key);

	/**
	 * 查询全部结果, select(null)方法能达到同样的效果  @return the list
	 *
	 * @return the list
	 */
	List<T> selectAll();

	/**
	 * 根据实体中的属性进行查询, 只能有一个返回值, 有多个结果是抛出异常, 查询条件使用等号  @param record the record
	 *
	 * @param record the record
	 *
	 * @return the t
	 */
	T selectOne(T record);

	/**
	 * 根据实体中的属性查询总数, 查询条件使用等号  @param record the record
	 *
	 * @param record the record
	 *
	 * @return the int
	 */
	int selectCount(T record);

	/**
	 * 保存一个实体, null的属性不会保存, 会使用数据库默认值  @param record the record
	 *
	 * @param record the record
	 *
	 * @return the int
	 */
	int save(T record);

	/**
	 * 批量保存  @param list the list
	 *
	 * @param list the list
	 *
	 * @return the int
	 */
	@Transactional(rollbackFor = Exception.class)
	int batchSave(List<T> list);

	/**
	 * 根据主键更新属性不为null的值  @param entity the entity
	 *
	 * @param entity the entity
	 *
	 * @return the int
	 */
	int update(T entity);

	/**
	 * 根据实体属性作为条件进行删除, 查询条件使用等号  @param record the record
	 *
	 * @param record the record
	 *
	 * @return the int
	 */
	int delete(T record);

	/**
	 * 批量删除  @param list the list
	 *
	 * @param list the list
	 *
	 * @return the int
	 */
	@Transactional(rollbackFor = Exception.class)
	int batchDelete(List<T> list);

	/**
	 * 根据主键字段进行删除, 方法参数必须包含完整的主键属性  @param key the key
	 *
	 * @param key the key
	 *
	 * @return the int
	 */
	int deleteByKey(Object key);

	/**
	 * 这个查询支持通过Example类指定查询列, 通过selectProperties方法指定查询列  @param example the example
	 *
	 * @param example the example
	 *
	 * @return the list
	 */
	List<T> selectByExample(Object example);

	/**
	 * 根据Example条件进行查询总数  @param example the example
	 *
	 * @param example the example
	 *
	 * @return the int
	 */
	int selectCountByExample(Object example);

	/**
	 * 根据Example条件更新实体record包含的不是null的属性值  @param record the record
	 *
	 * @param record  the record
	 * @param example the example
	 *
	 * @return the int
	 */
	int updateByExample(@Param("record") T record, @Param("example") Object example);

	/**
	 * 根据Example条件删除数据  @param example the example
	 *
	 * @param example the example
	 *
	 * @return the int
	 */
	int deleteByExample(Object example);

	/**
	 * 根据实体属性和RowBounds进行分页查询  @param record the record
	 *
	 * @param record    the record
	 * @param rowBounds the row bounds
	 *
	 * @return the list
	 */
	List<T> selectByRowBounds(T record, RowBounds rowBounds);

	/**
	 * 根据example条件和RowBounds进行分页查询  @param example the example
	 *
	 * @param example   the example
	 * @param rowBounds the row bounds
	 *
	 * @return the list
	 */
	List<T> selectByExampleAndRowBounds(Object example, RowBounds rowBounds);

}

3.创建通用service层接口实现

@Slf4j
public abstract class BaseBaseServiceImpl<T> implements IBaseService<T> {

  @Autowired
  protected BaseMapper<T> mapper;

  /**
   * Select list.
   *
   * @param record the record
   *
   * @return the list
   */
  @Override
  public List<T> select(T record) {
    return mapper.select(record);
  }

  /**
   * Select by key t.
   *
   * @param key the key
   *
   * @return the t
   */
  @Override
  public T selectByPrimaryKey(Object key) {
    return mapper.selectByPrimaryKey(key);
  }

  /**
   * Select all list.
   *
   * @return the list
   */
  @Override
  public List<T> selectAll() {
    return mapper.selectAll();
  }

  /**
   * Select one t.
   *
   * @param record the record
   *
   * @return the t
   */
  @Override
  public T selectOne(T record) {
    return mapper.selectOne(record);
  }

  /**
   * Select count int.
   *
   * @param record the record
   *
   * @return the int
   */
  @Override
  public int selectCount(T record) {
    return mapper.selectCount(record);
  }

  /**
   * Select by example list.
   *
   * @param example the example
   *
   * @return the list
   */
  @Override
  public List<T> selectByExample(Object example) {
    return mapper.selectByExample(example);
  }

  /**
   * Save int.
   *
   * @param record the record
   *
   * @return the int
   */
  @Override
  public int save(T record) {
    return mapper.insertSelective(record);
  }

  /**
   * Batch save int.
   *
   * @param list the list
   *
   * @return the int
   */
  @Override
  public int batchSave(List<T> list) {
    int result = 0;
    for (T record : list) {
      int count = mapper.insertSelective(record);
      result += count;
    }
    return result;
  }

  /**
   * Update int.
   *
   * @param entity the entity
   *
   * @return the int
   */
  @Override
  public int update(T entity) {
    return mapper.updateByPrimaryKeySelective(entity);
  }

  /**
   * Delete int.
   *
   * @param record the record
   *
   * @return the int
   */
  @Override
  public int delete(T record) {
    return mapper.delete(record);
  }

  /**
   * Delete by key int.
   *
   * @param key the key
   *
   * @return the int
   */
  @Override
  public int deleteByKey(Object key) {
    return mapper.deleteByPrimaryKey(key);
  }

  /**
   * Batch delete int.
   *
   * @param list the list
   *
   * @return the int
   */
  @Override
  public int batchDelete(List<T> list) {
    int result = 0;
    for (T record : list) {
      int count = mapper.deleteByPrimaryKey(record);
      if (count < 1) {
        log.error("删除数据失败");
        throw new BusinessException(ErrorCodeEnum.ERROR_DB_INSERT_FAIL);
      }
      result += count;
    }
    return result;
  }

  /**
   * Select count by example int.
   *
   * @param example the example
   *
   * @return the int
   */
  @Override
  public int selectCountByExample(Object example) {
    return mapper.selectCountByExample(example);
  }

  /**
   * Update by example int.
   *
   * @param record  the record
   * @param example the example
   *
   * @return the int
   */
  @Override
  public int updateByExample(T record, Object example) {
    return mapper.updateByExampleSelective(record, example);
  }

  /**
   * Delete by example int.
   *
   * @param example the example
   *
   * @return the int
   */
  @Override
  public int deleteByExample(Object example) {
    return mapper.deleteByPrimaryKey(example);
  }

  /**
   * Select by row bounds list.
   *
   * @param record    the record
   * @param rowBounds the row bounds
   *
   * @return the list
   */
  @Override
  public List<T> selectByRowBounds(T record, RowBounds rowBounds) {
    return mapper.selectByRowBounds(record, rowBounds);
  }

  /**
   * Select by example and row bounds list.
   *
   * @param example   the example
   * @param rowBounds the row bounds
   *
   * @return the list
   */
  @Override
  public List<T> selectByExampleAndRowBounds(Object example, RowBounds rowBounds) {
    return mapper.selectByExampleAndRowBounds(example, rowBounds);
  }

}

4.创建实体类

@Data
@Table(name="bdc_account")//设置数据库中表名字
public class BdcAccount implements Serializable {

  private static final long serialVersionUID = 1130119242372588401L;

  @Id
  private Integer id;

  private String url;

  private String website;

  private String username;

  private String password;

}

5.继承数据操作接口

public interface BdcAccountMapper extends BaseMapper<BdcAccount> {

  List<BdcAccount> getBdcAccountList();

}

6.创建接口对应的xml

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.capture.provider.mapper.BdcProductPublishMapper">
</mapper>

7.在service层不写sql直接操作单表

@Service
@Slf4j
public class BdcAccountBaseServiceImpl extends BaseBaseServiceImpl<BdcAccount> implements
    BdcAccountBaseService {

  @Resource
  private BdcAccountMapper bdcAccountMapper;

  @Override
  public BdcAccount selectByPrimaryKey() {
    BdcAccount account = new BdcAccount();
    account.setId(1);
    account = bdcAccountMapper.selectByPrimaryKey(account);
    return account;
  }
}

8.service层只要继承一下通用service层接口实现

@Service
@Slf4j
public class BdcProductPublishBaseServiceImpl extends
    BaseBaseServiceImpl<BdcProductPublish> implements
    BdcProductPublishBaseService {

}

9.直接调用通用service的方法操作单表

@RestController
public class BdcProductPublishQueryFeignClient {

  @Resource
  private BdcProductPublishBaseService bdcProductPublishService;

  public BdcProductPublishVo getBdcProductPublishVo(Integer publishId) {
    BdcProductPublish publish = new BdcProductPublish();
    publish.setId(publishId);
    return bdcProductPublishService.selectByPrimaryKey(publish);
  }
}

5.小结

至此，我们就可以把单表那些枯燥无聊重复的代码抛到脑后了；如果需要写一些多表关联的复杂sql，你开始可以写在mapper对应的xml中，正常使用mybatis调用即可。

spark_youngster
关注
专栏目录
【Springboot集成tk.Mybatis】
fenxi4152的博客
07-13 554
Springboot集成tk.Mybatis，mybatis,springboot,java
Spring Boot - 3.spring boot 整合tk.mybatis
PxzBoss的博客
03-16 484
1.整合 Druid 数据源 概述 Druid 是阿里巴巴开源平台上的一个项目，整个项目由数据库连接池、插件框架和 SQL 解析器组成。该项目主要是为了扩展 JDBC 的一些限制，可以让程序员实现一些特殊的需求，比如向密钥服务请求凭证、统计 SQL 信息、SQL 性能收集、SQL 注入检查、SQL 翻译等，程序员可以通过定制来实现自己需要的功能。 Druid 是目前最好的数据库连接池，在功能、性能...
MyBatis基于Spring-boot集成通用Mapper以及pagehelper分页插件
09-17
MyBatis基于Spring-boot集成通用Mapper以及pagehelper分页插件，含单元测试、SQL脚本；减少Mybatis SQL的编写
SpringBoot 2.x 整合Mybatis三：tk.mybatis
赵彦军
06-19 8052
转载请标明出处：http://blog.csdn.net/zhaoyanjun6/article/details/75647437 本文出自【赵彦军的博客】 简介 地址：https://github.com/abel533/Mapper/wiki/1.3-spring-boot 具体版本号：http://mvnrepository.com/artifact/tk.myba...
spring-boot集成4：集成mybatis，druid和tk.mybatis
dianhe6449的博客
11-21 203
Why mybatis? mybatis提供了ORM功能，相比于其他ORM框架，其需要编写更多的sql，也给了我们编写特殊/复杂sql和进行sql优化的机会。 Why druid? Druid是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是目前最好的数据库连接池。 在功能、性能、扩展性方面，都超过其他数据库连接池，同时加入了日志监控， 可以很好的监控DB池连接和SQL的...
springbootdemo2:这是封装版的springboot+tk.mybatis+sql server(mysql)
05-17
这个项目采用的是springboot+tk.mybatis+sqlserver（可以切换至mysql） 其中对service层进行了封装,将Mapper baseMapper封装作为service层的一个对象,而其他映射到Mapper.xml的文件 则是针对特殊需求使用 可以通过修改application.yml,添加mysql的驱动就可以了，另外修改pom文件中的驱动设置为mysql
Springboot中使用pageHelper插件
qq_41096887的博客
01-21 843
Springboot中使用pageHelper插件 ​ 都知道pagehelper是一个MyBatis的分页插件，其实在如今的前后端分离项目中，我们使用该插件的机会并不多。但我还是觉得这部分内容还是应该学习和掌握的，毕竟我们应该善其身而兼济天下。 ​ ok，我准备从以下几个方面来说一下pagehelper。 优点 无需你自己去封装以及关心sql分页等问题，使用很方便，前端取数据也很方便。 我们...
SpringBoot+Mybatis+Druid+PageHelper实现多数据源并分页方法
08-26
总结来说，SpringBoot整合Mybatis、Druid和PageHelper可以创建一个高性能、易维护的后端系统。通过Druid，我们能够监控数据库性能，优化连接池配置；使用PageHelper可以简化分页查询的实现；而多数据源的支持则增强...
如何整合tk.mybatis 到springboot 项目中
小样
01-09 358
一、根源 tk.mybatis 是一款mybatis的插件，可以自动生成xml，mapper等，之前也用过一些其他插件，比如mybatis-generater ，但是会有个个问题，xml文件中会包含所有那些公共的方法。这样看上去很不友好，想在自己公司的老项目中整合进tk.mybatis 二、整合步骤 1、新增代码 ①添加maven依赖 <dependency> ...
tkmbatis 日志_Spring Boot 中使用 TKMybatis 和 PageHelper
weixin_36485321的博客
12-30 163
整合 Druid 数据源引入依赖在 pom.xml 中引入 druid-spring-boot-starter 和 mysql-connector-java 依赖com.alibabadruid-spring-boot-starter1.1.10mysqlmysql-connector-java5.1.40runtime相关配置在 application.yml 中添加以下配置spring:dat...
springboot + mybatis + pagehelper分页插件 + druid连接池 + generator逆向插件，请阅读README.md
06-18
springboot + mybatis + pagehelper分页插件 + druid连接池 + generator逆向插件
Spring Boot系列六 Spring boot集成mybatis、分页插件pagehelper
不积跬步无以至千里; 不积小流无以成江海
09-17 1万+
1. Spring Boot集成mybatis 2. Spring Boot集成pagehelper分页插件，定义分页的相关类 3. 实现工具类：model转dto，实现数据层和传输层的解耦 4. 完整展示了从浏览器输入URL，并从数据库操作数据的完整流程
Spring Boot教程(八)：Spring Boot集成pagehelper分页插件
热门推荐
蝈蝈的博客
05-07 3万+
一、项目准备 直接使用上个章节的源码，Spring Boot教程(七)：Spring Boot集成druid连接池 为了方便，后面章节不再根据章节内容修改包名和启动类名，所以先对上节源码做以下修改： 1、包名修改 将包名com.songguoliang.mybatis修改为com.songguoliang.springboot。 2、修改启动类 将启动类DruidApplication...
springboot中使用mybatis的分页插件pageHelper
du6666的博客
04-10 648
springboot中使用mybatis的分页插件pageHelper 1.首先在pom.xml中配置 <!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter --> <dependency> <groupId>org.myba...
关于springboot集成mybatis pageHelper druid 配置
a625013的专栏
08-07 496
springboot集成mybatis pageHelper druid 配置
Springboot集成Mybaties的分页插件Pagehelper的坑
第一行代码
09-02 1403
使用springboot集成Mybaties，使用到了pageHelper这个分页插件，但是在使用的时候出现了一个问题 分页插件配置： pagehelper: helper-dialect: mysql reasonable: true params: count=countsql support-methods-arguments: true springboot启动报错：...
Spring-Boot学习笔记-整合Mybatis-Druid-PageHelper
HowieLi
03-20 1125
写在前面　　看过几个大牛写的博客还有在一些网课网站上看的讲SpringBoot的视频，几乎都是讲的基于Hibernate来进行数据库操作。虽然我之前也学习过Hibernate，不过，我更喜欢Mybatis这种可以自定义SQL，而且还更轻量级的框架，所以我通过查阅资料，对Mybatis进行了整合。整合期间失败过很多次，主要的原因是我查阅的大部分资料都是很早之前的版本，在我现在使用的版本中并不适用；次要
springboot整合mybatis
qq_44271884的博客
11-10 174
springboot配置数据库连接池druid 新建springboot项目时勾选上SQL里面的MySQL、JDBC、MyBatis.，在上次建项目的基础上。 druid学习地址 https://github.com/alibaba/druid/tree/master/druid-spring-boot-starter 首先我们要导入druid所需pom依赖 <dependency> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值