springboot 整合mybatis

最新推荐文章于 2021-08-17 11:10:03 发布

留白1108

最新推荐文章于 2021-08-17 11:10:03 发布

阅读量652

点赞数

文章标签：数据库 mybatis mysql java spring

本文链接：https://blog.csdn.net/nathan_csdn/article/details/122636736

版权

本文详细介绍了如何从零开始在Spring Boot项目中整合MyBatis，使用tk.mybatis框架生成模板代码，并利用paginator组件实现分页功能。包括配置POM依赖、新建项目包结构、配置application.properties、编写配置代码等步骤，最后通过测试验证配置的正确性。

摘要由CSDN通过智能技术生成

前言

你将会学习到什么

从0开始学习spring和mybatis的整合。
基于 tk.mybatis框架 生成模板代码
利用 paginator组件 实现分页功能

你需要做哪些准备

一个可以使用的springboot项目，可查看此博客完成：快速构建一个springboot项目
一个可以使用的MySQL数据库，或者选择安装： MySQL三分钟快速入门

一、配置POM依赖

添加所需jar包版本，你直接替换 pom.xml 的 <properties> 即可

<properties>
        <!-- 跳过maven的test流程 -->
        <skipTests>true</skipTests>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
        <fastjson.version>1.1.26</fastjson.version>
        <mybatis.version>3.4.1</mybatis.version>
        <mybatis-spring.version>1.3.0</mybatis-spring.version>
        <druid.version>1.0.24</druid.version>
        <servlet-api.version>3.1.0</servlet-api.version> 
        <!-- 生成UUID的工具 -->
        <fasterxml.uuid.version>3.1.4</fasterxml.uuid.version>
        <org.codehaus.jackson.version>1.9.13</org.codehaus.jackson.version>
        <!-- 分页插件 -->
        <github.miemiedev.version>1.2.17</github.miemiedev.version>
</properties>

添加JSON相关依赖

<!-- fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>${fastjson.version}</version>
</dependency>           
<!--对json格式的支持 -->
<dependency>
    <groupId>org.codehaus.jackson</groupId>
    <artifactId>jackson-mapper-asl</artifactId>
    <version>${org.codehaus.jackson.version}</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>   
<dependency>
    <groupId>com.fasterxml.uuid</groupId>
    <artifactId>java-uuid-generator</artifactId>
    <version>${fasterxml.uuid.version}</version>
</dependency>

添加JDBC依赖

<!-- 添加JDBC jar -->
<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>1.1.1</version>
</dependency>
<dependency>
  <groupId>tk.mybatis</groupId>
  <artifactId>mapper-spring-boot-starter</artifactId>
  <version>1.1.0</version>
</dependency>   
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>${druid.version}</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

添加mybatis分页插件

<!-- mybatis分页插件 -->
<dependency>  
    <groupId>com.github.miemiedev</groupId>  
    <artifactId>mybatis-paginator</artifactId>  
    <version>${github.miemiedev.version}</version>  
    <exclusions>
        <exclusion>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <scope>provided</scope>	
</dependency>

添加log4j依赖

<dependency>
	<groupId>org.slf4j</groupId>
	<artifactId>slf4j-api</artifactId>
	<version>1.7.25</version>
</dependency>
<dependency>
	<groupId>org.slf4j</groupId>
	<artifactId>log4j-over-slf4j</artifactId>
</dependency>
<dependency>
	<groupId>org.slf4j</groupId>
	<artifactId>jcl-over-slf4j</artifactId>
</dependency>

好，到此为止，我们的POM依赖都准备好了。接下来我们准备一下我们的项目包结构

二、新建package

我们需要创建如下 pacage

config - 用于存放配置类
entity - 用于存放数据实体
mapper - 用于存放mapper类
mapping - 存放mybatis的mapping.xml文件
service - 存放service业务类
controller - 存放前端控制器类

三、配置

配置application.properties

server.port=8001
server.servlet.context-path=/mybatis
# 编码
server.servlet.encoding.charset=UTF-8
# spring日期类型转换格式
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=GMT+8
# 过滤请求参数空值，接收前端请求时若前端传的值为null，避免后端NPE的问题
spring.jackson.default-property-inclusion=non-null

# 配置数据源
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.url=jdbc:mysql://localhost:3306/local_test?characterEncoding=UTF-8&autoReconnect=true&zeroDateTimeBehavior=convertToNull&useUnicode=true
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=dev_user
spring.datasource.password=@dev6pWd

# mybatis相关配置
mybatis.type-aliases-package=com.lb.springboot
mybatis.mapper-locations=classpath:com/lb/springboot/mapping/*.xml
logging.level.tk.mybatis=TRACE

新增 druid.properties配置

将文件放在 /src/main/resources/ 目录

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

四、编写配置代码

1.新建DruidDataSourceProperties.java

在 config 包下新建 datasource 包，创建 DruidDataSourceProperties.java 文件
DruidDataSourceProperties 可以理解为所有的Druid配置信息，它等同于一个properties文件，只不过它以Java组件的形式这展示。它可以方便的 @Autowired 到任何一个需要使用它的地方。

package com.lb.springboot.config.datasource;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "spring.datasource")
@PropertySource("classpath:druid.properties")
public class DruidDataSourceProperties {
	private String driverClassName;
	private String url;
	private String username;
	private String password;
	@Value("${druid.initialSize}")
	private int initialSize;
	
	@Value("${druid.minIdle}")
	private int minIdle;
	
	@Value("${druid.maxActive}")
	private int maxActive;
	
	@Value("${druid.timeBetweenEvictionRunsMillis}")
	private long timeBetweenEvictionRunsMillis;
	
	@Value("${druid.minEvictableIdleTimeMillis}")
	private long minEvictableIdleTimeMillis;
	
	@Value("${druid.validationQuery}")
	private String validationQuery;
	
	@Value("${druid.testWhileIdle}")
	private boolean testWhileIdle;
	
	@Value("${druid.testOnBorrow}")
	private boolean testOnBorrow;
	
	@Value("${druid.testOnReturn}")
	private boolean testOnReturn;
	
	@Value("${druid.poolPreparedStatements}")
	private boolean poolPreparedStatements;
	
	@Value("${druid.maxPoolPreparedStatementPerConnectionSize}")
	private int maxPoolPreparedStatementPerConnectionSize;
	
	@Value("${druid.filters}")
	private String filters;
	
	@Value("${druid.connectionProperties}")
	private String connectionProperties;
	
	@Bean
	public static PropertySourcesPlaceholderConfigurer propertyConfigure(){
		return new PropertySourcesPlaceholderConfigurer();
	}
        // 此处省略N个get \ set 方法

2. 创建 DruidDataSourceConfig.java

DruidDataSourceConfig.java 是 Druid 数据源具体的配置，注入了 DruidDataSourceProperties 组件
并提供初始化连接池实例、Druid数据源监控拦截器、请求URL过滤器及事务的支持。

package com.lb.springboot.config.datasource;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;

@Configuration
@EnableTransactionManagement
public class DruidDataSourceConfig {
	/** 驱动名称 */
	private String DEFAULT_DRIVER_CLASSNAME;

	private static final Logger LOGGER = LoggerFactory.getLogger(DruidDataSourceConfig.class);
	
	@Autowired
	private DruidDataSourceProperties dataSourceProperties;
	
	/**
	 * Druid数据源监控拦截器
	 * 可以监控数据库的连接情况
	 * @return
	 */
	@Bean
	public ServletRegistrationBean druidRegistrationBean() {
		ServletRegistrationBean registrationBean = new ServletRegistrationBean();
		registrationBean.setServlet(new StatViewServlet());
		registrationBean.addUrlMappings("/druid/*");
		registrationBean.addInitParameter("allow", "127.0.0.1");
		LOGGER.info(" druid console manager info : {} ", registrationBean);
		return registrationBean;
	}

	/**
	 * 请求URL过滤器
	 * @return
	 */
    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new WebStatFilter());
        filterRegistrationBean.addUrlPatterns("/*");
        filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico, /druid/*");
        LOGGER.info(" druid filter register : {} ", filterRegistrationBean);
        return filterRegistrationBean;
    }
	
    @Bean
	public DataSource dataSource() throws SQLException {
		DruidDataSource ds = new DruidDataSource();
		ds.setDriverClassName(dataSourceProperties.getDriverClassName());
		DEFAULT_DRIVER_CLASSNAME = dataSourceProperties.getDriverClassName();
		ds.setUrl(dataSourceProperties.getUrl());
		ds.setUsername(dataSourceProperties.getUsername());
		ds.setPassword(dataSourceProperties.getPassword());
		ds.setInitialSize(dataSourceProperties.getInitialSize());
		ds.setMinIdle(dataSourceProperties.getMinIdle());
		ds.setMaxActive(dataSourceProperties.getMaxActive());
		ds.setTimeBetweenEvictionRunsMillis(dataSourceProperties.getTimeBetweenEvictionRunsMillis());
		ds.setMinEvictableIdleTimeMillis(dataSourceProperties.getMinEvictableIdleTimeMillis());
		ds.setValidationQuery(dataSourceProperties.getValidationQuery());
		ds.setTestWhileIdle(dataSourceProperties.isTestWhileIdle());
		ds.setTestOnBorrow(dataSourceProperties.isTestOnBorrow());
		ds.setTestOnReturn(dataSourceProperties.isTestOnReturn());
		ds.setPoolPreparedStatements(dataSourceProperties.isPoolPreparedStatements());
		ds.setMaxPoolPreparedStatementPerConnectionSize(dataSourceProperties.getMaxPoolPreparedStatementPerConnectionSize());
		ds.setFilters(dataSourceProperties.getFilters());
		ds.setConnectionProperties(dataSourceProperties.getConnectionProperties());
		LOGGER.info(" druid datasource config : {} ", ds);
		return ds;
	}

	@Bean
	public PlatformTransactionManager transactionManager() throws Exception {
		DataSourceTransactionManager txManager = new DataSourceTransactionManager();
		txManager.setDataSource(dataSource());
		return txManager;
	}
	
}

3. 创建MybatisDataSourceConfig.java

它作用是获取 DataSource 提供 SqlSessionFactory
并提供 SqlSessionTemplate 供调用方使用。

package com.lb.springboot.config.datasource;
import javax.sql.DataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;

/**
 * mybatis配置
 * <p>@Configuration代表这个类等同于XML</p>
 * @author lb
 */
@Configuration
public class MybatisDataSourceConfig {
	
	@Autowired
	private DataSource dataSource;
	
	@Bean(name="sqlSessionFactory")
	public SqlSessionFactory sqlSessionFactoryBean() {
		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
		bean.setDataSource(dataSource);
		ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
		try {
			// 添加mybatis mapping文件的目录
			bean.setMapperLocations(resolver.getResources("classpath:com/lb/springboot/mapping/*.xml"));
			SqlSessionFactory sqlSessionFactory = bean.getObject();
			sqlSessionFactory.getConfiguration().setCacheEnabled(Boolean.TRUE);
			return sqlSessionFactory;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

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

}

4. 创建MybatisMapperScanerConfig.java

它设置mybatis的Scaner，扫描所有的mapper
@AutoConfigureAfter 的作用是，在初始化 MybatisDataSourceConfig.class 之后再初始化本类

package com.lb.springboot.config.datasource;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * mybatis的mapper扫描
 * @author lb
 */
@Component
@AutoConfigureAfter(MybatisDataSourceConfig.class)
public class MybatisMapperScanerConfig {
	
	@Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer configurer = new MapperScannerConfigurer();
        configurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
        configurer.setBasePackage("com.lb.springboot.mapper");
        return configurer;
    }
}

五、测试

启动项目

浏览器访问 localhost:8001/mybatis/druid ,为什么是 /druid呢？因为我们 DruidDataSourceConfig 的 ServletRegistrationBean 作为监控平台，访问这个地址会直接调转到Druid提供的可视化界面，内容如下：

恭喜你，spring整合mybatis 配置就完成了！接下来我们要进行一下编码

六、mybatis编码

public class LtDict implements Serializable {
    private static final long serialVersionUID = -8989159627410048345L;
    @Id
	@GeneratedValue(generator="UUID")
	private String id;
    private String code;
    private String name;
    private String status;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id == null ? null : id.trim();
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code == null ? null : code.trim();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }
    public String getStatus() {
        return status;
    }
    public void setStatus(String status) {
        this.status = status == null ? null : status.trim();
    }
}

import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.mapper.common.MySqlMapper;
/**
 * 继承tk.mybatis的Mapper
 * @param <T>
 */
public interface BaseMapper<T> extends Mapper<T>, MySqlMapper<T> {
}

import com.github.miemiedev.mybatis.paginator.domain.PageBounds;
import com.lb.springboot.common.BaseMapper;
import com.lb.springboot.entity.LtDict;
import org.apache.ibatis.annotations.Param;
import java.util.List;

public interface DictMapper extends BaseMapper<LtDict> {
    List<LtDict> findByStatus(@Param("status")String status, PageBounds pageBounds);
}

<?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.lb.springboot.mapper.DictMapper" >
  <resultMap id="BaseResultMap" type="com.lb.springboot.entity.LtDict" >
    <id column="id" property="id" jdbcType="VARCHAR" />
    <result column="code" property="code" jdbcType="VARCHAR" />
    <result column="name" property="name" jdbcType="VARCHAR" />
    <result column="status" property="status" jdbcType="VARCHAR" />
  </resultMap>
  <sql id="Base_Column_List" >
    id, code, name, status
  </sql>

	<select id="findByStatus" resultMap="BaseResultMap">
		select id, code, name, status from lt_dict d
		where status = #{status, jdbcType=VARCHAR}
	</select>

</mapper>

import com.alibaba.fastjson.JSON;
import com.lb.springboot.entity.LtDict;
import com.lb.springboot.mapper.DictMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
import java.util.Random;

@RunWith(SpringRunner.class)
@SpringBootTest
public class ApplicationTests {

	@Autowired
	private DictMapper dictMapper;

	@Test
	public void insertTest(){
		for (int i = 1; i < 5; i++) {
			LtDict dict = new LtDict();
			dict.setCode(String.valueOf(new Random().nextInt()));
			dict.setName("TEST-"+i);
			dict.setStatus("1");
			dictMapper.insert(dict);
		}
	}

	@Test
	public void selectTest(){
		List<LtDict> dictList = dictMapper.selectAll();
		System.err.println(JSON.toJSONString(dictList,true));
	}
}