@nextleaf 2018-07-18T18:58:23.000000Z 字数 11025 阅读 657

【1】MyBatis框架及入门

MyBatis 持久层

mybatis的执行流程

mybatis框架是一个持久层框架。mybatis可以让开发者的主要精力放在sql上，通过mybatis提供的映射方式，自由灵活的生成满足需要的sql语句。MyBatis可以将向preparedStatement中的输入参数自动进行输入映射，将查询结果集灵活映射成java对象（输出映射）。下面在整体上把握一下mybatis框架，总结一下mybatis的执行流程。
从图中可以看出，mybatis中首先要在配置文件中配置一些东西，然后根据这些配置去创建一个会话工厂，再根据会话工厂创建会话，会话发出操作数据库的sql语句，然后通过执行器操作数据，再使用mappedStatement对数据进行封装。这就是整个mybatis框架的执行情况。

入门mybatis

1、mybatis环境准备

mybatis运行环境

mybatis运行环境主要是指mybatis的jar包，mybatis已经将它的各个版本托管到github上了，大家可以去github上下载。
mybatis的jar包包括一个核心包和几个依赖包，我们全部导入到工程中即可。然后就是mysql的驱动包，也要导入到工程中总共需要导入的jar包
如果时候maven工程，需要引入MyBatis依赖

<!--mybatis依赖 -->  
<dependency>  
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
</dependency>
<!-- mybatis/spring包 -->
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.2</version>
</dependency>
<!-- mysql驱动包 -->
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.11</version>
</dependency>

log4j配置文件

从上面的jar包中可以看出，mybatis的依赖包中有很多日志包，既然mybatis依赖log4j，那我们首先要建立一个log4j.properties文件，这个可以在官方的文件中拷贝下，如下：

# Global logging configuration
# developer-->DEBUG  productor-->INFO or ERROR
log4j.rootLogger=DEBUG, stdout
# MyBatis logging configuration...
log4j.logger.org.mybatis.example.BlogMapper=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

全局配置文件

mybatis需要配置一个全局配置文件SqlMapConfig.xml，这个文件是用来配置mybatis的运行环境，即数据源、事务等。我们也可以从官方的例子中拷贝一份，然后做一下修改：

<?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>
    <!-- 和Spring整合后environment配置都会被干掉 -->
    <environments default="development">
        <environment id="development">
            <!-- 使用jdbc事务管理，目前由mybatis来管理 -->
            <transactionManager type="JDBC" />
            <!-- 数据库连接池，目前由mybatis来管理 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="sqlmap/User.xml" />
    </mappers>
</configuration>

以上这些环境配置（标签中的内容在以后和Spring整合后，都会交给Spring来管理，现在暂时交给 mybatis来管理）中，修改成自己数据库相对应的情况即可，标签用来配置映射文件的，这些映射文件是针对不同的pojo的，这个示例中只操作一个User对象，所以只有一个配置文件，在sqlmap目录下的User.xml，在下文中可以看到。最后来看一下整个环境的结构：

接下来就开始开发示例程序了

编写程序

首先我们得有一个pojo，在mybatis.po包中新建一个User.java类

package com.vo;
import java.util.Date;
public class User {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    public User(String username, Date birthday, String sex, String address) {
        this.username = username;
        this.birthday = birthday;
        this.sex = sex;
        this.address = address;
    }
    public User(Integer id, String username, Date birthday, String sex, String address) {
        this.id = id;
        this.username = username;
        this.birthday = birthday;
        this.sex = sex;
        this.address = address;
    }
    public User() {}
    public Integer getId() {return id;}
    public String getUsername() {return username;}
    public Date getBirthday() {return birthday;}
    public String getSex() {return sex;}
    public String getAddress() {return address;}
    public void setId(Integer id) {this.id = id;}
    public void setUsername(String username) {this.username = username;}
    public void setBirthday(Date birthday) {this.birthday = birthday;}
    public void setSex(String sex) {this.sex = sex;}
    public void setAddress(String address) {this.address = address;}
}

对应数据库建表语句

use mybatis
drop table if exists user;
create table user
(
    id int primary key not null auto_increment,
    username varchar(40),
    birthday date,
    sex char(1),
    address varchar(255)
);
insert into user(username,birthday,sex,address) values("倪升武","1990-09-19","男","同济大学");
insert into user(username,birthday,sex,address) values("张三2","1990-09-19","男","同济大学");
/*自己多加几个*/

根据用户id查询用户信息

首先得创建配置文件User.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="test">
    <!-- 需求：通过id查询用户 -->
    <select id="findUserById" parameterType="int" resultType="mybatis.po.User">
        select * from user where id = #{id}
    </select>
</mapper>

来简单解释下该配置文件中一些参数的作用：

<select>标签：用于执行数据库查询的，所有关于查询的都使用该标签。
id属性：标识映射文件中的sql，将sql语句封装到mappedStatement对象中，即statement的id，下面执行数据库的时候需要用到这个id。
#{}：表示一个占位符，用来接收输入参数的。
#{id}：id标识接收输入的参数，参数名称就是id，如果输入参数是简单类型，那么#{}中的参数名可以任意，可以value或者其他名称。
parameterType：指定输入参数的类型，这个要和数据库中的保持一致。
resultType：指定输出结果的类型，即查询结果所映射的java对象。

有了User.xml配置文件后，需要在全局配置文件SqlMapConfig.xml中添加这个映射，上面已经添加过了，即：

<mappers>
    <mapper resource="sqlmap/User.xml" />
</mappers>

接下来就是写测试类:

import java.io.IOException;
import java.io.InputStream;
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 com.vo.User;
public class MybatisFirst {
    //因为接下来的测试代码中，获取sqlSession这部分都相同，所以抽取成一个方法
    public SqlSession getSession() throws IOException {
        String resource = "SqlMapConfig.xml"; //mybatis配置文件
        //得到配置文件的流
        InputStream inputStream = Resources.getResourceAsStream(resource);
        //创建会话工厂SqlSessionFactory,要传入mybaits的配置文件的流
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //通过工厂得到SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        return sqlSession;
    }
    //根据id查询用户的信息，得到一条记录的结果
    @Test
    public void findUserById() throws IOException {
        SqlSession sqlSession = getSession(); //调用上面的方法获取sqlSession
        //通过SqlSession操作数据库
        //第一个参数：映射文件中statement的id，= namespace + statement的id
        //第二个参数：指定和映射文件中所匹配的parameterType类型的参数
        //selectOne表示查询出一条记录进行映射
        User user = sqlSession.selectOne("test.findUserById", 1);
        System.out.println(user);
        //释放资源，最好放在finally中，这里只是测试程序，就不弄了
        sqlSession.close();
    }
}

mybatis有个特点，就是要执行什么语句，都写在配置文件中，需要传入或者输出什么参数类型也写在配置文件中，在java中只要对应那个配置传入我们想要的参数或者接受输出参数即可

根据用户名称模糊查询用户信息

使用mybatis开发，流程都一样，先在User.xml中添加配置：

<mapper namespace="test">   
    <!-- 省略其他 -->
    <!-- 根据用户名称模糊查询用户信息，可能返回多条 -->
    <select id="findUserByName" parameterType="java.lang.String" resultType="mybatis.po.User">
        select * from user where username like '%${value}%'
    </select>
</mapper>

resultType：这里虽然是查询多条记录，但是resultType指定的就是单条记录所映射的java对象类型。
${}：表示拼接sql串，将接收到的参数的内容不加任何的修饰拼接在sql中,${}中只能使用value，但是使用${}来拼接sql，可能会引起sql注入，所以不建议使用这种方法。

这里使用${}来拼接sql是为了后面java程序中直接输入方便（比如我模糊查询“张三”，就不用输入“%张三%”了），但是有sql注入的隐患。如果安全一点，还是使用#{}来接收参数，不过此时的话，java程序中输入参数就得是“%张三%”了。下面看下java程序：

package test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
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 com.vo.User;
public class MybatisFirst {
    //因为接下来的测试代码中，获取sqlSession这部分都相同，所以抽取成一个方法
    public SqlSession getSession() throws IOException {
        String resource = "SqlMapConfig.xml"; //mybatis配置文件
        //得到配置文件的流
        InputStream inputStream = Resources.getResourceAsStream(resource);
        //创建会话工厂SqlSessionFactory,要传入mybaits的配置文件的流
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //通过工厂得到SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        return sqlSession;
    }
    //省略不相关代码
        //根据用户名称模糊查询用户列表
        @Test
        public void findUserByName() throws IOException {
            SqlSession sqlSession = getSession();
            //selectList表示查询出一个列表（多条记录）进行映射
            List<User> list = sqlSession.selectList("test.findUserByName", "张三");
            System.out.println(list);
            //释放资源，最好放在finally中，这里只是测试程序，就不弄了
            sqlSession.close();
        }
}

添加用户

首先完成添加用户的配置文件：

<mapper namespace="test">
    <!-- 省略不相关配置 -->
    <!-- 添加用户 -->
    <insert id="insertUser" parameterType="mybatis.po.User">
        insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
        <!-- 将插入数据的主键返回，返回到user对象中 -->
        <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
            select last_insert_id()
        </selectKey>
        <!-- 
        <selectKey keyProperty="id" order="BEFORE" resultType="java.lang.String">
            select uuid()
        </selectKey>
         -->
    </insert>
</mapper>

<insert>标签：用于执行数据库查询的，所有关于查询的都使用该标签。
parameterType：要传入一个具体的pojo（包括用户信息）
#{}中指定pojo的属性名，接收到pojo对象的属性值，mybatis通过OGNL获取对象的属性值。
<selectKey>标签：用来返回插入数据的主键的，实际中如果有获得主键的需要就可以使用它。
select last_insert_id()：是sql函数，表示得到刚刚insert进去记录的主键值，只适用于自增主键。
keyProperty：表示将查询到主键值设置到上面parameterType指定的对象的哪个属性。
order：表示select last_insert_id()的执行顺序，是相对于insert语句来说的。
resultType：表示select last_insert_id()的结果类型。

添加用户的java代码：

package test;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
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 com.vo.User;
public class MybatisFirst {
    //因为接下来的测试代码中，获取sqlSession这部分都相同，所以抽取成一个方法
    public SqlSession getSession() throws IOException {
        String resource = "SqlMapConfig.xml"; //mybatis配置文件
        //得到配置文件的流
        InputStream inputStream = Resources.getResourceAsStream(resource);
        //创建会话工厂SqlSessionFactory,要传入mybaits的配置文件的流
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //通过工厂得到SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        return sqlSession;
    }
    //省略不相关代码
    //添加用户信息
        @Test
        public void insertUser() throws IOException {
            SqlSession sqlSession = getSession();
            User user = new User("倪升武", new Date(), "男", "同济大学");
            sqlSession.insert("test.insertUser", user); //添加一项
            //提交事务
            sqlSession.commit();
            System.out.println(user.getId()); //获取刚刚添加的id
            //释放资源，最好放在finally中，这里只是测试程序，就不弄了
            sqlSession.close();
        }
}

更新用户和删除用户

<mapper namespace="test">
    <!-- 省略不相关配置 -->
    <!-- 删除用户 -->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id=#{id}
    </delete>
    <!-- 更新用户 -->
    <update id="updateUser" parameterType="mybatis.po.User">
        update user set username=#{username},birthday=#{birthday},sex=#{sex},address=#{address} where id=#{id}
    </update>
</mapper>

package test;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
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 com.vo.User;
public class MybatisFirst {
    //因为接下来的测试代码中，获取sqlSession这部分都相同，所以抽取成一个方法
    public SqlSession getSession() throws IOException {
        String resource = "SqlMapConfig.xml"; //mybatis配置文件
        //得到配置文件的流
        InputStream inputStream = Resources.getResourceAsStream(resource);
        //创建会话工厂SqlSessionFactory,要传入mybaits的配置文件的流
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //通过工厂得到SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        return sqlSession;
    }
    //省略不相关代码
    //删除用户信息
        @Test
        public void deleteUser() throws IOException {
            SqlSession sqlSession = getSession();
            //传入id，删除用户
            sqlSession.delete("test.deleteUser", 16);
            //提交事务
            sqlSession.commit();
            //释放资源，最好放在finally中，这里只是测试程序，就不弄了
            sqlSession.close();
        }
        //更新用户信息
        @Test
        public void updateUser() throws IOException {
            SqlSession sqlSession = getSession();
            User user = new User("倪升武", new Date(), "男", "同济大学");
            user.setId(9);
            //更新用户
            sqlSession.update("test.updateUser", user);
            //提交事务
            sqlSession.commit();
            //释放资源，最好放在finally中，这里只是测试程序，就不弄了
            sqlSession.close();
        }
}

到这里mybatis的入门程序就写完了，从上面的程序来看，mybatis的基本操作还是挺简便的。主要要搞清楚mybatis的一个执行流程就比较好理解了。入门就总结这么多吧

作者：倪升武（联系作者）
发表时间：2017-06-09 13:40
版权声明：自由转载-非商用-非衍生-保持署名，转载请注明出处