Mybatis使用及与Spring的相关整合

海贼小林子 2021-05-19

298

由于公司的单体服务是采用的SSM架构，这里对Mybatis的学习做一下记录，以加深印象

一、简介

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录

二、简单使用

1.引入依赖（pom.xml）

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.2.8</version>
</dependency>

2.全局配置文件（mybatis-config.xml）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!-- 根标签 -->
<configuration>
<properties>
  <property name="driver" value="com.mysql.jdbc.Driver"/>
  <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis-110?useUnicode=true&amp;characterEncoding=utf-8&amp;allowMultiQueries=true"/>
  <property name="username" value="root"/>
      <property name="password" value="123456"/>
   </properties>


   <!-- 环境，可以配置多个，default：指定采用哪个环境 -->
   <environments default="test">
      <!-- id：唯一标识 -->
      <environment id="test">
         <!-- 事务管理器，JDBC类型的事务管理器 -->
         <transactionManager type="JDBC" >
         <!-- 数据源，池类型的数据源 -->
         <dataSource type="POOLED">
            <property name="driver" value="com.mysql.jdbc.Driver" >
            <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis-110" >
            <property name="username" value="root" >
            <property name="password" value="123456" >
         </dataSource>
      </environment>
      <environment id="development">
         <!-- 事务管理器，JDBC类型的事务管理器 -->
         <transactionManager type="JDBC" >
         <!-- 数据源，池类型的数据源 -->
         <dataSource type="POOLED">
            <property name="driver" value="${driver}" > <!-- 配置了properties，所以可以直接引用 -->
            <property name="url" value="${url}" >
            <property name="username" value="${username}" >
            <property name="password" value="${password}" >
         </dataSource>
      </environment>
   </environments>
  </configuration>

3.配置Map.xml（MyMapper.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：命名空间，随便写，一般保证命名空间唯一 -->
<mapper namespace="MyMapper">
   <!-- statement，内容：sql语句。id：唯一标识，随便写，在同一个命名空间下保持唯一
      resultType：sql语句查询结果集的封装类型,tb_user即为数据库中的表
    -->
   <select id="selectUser" resultType="com.zpc.mybatis.User">
      select * from tb_user where id = #{id}
   </select>
</mapper>

4.修改全局配置文件（mybatis-config.xml）

<configuration>
   <!-- 环境，可以配置多个，default：指定采用哪个环境 -->
   <environments default="test">
      <!-- id：唯一标识 -->
      <environment id="test">
         <!-- 事务管理器，JDBC类型的事务管理器 -->
         <transactionManager type="JDBC" >
         <!-- 数据源，池类型的数据源 -->
         <dataSource type="POOLED">
            <property name="driver" value="com.mysql.jdbc.Driver" >
            <property name="url" value="jdbc:mysql://127.0.0.1:3306/ssmdemo" >
            <property name="username" value="root" >
            <property name="password" value="123456" >
         </dataSource>
      </environment>
   </environments>
   <mappers>
     <mapper resource="mappers/MyMapper.xml" >
   </mappers>
</configuration>

5.构建sqlSessionFactory（MybatisTest.java）

// 指定全局配置文件
String resource = "mybatis-config.xml";
// 读取配置文件
InputStream inputStream = Resources.getResourceAsStream(resource);
// 构建sqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

6.打开sqlSession会话，并执行sql（MybatisTest.java）

// 获取sqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 操作CRUD，第一个参数：指定statement，规则：命名空间+“.”+statementId
// 第二个参数：指定传入sql的参数：这里是用户id
User user = sqlSession.selectOne("MyMapper.selectUser", 1);
System.out.println(user);

示例代码：MybatisTest

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;


import java.io.InputStream;


public class MybatisTest {
   public static void main(String[] args) throws Exception {
      // 指定全局配置文件
      String resource = "mybatis-config.xml";
      // 读取配置文件
      InputStream inputStream = Resources.getResourceAsStream(resource);
      // 构建sqlSessionFactory
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
      // 获取sqlSession
      SqlSession sqlSession = sqlSessionFactory.openSession();
      try {
         // 操作CRUD，第一个参数：指定statement，规则：命名空间+“.”+statementId
         // 第二个参数：指定传入sql的参数：这里是用户id
         User user = sqlSession.selectOne("MyMapper.selectUser", 1);
         System.out.println(user);
      } finally {
         sqlSession.close();
      }
   }
}

User.java

import java.text.SimpleDateFormat;
import java.util.Date;


public class User {
    private String id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private Integer sex;
    private Date birthday;
    private String created;
    private String updated;


    public String getId() {
        return id;
    }


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


    public String getUserName() {
        return userName;
    }


    public void setUserName(String userName) {
        this.userName = userName;
    }


    public String getPassword() {
        return password;
    }


    public void setPassword(String password) {
        this.password = password;
    }


    public String getName() {
        return name;
    }


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


    public Integer getAge() {
        return age;
    }


    public void setAge(Integer age) {
        this.age = age;
    }


    public Integer getSex() {
        return sex;
    }


    public void setSex(Integer sex) {
        this.sex = sex;
    }


    public Date getBirthday() {
        return birthday;
    }


    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }


    public String getCreated() {
        return created;
    }


    public void setCreated(String created) {
        this.created = created;
    }


    public String getUpdated() {
        return updated;
    }


    public void setUpdated(String updated) {
        this.updated = updated;
    }


    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                ", birthday='" + new SimpleDateFormat("yyyy-MM-dd").format(birthday) + '\'' +
                ", created='" + created + '\'' +
                ", updated='" + updated + '\'' +
                '}';
    }
}

7.目录结构

MyBatis使用步骤总结

1)配置mybatis-config.xml 全局的配置文件 (1、数据源，2、外部的mapper)
2)创建SqlSessionFactory
3)通过SqlSessionFactory创建SqlSession对象
4)通过SqlSession操作数据库 CRUD
5)调用session.commit()提交事务
6)调用session.close()关闭会话

二、mybatis缓存

一级缓存：默认开启存在session中

条件: 同一个session，相同的sql和参数

update、insert、delete时候会清空缓存

二级缓存：作用域：一个mapper的namespace、同一个namespace查询sql可以从缓存中命中

开启二级缓存：必须序列化

<mapper namespace="com.zpc.mybatis.dao.UserMapper">
      <cache/>
</mapper>

关闭二级缓存：

不开启、或者全局mybatis-config.xml中关闭二级缓存

<settings>


    <!--开启驼峰匹配-->


    <setting name="mapUnderscoreToCamelCase" value="true"/>


    <!--开启二级缓存,全局总开关，这里关闭，mapper中开启了也没用-->


    <setting name="cacheEnabled" value="false"/>


</settings>

三、spring 集成 mybatis

1.引入spring和mybatis相关依赖

pom.xml

<!--数据库连接池-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.8</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>1.2.2</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>4.1.3.RELEASE</version>
            </dependency>
            <!--spring集成Junit测试-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>4.1.3.RELEASE</version>
                <scope>test</scope>
            </dependency>
            <!--spring容器-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>4.1.3.RELEASE</version>
            </dependency>

2.配置spring配置文件

<beans xmlns="http://www.springframework.org/schema/beans"
                xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
                xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
                http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
                http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
                <!-- 加载配置文件 -->
                <context:property-placeholder location="classpath:properties/*.properties"/>
                <!-- 数据库连接池 -->
                <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
                    destroy-method="close">
                    <property name="driverClassName" value="${jdbc.driver}"/>
                    <property name="url"
                            value="jdbc:mysql://${jdbc.host}:3306/${jdbc.database}?useUnicode=true&amp;characterEncoding=utf-8&amp;zeroDateTimeBehavior=convertToNull"/>
                    <property name="username" value="${jdbc.userName}"/>
                    <property name="password" value="${jdbc.passWord}"/>
                    <!-- 初始化连接大小 -->
                    <property name="initialSize" value="${jdbc.initialSize}"></property>
                    <!-- 连接池最大数据库连接数  0 为没有限制 -->
                        <property name="maxActive" value="${jdbc.maxActive}"></property>
                        <!-- 连接池最大的空闲连接数，这里取值为20，表示即使没有数据库连接时依然可以保持20空闲的连接，而不被清除，随时处于待命状态 0 为没有限制 -->
                        <property name="maxIdle" value="${jdbc.maxIdle}"></property>
                        <!-- 连接池最小空闲 -->
                        <property name="minIdle" value="${jdbc.minIdle}"></property>
                        <!--最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制-->
                        <property name="maxWait" value="${jdbc.maxWait}"></property>
                    </bean>
                    <!-- spring和MyBatis完美整合 -->
                    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
                        <property name="dataSource" ref="dataSource"/>
                        <!-- 自动扫描mapping.xml文件 -->
                        <property name="mapperLocations" value="classpath:mappers/*.xml"></property>
                        <!--如果mybatis-config.xml没有特殊配置也可以不需要下面的配置-->
                        <property name="configLocation" value="classpath:mybatis-config.xml" >
                    </bean>
                    <!-- DAO接口所在包名，Spring会自动查找其下的类 -->
                    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
                        <property name="basePackage" value="com.zpc.mybatis.dao"/>
                        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
                    </bean>
                    <!-- (事务管理)transaction manager -->
                    <bean id="transactionManager"
                        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
                        <property name="dataSource" ref="dataSource"/>
                    </bean>
            </beans>

其中需要的有:

1.配置数据库连接池-比如可以配置不同数据源的数据库连接池

2.配置sqlSessionFactory，指定自动扫描mapping.xml文件、配置mybatis-config.xml，如果没用特殊配置可以不配置

3.配置MapperScannerConfigurer，自动扫描相关Mapper包和类

4.配置transactionManager，事务管理

db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.host=localhost
jdbc.database=ssmdemo
jdbc.userName=root
jdbc.passWord=123456
jdbc.initialSize=0
jdbc.maxActive=20
jdbc.maxIdle=20
jdbc.minIdle=1
jdbc.maxWait=1000

在构建sqlSessionFactory时不配置mybatis-config.xml也行：

<!-- spring和MyBatis完美整合 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <!-- 自动扫描mapping.xml文件 -->
    <property name="mapperLocations" value="classpath:mappers/*.xml"></property>
    <!--如果mybatis-config.xml没有特殊配置也可以不需要下面的配置-->
    <!--<property name="configLocation" value="classpath:mybatis-config.xml" >-->
</bean>

3.测试

import com.zpc.mybatis.dao.UserMapper;
import com.zpc.mybatis.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.io.InputStream;
import java.util.Date;
import java.util.List;


//目标：测试一下spring的bean的某些功能
@RunWith(SpringJUnit4ClassRunner.class)//junit整合spring的测试//立马开启了spring的注解
@ContextConfiguration(locations="classpath:spring/applicationContext-*.xml")//加载核心配置文件，自动构建spring容器
public class UserMapperSpringTest {


    @Autowired
    private UserMapper userMapper;


    @Test
    public void testQueryUserByTableName() {
        List<User> userList = this.userMapper.queryUserByTableName("tb_user");
        for (User user : userList) {
            System.out.println(user);
        }
    }


    @Test
    public void testLogin() {
        System.out.println(this.userMapper.login("hj", "123456"));
    }


    @Test
    public void testQueryUserById() {
        System.out.println(this.userMapper.queryUserById("1"));
        User user = new User();
        user.setName("美女");
        user.setId("1");
        userMapper.updateUser(user);


        System.out.println(this.userMapper.queryUserById("1"));
    }


    @Test
    public void testQueryUserAll() {
        List<User> userList = this.userMapper.queryUserAll();
        for (User user : userList) {
            System.out.println(user);
        }
    }


    @Test
    public void testInsertUser() {
        User user = new User();
        user.setAge(20);
        user.setBirthday(new Date());
        user.setName("大神");
        user.setPassword("123456");
        user.setSex(2);
        user.setUserName("bigGod222");
        this.userMapper.insertUser(user);
        System.out.println(user.getId());
    }


    @Test
    public void testUpdateUser() {
        User user = new User();
        user.setBirthday(new Date());
        user.setName("静静");
        user.setPassword("123456");
        user.setSex(0);
        user.setUserName("Jinjin");
        user.setId("1");
        this.userMapper.updateUser(user);
    }


    @Test
    public void testDeleteUserById() {
        this.userMapper.deleteUserById("1");
    }


    @Test
    public void testqueryUserList() {
        List<User> users = this.userMapper.queryUserList(null);
        for (User user : users) {
            System.out.println(user);
        }
    }


    @Test
    public void queryUserListByNameAndAge() throws Exception {
        List<User> users = this.userMapper.queryUserListByNameAndAge("鹏程", 20);
        for (User user : users) {
            System.out.println(user);
        }
    }


    @Test
    public void queryUserListByNameOrAge() throws Exception {
        List<User> users = this.userMapper.queryUserListByNameOrAge(null, 16);
        for (User user : users) {
            System.out.println(user);
        }
    }


    @Test
    public void queryUserListByIds() throws Exception {
        List<User> users = this.userMapper.queryUserListByIds(new String[]{"5", "2"});
        for (User user : users) {
            System.out.println(user);
        }
    }

4.目录结构：

自己的项目mybatis配置文件(这里用了多种数据库数据源)：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
xmlns:p="http://www.springframework.org/schema/p"  
xmlns:aop="http://www.springframework.org/schema/aop"   
xmlns:context="http://www.springframework.org/schema/context"  
xmlns:jee="http://www.springframework.org/schema/jee"  
xmlns:tx="http://www.springframework.org/schema/tx"  
xsi:schemaLocation="
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd  
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd  
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd ">
  <!-- hive数据库连接配置文件 -->
  <!-- 配置文件位置 -->
  <context:property-placeholder location="classpath:dataSource.properties"/>
  <bean id="dataSourceHive" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close" autowire="byName">
        <property name="driverClassName" value="${hive.driverClass}"/>
        <property name="url" value="${hive.url}"/>
        <property name="username" value="hive"/>
        <property name="password" value=""/>


        <property name="filters" value="stat"/>


        <property name="maxActive" value="${hive.maxActive}"/>
        <property name="initialSize" value="${hive.initialSize}"/>
        <property name="minIdle" value="${hive.minIdle}"/>


    </bean>
  <!-- 配置MyBatis的sqlSessionFactory -->
  <bean id="sqlSessionFactoryHive" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSourceHive"></property>
    <property name="configLocation" value="classpath:mybatis-config.xml"></property>
    
    <property name="mapperLocations" value="classpath:mapper/hive/*.xml"></property>
  </bean>


  <!-- Mapper接口所在包名，Spring会自动查找其下的Dao接口  -->
  <bean id="Configurerhive" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.rjtx.dao.hive"></property>
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactoryHive"></property>
  </bean>
  
  <bean id="transactionManagerHive"
   class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name="dataSource" ref="dataSourceHive" />
      <qualifier value="hive"/>
    </bean>
  
  <!-- 配置基于注解的声明式事务 -->
  <tx:annotation-driven transaction-manager="transactionManagerHive"></tx:annotation-driven>
  
</beans>

#重点：

如：项目用到了Hive、mysql等不同数据库

则配置不同的数据源，然后对应的DriverClass需要配置对应数据库的class、以及配置不同ID的sqlSessionFactory

原理：

使用的时候直接使用Mapper操作数据、由于配置了对应的不同sqlSessionFactory，则操作数据库的时候，会使用不同的sqlSessionFactory-然后操作对应的数据源，数据库

四、springboot 集成 mybatis

1.引入Mybatis

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

2.application.yml文件配置

server:
            port: 8081
        spring:
        datasource:
            driver-class-name: com.mysql.cj.jdbc.Driver
            url: jdbc:mysql://127.0.0.1:3306/zzz?useUnicode=true & characterEncoding=utf-8 &
            useSSL=true & serverTimezone=Asia/Shanghai
            username: root
            password: 123456
        mybatis:
            mapper-locations: classpath:/mapper/*.xml <!--用于将配置路径下的 * .xml 文件加载到 mybatis 中-->
            type-aliases-package: com.example.entity <!--指定POJO扫描包来让 mapper.xml 文件的 resultType 自动扫描到自定义POJO，这样就不用每次指定完全限定名-->

3.编写Entity、编写Dao或者Mapper、编写Service、编写Controller

4.启动类添加MapperScan扫描

@MapperScan("com.example.dao")
            @SpringBootApplication
            public class SpringmybatisApplication {
                public static void main(String[] args) {
                    SpringApplication.run(SpringmybatisApplication.class, args);
                }
            }

注意：如果不使用@MapperScan注解的话，则需要在对应的DAO或者是Mapper类上添加@Mapper注解，表明它是数据库操作

5.编写Mapper.xml文件，书写sql

<?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.example.dao.UserDao">
            <select id="getUserById" resultType="User">
                select * from `user` where id=#{id}
            </select>
            <select id="getUserById2" resultType="User">
                select * from `user` where age=#{age}
            </select>
        </mapper>

6.启动，访问

五、springcloud集成mybatis

springcloud的集成和springboot的基本一样，只是对应的有些不同的依赖需要替换成springcloud、不再赘述

数据库

文章转载自海贼小林子，如果涉嫌侵权，请发送邮件至：contact@modb.pro进行举报，并提供相关证据，一经查实，墨天轮将立刻删除相关内容。