10.Mybatis入门案例

本文来实现一个最简单的Mybatis案例。

‍

创建项目

本文使用Maven来创建项目，项目名LearnMybatis，并用Git管理，上传到了GitHub (opens new window)和Gitee (opens new window)上。

主要就是新建一个文件夹，创建对应的目录。这里我们设置打包方式为 jar，并设置源码和字节码版本为1.8

<?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>com.peterjxl</groupId>
    <artifactId>LearnMybatis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

</project>

‍

‍

数据库准备

我们创建一个数据库LearnMybatis，并创建如下表：

• user表，存储用户信息
• account表，存储每个用户的账号信息
• role表：存储用户的角色信息
• user_role：存储用户和角色的关联信息

然后创建数据库用户LearnMybatisUser​，配置密码为LearnMybatisUserPassword​。

SQL文件已存放在项目在中：src\main\resources\MybatisDB_init.sql。内容如下：

create database LearnMybatis;
use LearnMybatis;

CREATE USER IF NOT EXISTS LearnMybatisUser@'%' IDENTIFIED BY 'LearnMybatisUserPassword';
GRANT ALL PRIVILEGES ON learnmybatis.* TO LearnMybatisUser@'%' WITH GRANT OPTION;
FLUSH PRIVILEGES;

CREATE TABLE `user` (
  `id` int(11) NOT NULL auto_increment,
  `username` varchar(32) NOT NULL COMMENT '用户名称',
  `birthday` datetime default NULL COMMENT '生日',
  `sex` char(1) default NULL COMMENT '性别',
  `address` varchar(256) default NULL COMMENT '地址',
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert  into `user`(`id`,`username`,`birthday`,`sex`,`address`) values 
(41,'张三','2018-02-27 17:47:08','男','北京'),
(42,'李四','2018-03-02 15:09:37','女','北京'),
(43,'王五','2018-03-04 11:34:34','女','北京'),
(45,'赵六','2018-03-04 12:04:06','男','北京'),
(46,'小七','2018-03-07 17:37:26','男','北京'),
(48,'老八','2018-03-08 11:44:00','男','北京');


CREATE TABLE `account` (
  `ID` int(11) NOT NULL COMMENT '编号',
  `UID` int(11) default NULL COMMENT '用户编号',
  `MONEY` double default NULL COMMENT '金额',
  PRIMARY KEY  (`ID`),
  KEY `FK_Reference_8` (`UID`),
  CONSTRAINT `FK_Reference_8` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;


insert  into `account`(`ID`,`UID`,`MONEY`) values (1,46,1000),(2,45,1000),(3,46,2000);



CREATE TABLE `role` (
  `ID` int(11) NOT NULL COMMENT '编号',
  `ROLE_NAME` varchar(30) default NULL COMMENT '角色名称',
  `ROLE_DESC` varchar(60) default NULL COMMENT '角色描述',
  PRIMARY KEY  (`ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert  into `role`(`ID`,`ROLE_NAME`,`ROLE_DESC`) values (1,'院长','管理整个学院'),(2,'总裁','管理整个公司'),(3,'校长','管理整个学校');




CREATE TABLE `user_role` (
  `UID` int(11) NOT NULL COMMENT '用户编号',
  `RID` int(11) NOT NULL COMMENT '角色编号',
  PRIMARY KEY  (`UID`,`RID`),
  KEY `FK_Reference_10` (`RID`),
  CONSTRAINT `FK_Reference_10` FOREIGN KEY (`RID`) REFERENCES `role` (`ID`),
  CONSTRAINT `FK_Reference_9` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert  into `user_role`(`UID`,`RID`) values (41,1),(45,1),(41,2);

‍

导入依赖

接下来，我们就要导入Mybatis框架所用到的依赖了：

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

注：可以通过Mybatis官网 (opens new window)查看最新的版本

‍

‍

Mybatis只是对JDBC的封装，因此我们还需JDBC的依赖；这里顺便将Log4j 和 Junit的依赖都引入：

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.6</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.27</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
</dependencies>

‍

创建实体类

package com.peterjxl.domain;

import java.io.Serializable;
import java.util.Date;

public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
}

‍

然后创建 getter 、setter和toString方法，这里不演示了

‍

‍

创建Dao的接口

package com.peterjxl.dao;

import com.peterjxl.domain.User;
import java.util.List;

public interface IUserDao {

    /**
     * 查询所有用户
     * @return
     */
    List<User> findAll();
}

‍

新建Mybatis配置文件

我们在resources目录下，新建SqlMapConfig.xml，作为Mybatis的文件。其实Mybatis对配置文件名并没做要求，可自行修改。

然后我们引入约束DTD文件，并创建根元素<configuration>​：

<?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>
  
</configuration>

‍

配置数据源

然后我们就可以配置数据库连接信息了：

<?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">

<!-- Mybatis的主配置文件 -->
<configuration>
  
    <!--配置环境-->
    <environments default="mysql">
        <environment id="mysql">
            <!-- 配置事务的类型 -->
            <transactionManager type="JDBC"/>

            <!-- 配置数据源（连接池） -->
            <dataSource type="POOLED">
                <!-- 配置连接数据库的4个基本信息 -->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///LearnMybatis"/>
                <property name="username" value="LearnMybatisUser"/>
                <property name="password" value="LearnMybatisUserPassword"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

‍

​<environments>​标签里可以配置多个数据源，default则是指定默认的数据源是哪个；

​<environment>​标签里则是一个数据源的相关信息，id则是表明该数据源的标识符，然后可以配置连接信息

‍

‍

配置映射文件

之前我们说过可以通过配置，完成实体类到数据库表的映射，这也算通过XML配置文件来实现的。

我们可以在Mybatis的配置文件里指定映射文件（mapper）的路径：

<?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">

<!-- Mybatis的主配置文件 -->
<configuration>
    <!-- 省略其他信息...... -->

    <mappers>
        <mapper resource="com/peterjxl/dao/IUserDao.xml"/>
    </mappers>
</configuration>

‍

这里取名为IUserDao.xml，是为了和之前的三层架构里提到的DAO层保持一致，在有的项目中，映射文件也叫Mapper：IUserMapper.xml。

‍

‍

然后我们在resources目录里创建对应的文件夹和文件：

​

注意是三级目录结构，映射配置文件所在的目录结构，必须和dao接口的包结构相同。由于resources里的文件编译后会放到claesses目录下，因此最后该配置文件是和字节码文件同一个路径的，例如这是我打包后的文件结构：

‍

‍

引入mapper的约束，和创建根元素<mapper>​：

<?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.peterjxl.dao.IUserDao">
  
</mapper>

namespace属性的值，得是接口的全类名。

‍

然后我们就可以设置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.peterjxl.dao.IUserDao">
    <!-- 配置查询所有用户，id要写方法名称-->
    <select id="findAll" resultType="com.peterjxl.domain.User">
        select * from user
    </select>
</mapper>

这里配置了一个select标签，表明是查询的SQL，id的属性值是接口的方法名；并且设置查询出来的结果集，是和User类型做映射。

‍

‍

小结

注意事项：

1. 映射配置文件所在的目录结构，必须和dao接口的包结构相同。
2. 映射配置文件中，namespace属性的值，必须得是dao接口的全限定类名
3. 映射配置文件中，id属性的取指必须是dao接口的方法名

当我们做到上述要求后，我们就不用再写dao实现类了！剩下的事情就交给Mybatis完成。其原理就是创建代理对象，我们在讲解Servlet的时候有简单讲解过

‍

‍

新建日志配置文件

我们在resources文件夹里新建log4j.properties文件：

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

‍

创建测试类

我们在测试类里，完成对Mybatis的入门案例，步骤如下：

1. 读取配置文件
2. 创建SqlSessionFactory工厂
3. 使用工厂生成SqlSession对象
4. 使用SqlSession 创建Dao接口的代理对象
5. 使用代理对象执行方法
6. 释放资源

‍

package com.peterjxl.test;

import com.peterjxl.dao.IUserDao;
import com.peterjxl.domain.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.Test;

import java.io.InputStream;
import java.util.List;

public class MybatisTest {

    @Test
    public void helloMybatis() throws Exception{
        // 1. 读取配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");

        // 2. 创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);

        // 3. 使用工厂生成SqlSession对象
        SqlSession session = factory.openSession();

        // 4. 使用SqlSession创建Dao接口的代理对象
        IUserDao userDao = session.getMapper(IUserDao.class);

        // 5. 使用代理对象执行方法
        List<User> users = userDao.findAll();
        for(User user : users){
            System.out.println(user);
        }

        // 6. 释放资源
        session.close();
        in.close();
    }

}

‍

运行结果：

User{id=41, username='张三', birthday=Tue Feb 27 17:47:08 CST 2018, sex='男', address='北京'}
User{id=42, username='李四', birthday=Fri Mar 02 15:09:37 CST 2018, sex='女', address='北京'}
User{id=43, username='王五', birthday=Sun Mar 04 11:34:34 CST 2018, sex='女', address='北京'}
User{id=45, username='赵六', birthday=Sun Mar 04 12:04:06 CST 2018, sex='男', address='北京'}
User{id=46, username='小七', birthday=Wed Mar 07 17:37:26 CST 2018, sex='男', address='北京'}
User{id=48, username='老八', birthday=Thu Mar 08 11:44:00 CST 2018, sex='男', address='北京'}

‍

‍

测试类解读

我们来解读下测试类的代码。

首先是读取配置文件：

//1.读取配置文件
InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");

一般不用绝对路径 或者 相对路径。而是使用以下两种：

1. 使用类加载器。它只能读取类路径的配置文件
2. 使用ServletContext对象的getRealPath()​方法

‍

然后是创建工厂：

//2.创建SqlSessionFactory工厂
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(in);

Mybatis使用了构建者模式。

什么是构建者模式：工厂不是我们自己创建的，而是用 SqlSessionFactoryBuilder​。如果自己创建工厂类，费时费力。

举个生活中的例子，假设我们要创建一个工厂，那么首先要选址，买建筑材料，预估人工等，什么都要自己做；而我们可以买现成的建好的工厂，或者找一个包工队，让包工队帮我们干活。我们想要创建工厂类，无需自己构造工厂，只需交给SqlSessionFactoryBuilder即可。

‍

‍

生成SqlSesion对象，则使用了工厂模式。使用工厂模式的好处：解耦，降低类之间的依赖关系

//3.使用工厂生产SqlSession对象
SqlSession session = factory.openSession();

‍

创建Dao接口实现类使用了代理模式。 优势：不修改源码的基础上对已有方法增强

// 4. 使用SqlSession创建Dao接口的代理对象
IUserDao userDao = session.getMapper(IUserDao.class);

//5.使用代理对象执行方法
List<User> users = userDao.findAll();
for(User user : users){
    System.out.println(user);
}

//6.释放资源
session.close();
in.close();

‍

可以看到，使用了Mybatis也有很多的步骤，要读配置文件，创建工厂，创建Session.... 这是Mybatis出于灵活，才这样设计的，我们可以简化为一行代码：

//1.读取配置文件
InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
SqlSession session  =  new SqlSessionFactoryBuilder().build(in).openSession();
  
//4.使用SqlSession创建Dao接口的代理对象
IUserDao userDao = session.getMapper(IUserDao.class);
  
//5.使用代理对象执行方法
List<User> users = userDao.findAll();
for(User user : users){
    System.out.println(user);
}

//6.释放资源
session.close();
in.close();

‍

总结

本文使用Mybatis做了一个简单的查询，步骤如下；

1. 读取配置文件
2. 创建SqlSessionFactory工厂
3. 使用工厂生成SqlSession对象
4. 使用SqlSession 创建Dao接口的代理对象
5. 使用代理对象执行方法
6. 释放资源

虽然步骤看上去还是挺复杂，但后续使用注解后，会变的很简单，敬请期待。

本文所有代码已上传到了GitHub (opens new window)和Gitee (opens new window)上，并且创建了分支demo1，读者可以通过切换分支来查看本文的示例代码。

‍