一、简介

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

二、持久层技术解决方案

JDBC技术

- Connection
- PreparedStatement
- ResultSet

Spring中的JdbcTemplate
Apache的DbUtils

以上这些都不是框架，JDBC是规范、Spring的JdbcTemplage和Apache的Dbutils是工具类。

三、Mybatis的入门案例

1、Mybatis的环境准备

mysql数据源

-- 创建user表
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 AUTO_INCREMENT=4 DEFAULT CHARSET=utf8

-- 插入数据
INSERT INTO USER (
    username,
    birthday,
    sex,
    address
)
VALUES
    (
        'littlep',
        NOW(),
        '女',
        '山西运城'
    ),
    (
        '小2p',
        NOW(),
        '男',
        '中国'
    );

创建Maven工程，引入依赖

<?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.seapp</groupId>
    <artifactId>day01_seapp_mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--指定打包方式-->
    <packaging>jar</packaging>

    <dependencies>
        <!-- mybatis依赖包        -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.3</version>
        </dependency>
        <!--数据连接驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

    </dependencies>
</project>

创建实体类

package com.seapp.mybatis.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 address;

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Date getBirthday() {
        return birthday;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "user{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", address='" + address + '\'' +
                '}';
    }
}

创建IUserDao.java类，实现查询所有的方法

package com.seapp.mybatis.dao;

import com.seapp.mybatis.domain.User;

import java.util.List;

/**
 * @author seapp
 * @date 2020/7/22 23:20
 */
public interface IUserDao {
    /**
     * 查询所有人员数据
     * @return
     */
    List<User> findAll();

}

创建IUserDao.xml 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.seapp.mybatis.dao.IUserDao">
    <!--查询所有-->
    <select id="findAll" resultType="com.seapp.mybatis.domain.User">
        select * from user;
    </select>

</mapper>

SqlMapConfig.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>
<!-- 配置环境   -->
    <environments default="mysql">
        <!--配置mysql环境-->
        <environment id="mysql">
            <!--配置事务类型 -->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源（连接池）-->
            <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>

    <!-- 指定映射文件的位置，映射配置文件指的是每个dao独立的配置文件-->
    <mappers>
        <mapper resource="com/seapp/mybatis/dao/IUserDao.xml" />
    </mappers>
</configuration>

2.注意事项

创建IUserDao.java和IUserDao.xml 名称是为了保持一致。在Mybatis中它把持久层的操作接口名称和映射文件也叫做Mapper，所以IUserDao和IUserMapper是一样的。
在Idea中的resource中包的创建和目录的创建时不一样的。
- 包的创建：com.seapp.mybatis 是三级目录。
-目录的创建：com.seapp.mybatis是一级目录。
mybatis的映射文件必须与dao接口的包结构一致。
映射文件的mapper标签namespace属性的取值必须是dao接口的全限定类名。
映射配置文件的操作配置（select），id属性的取值必须是dao接口中的方法名。
log4j.properties的设置

### 设置###
log4j.rootLogger = debug,stdout,D,E

### 输出信息到控制抬 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n

### 输出DEBUG 级别以上的日志到=E://logs/error.log ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = D://logs/log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG 
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

### 输出ERROR 级别以上的日志到=E://logs/error.log ###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File =D://logs/error.log 
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR 
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

3. 测试类的实现

package com.seapp.mybatis;

import com.seapp.mybatis.dao.IUserDao;
import com.seapp.mybatis.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 java.io.IOException;
import java.io.InputStream;
import java.util.List;

/**
 * @author seapp
 * @date 2020/7/23 22:28
 * mybatis入门测试类
 */
public class MyBatisTest {

    /**
     * 入门案例
     * @param args
     */
    public static void main(String[] args) throws IOException {
        //1.加载配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3.通过工厂获取Sqlsession对象
        SqlSession sqlSession = factory.openSession();
        //4.通过SqlSession对象获取IUserDao代理实现类
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
        //5.调用接口方法获取人员数据
        List<User> userList = userDao.findAll();
        for (User user :
                userList) {
            System.out.println("user = " + user);
        }
        //6.关闭资源
        sqlSession.close();
        in.close();
    }

}

实验结果

三、mybatis以注解形式实现入门案例

1.IUserDao注解实现

package com.seapp.mybatis.dao;

import com.seapp.mybatis.domain.User;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * @author seapp
 * @date 2020/7/22 23:20
 */
public interface IUserDao {
    /**
     * 查询所有人员数据
     * @return
     */
    @Select("select * from user")
    List<User> findAll();

}

2.SqlMapConfig配置的修改

<?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>
<!-- 配置环境   -->
    <environments default="mysql">
        <!--配置mysql环境-->
        <environment id="mysql">
            <!--配置事务类型 -->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源（连接池）-->
            <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>

    <!-- 指定映射文件的位置，映射配置文件指的是每个dao独立的配置文件-->
    <!-- 若使用注解配置的话，mapper配置属性应为class,值为被注解的dao的全限定类名-->
    <mappers>
<!--        <mapper resource="com/seapp/mybatis/dao/IUserDao.xml" />-->
        <mapper class="com.seapp.mybatis.dao.IUserDao"/>
    </mappers>
</configuration>

四、mybatis的CRUD

1.IUserDao接口实现

package com.seapp.dao;

import com.seapp.domain.User;

import java.util.List;

/**
 * @author seapp
 * @date 2020/7/25 22:11
 */
public interface IUserDao {

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

    /**
     * 插入人员信息
     * @param user
     */
    void insertUser(User user);


    /**
     * 执行更新操作
     * @param user
     */
    void updateUser(User user);

    /**
     * 删除指定人员
     * @param id
     */
    void deleteUser(Integer id);

    /**
     * 根据id查询用户
     * @param id
     * @return
     */
    User findById(Integer id);


    /**
     * 根据人员名称进行模糊查询
     * @param username
     * @return
     */
    List<User> findByUserName(String username);

}

2. IUserDao.xml（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.seapp.dao.IUserDao">
    <!--查询所有-->
    <select id="findAll" resultType="com.seapp.domain.User">
        select * from user ;
    </select>

    <insert id="insertUser" parameterType="com.seapp.domain.User">
        INSERT INTO user (username,birthday,sex,address) values (#{username},#{birthday},#{sex},#{address})
    </insert>

    <update id="updateUser" parameterType="com.seapp.domain.User">

        UPDATE user
        SET username = #{username},
         birthday = #{birthday},
         sex = #{sex},
         address = #{address}
        WHERE
            id = #{id};

    </update>


    <delete id="deleteUser" parameterType="java.lang.Integer">
        DELETE
        FROM
            user
        WHERE
            id = #{uid};
    </delete>


    <select id="findById" parameterType="int" resultType="com.seapp.domain.User">
        select *
        from user
        where
            id = #{uid};
    </select>


    <select id="findByUserName" parameterType="String" resultType="com.seapp.domain.User">
        SELECT
            *
        FROM
            USER
        WHERE
            username LIKE #{name};
    </select>
</mapper>

3. 测试类实现

package com.seapp.dao;

import com.seapp.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.After;
import org.junit.Before;
import org.junit.Test;

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

/**
 * @author seapp
 * @date 2020/7/25 22:14
 */
public class UserTest {

    InputStream in;
    SqlSession sqlSession;

    /**
     * 测试前环境准备
     */
    @Before
    public void before() throws IOException {
        //1.加载配置文件SqlMapConfig
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.通过构建器获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取Session对象
        sqlSession = factory.openSession();
    }

    /**
     * 测试完成后资源释放
     */
    @After
    public void after() throws IOException {
        //事务提交
        sqlSession.commit();
        if (sqlSession != null) {
            sqlSession.close();
        }
        if (in != null) {
            in.close();
        }
    }

    /**
     * 测试插入方法
     */
    @Test
    public void testInsert() {
        User user = new User();
        user.setUsername("王小2p");
        user.setBirthday(new Date());
        user.setSex("男");
        user.setAddress("中国");
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
        userDao.insertUser(user);
    }


    @Test
    public void updateUserTest() {
        User user = new User();
        user.setId(7);
        user.setUsername("王2p");
        user.setBirthday(new Date());
        user.setSex("男");
        user.setAddress("中国");
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
        userDao.updateUser(user);
    }


    @Test
    public void deleteUser() {
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
        userDao.deleteUser(9);
    }

    /**
     * 根据id获取用户信息
     */
    @Test
    public void findByIdTest() {
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
        User user = userDao.findById(2);
        System.out.println("user = " + user);
    }

    /**
     * 根据用户名模糊查询
     */
    @Test
    public void findByUserName(){
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
        List<User> userList= userDao.findByUserName("%王%");
        for (User user : userList) {
            System.out.println("user = " + user);
        }
    }


    public static void main(String[] args) throws IOException {
        //1.加载配置文件SqlMapConfig
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.通过构建器获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取Session对象
        SqlSession sqlSession = factory.openSession();
        //4.通过sqlSession对象获取UserDao的代理对象
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
        //5.执行查询方法
        List<User> userList = userDao.findAll();
        //6.执行循环遍历
        for (User user : userList) {
            System.out.println("user = " + user);
        }
        //关闭资源
        sqlSession.close();
        in.close();

    }

}

4. 问题拓展：获取现在用户的id

 <insert id="insertUser" parameterType="com.seapp.domain.User">
        -- keyproperty：要返回的值名称
        -- order:取值after，代表插入后再执行
        -- resultType:代表返回值类型
        <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
            select last_insert_id();
        </selectKey>


        INSERT INTO user (username,birthday,sex,address)
        values (#{username},#{birthday},#{sex},#{address});
    </insert>

5.问题拓展：parameterType(输入类型)

传递简单类型
传递pojo对象
Mybatis 使用ognl表达式解析对象字段的值，#{}或者${}括号中的值为pojo属性名称。
传递pojo包装对象
通过pojo传递查询条件，查询条件是综合查询条件，这时可以通过包装对象传递输入参数。

package com.seapp.domain;

/**
 * 拓展类的封装
 * @author seapp
 * @date 2020/7/26 9:20
 */
public class QueryVo {

    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}


   /** 接口实现
     * 根据拓展类型实现查询
     * @param vo
     * @return
     */
    List<User> findByUser(QueryVo vo);

<select id="findByUser" parameterType="com.seapp.domain.QueryVo" resultType="com.seapp.domain.User">
        SELECT
            *
        FROM
            USER
        WHERE
            username LIKE #{user.username};
    </select>

       /** 测试类
         * 根据用户名模糊查询
         */
        @Test
        public void findByUserVo(){
            IUserDao userDao = sqlSession.getMapper(IUserDao.class);
            QueryVo queryVo = new QueryVo();
            User user1 = new User();
            user1.setUsername("%王%");
            queryVo.setUser(user1);
            List<User> userList= userDao.findByUser(queryVo);
            for (User user : userList) {
                System.out.println("user = " + user);
            }
        }

6.问题拓展：resultType结果类型的封装

输出简单对象
输出pojo类型
输出pojo列表
resultType可以指定pojo将查询结果映射为pojo,但需要pojo的属性名和sql查询的列名一致方可映射。
如果sql查询字段名和pojo的属性名不一致，可以通过resultMap将字段名和属性名做一个对应关系。resultMap实质上还需要将查询结构映射到pojo对象中。

@ 解决实体类属性与数据量列名不对应的两种方式：

通过AS取别名的方式：

 <!--查询所有-->
    <select id="findAll" resultType="com.seapp.domain.User">
--         select * from user ;
        SELECT
            id AS userId,
            username AS userName,
            birthday AS userBirthday,
            sex AS userSex,
            address AS userAddress
        FROM
            user;

    </select>

resultMap的使用

 <!--实体类名与数据库列名不一致时通过resultMap来实现实体类名与列名的对应关系    -->
    <resultMap id="userMap" type="com.seapp.domain.User">
        <!--主键对应 -->
        <id property="userId" column="id"/>
        <result property="userName" column="username"/>
        <result property="userBirthday" column="birthday"/>
        <result property="userSex" column="sex"/>
        <result property="userAddress" column="address"/>
    </resultMap>


    <!--查询所有-->
    <select id="findAll" resultMap="userMap">
        select * from user ;
--         SELECT
--             id AS userId,
--             username AS userName,
--             birthday AS userBirthday,
--             sex AS userSex,
--             address AS userAddress
--         FROM
--             user;

    </select>

五、SqlMapConfig.xml配置文件详解

1. properties标签的使用及细节

<?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标签可在标签内配置属性，也可引入外部配置文件    -->
    <!-- resource:用于指定配置文件的位置。    -->
    <properties resource="jdbcConfig.properties"></properties>

<!-- 配置环境   -->
    <environments default="mysql">
        <!--配置mysql环境-->
        <environment id="mysql">
            <!--配置事务类型 -->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源（连接池）-->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 指定映射文件的位置，映射配置文件指的是每个dao独立的配置文件-->
    <!-- 若使用注解配置的话，mapper配置属性应为class,值为被注解的dao的全限定类名-->
    <mappers>
        <mapper resource="com/seapp/dao/IUserDao.xml" />
<!--        <mapper class="com.seapp.mybatis.dao.IUserDao"/>-->
    </mappers>
</configuration>

配置文件如下所示：jdbcConfig.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=UTF-8
jdbc.username=root
jdbc.password=root

2. typeAliases标签属性的使用及package标签的定义。

<?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标签可在标签内配置属性，也可引入外部配置文件    -->
    <!-- resource:用于指定配置文件的位置。    -->
    <!-- url:要求按照url的格式来写地址。
        URL:Uniform Resource Locator 统一资源定位符，可以唯一标识一个资源的位置。
            写法：
                协议      主机     端口     URI
                http://localhost:8080/mybatis/jdbcConfig

        URI:Uniform Resource Identifier 统一资源标识符，在应用中唯一定位一个资源。
        -->
    <properties resource="jdbcConfig.properties"></properties>


    
    
    <!--typeAlises 配置别名，只能配置domain中类的别名    -->
    <typeAliases>
        <!--typeAlias:用于配置别名
            type:指定的是实体类全限定类名
            alias:别名，当配置别名后，就不再区分大小写了。
        -->
        <typeAlias type="com.seapp.domain.User" alias="user"/>

        <!--用于指定要配置别名的包，当指定后，该包下的实体类都会被注册别名，
        并且类名就是别名，且不区分大小写 -->
        <package name="com.seapp.domain"/>
        
    </typeAliases>

<!-- 配置环境   -->
    <environments default="mysql">
        <!--配置mysql环境-->
        <environment id="mysql">
            <!--配置事务类型 -->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源（连接池）-->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 指定映射文件的位置，映射配置文件指的是每个dao独立的配置文件-->
    <!-- 若使用注解配置的话，mapper配置属性应为class,值为被注解的dao的全限定类名-->
    <mappers>
<!--        <mapper resource="com/seapp/dao/IUserDao.xml" />-->
<!--        <mapper class="com.seapp.mybatis.dao.IUserDao"/>-->
        <!--package标签：用于指定dao接口所在的包，当指定完成后就不需要再配置mapper标签了。 -->
        <package name="com.seapp.dao"/>
    </mappers>
</configuration>

SSM框架之Mybatis初始（一）