MyBatis学习【尚硅谷】（1）

---

一、MyBatis简介

1 .MyBatis历史

MyBatis最初是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Foundation迁移到了Google Code。随着开发团队转投Google Code旗下，iBatis3.x正式更名为MyBatis。代码于2013年11月迁移到Github
iBatis一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO）

2. MyBatis特性

（1）MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架
（2）MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集
（3）MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录
（4）MyBatis 是一个 半自动的ORM（Object Relation Mapping）框架

二、创建MyBatis

1、 创建maven工程

打包方式：jar
引入依赖，即在pom.xml文件内创建依赖

<dependencies>
	<!-- Mybatis核心 -->
	<dependency>
		<groupId>org.mybatis</groupId>
		<artifactId>mybatis</artifactId>
		<version>3.5.7</version>
	</dependency>
	<!-- junit测试 -->
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.12</version>
		<scope>test</scope>
	</dependency>
	<!-- MySQL驱动 -->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>5.1.3</version>
		</dependency>
</dependencies>

2、创建MyBatis的核心配置文件

习惯上命名为mybatis-config.xml，这个文件名仅仅只是建议，并非强制要求。将来整合Spring之后，这个配置文件可以省略，所以大家操作时可以直接复制、粘贴。 核心配置文件主要用于配置连接数据库的环境以及MyBatis的全局配置信息 核心配置文件存放的位置是src/main/resources目录下
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>

    <!--设置连接数据库的环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:8080/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入映射文件-->

    <mappers>
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>

</configuration>

url:配置的是数据库的地址；地址，账户，密码每个人可能不同。
效果图：

3、创建mapper接口

MyBatis中的mapper接口相当于以前的dao。但是区别在于，mapper仅仅是接口，我们不需要提供实现类
在sql中中创建表


创建User的实体类：

package com.huweiqi.mybatis.pojo;

public class User {
    private Integer id;
    private String username;
    private String password;
    private Integer age;
    private String sex;
    private String email;

    public User(Integer id, String username, String password, Integer age, String sex, String email) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
        this.sex = sex;
        this.email = email;
    }

    public User() {
    }

    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 String getPassword() {
        return password;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String getSex() {
        return sex;
    }

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

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

创建mapper 的接口：

public interface UserMapper {

}

4、创建MyBatis的映射文件

相关概念：ORM（Object Relationship Mapping）对象关系映射。

对象：Java的实体类对象
关系：关系型数据库
映射：二者之间的对应关系

Java概念----------> 数据库概念
类 -------------------> 表
属性 ----- ----------> 字段/列
对象----------------> 记录/行
注意文件位置

UserMapper

public interface UserMapper {
    /**
     * MyBatis面向接口编程的两个一致
     * 1、映射文件的namespace要和mapper接口的全类名一致！
     * 2、映射文件中的sql语句的id要和mapper接口中的方法名一致！
     */
    /**
     * 添加用户信息的方法
     */
    int insertUser();
}

UserMapper.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="com.huweiqi.mybatis.mapper.UserMapper">

    <insert id="insertUser">
		insert into t_user values(null,'admin','123',23,'男','12345@qq.com')
	</insert>

</mapper>

然后需要在mybaits-config.xml文件中引入映射文件

    <mappers>
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>

test文件如下所示：

@Ignore
public class MyBatisTest {
    /**
     * sqlSessionFactory默认是不自动提交事务，若需要自动提交事务
     * 可以使用sqlSessionFactory.openSession(true);
     * @throws IOException
     */
    @Test
    public void testInsertUser() throws IOException {
        //读取MyBatis的核心配置文件
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        //获取SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        //获取sqlSession，此时通过SqlSession对象所操作的sql都必须手动提交或回滚事务
//        SqlSession sqlSession = sqlSessionFactory.openSession();
        //创建SqlSession对象，此时通过SqlSession对象所操作的sql都会自动提交，设置为true的时候，就是自动提交，默认值为false为手动提交
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //通过代理模式创建UserMapper接口的代理实现类对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配元素文件，通过调用的方法名匹配映射文件中的SQL标签，并执行标签中的SQL语句
        int result = userMapper.insertUser();
        //提交事务
//        sqlSession.commit();
        System.out.println("result:" + result);
    }

}

注意！！！：MyBatis面向接口编程的两个一致

出现的部分问题如下：
1. 不支持5版本；
	解决方法：去file选项的设置选项夹中，将项目和文件结构都设置为一致。jdk1.8对应8
	带图片如下：

2. maven打包报错：Failed to execute goal org.apache.maven.plugins:maven-surefire-plugin:2.6:test，
  解决办法：如下：

见地址：
https://blog.csdn.net/qq_36598186/article/details/82864142?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165243642116781483711687%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=165243642116781483711687&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_allfirst_rank_ecpm_v1~rank_v31_ecpm-1-82864142-null-null.142^v9pc_search_result_cache,157^v4control&utm_term=Failed+to+execute+goal+org.apache.maven.plugins%3Amaven-war-plugin%3A2.2%3Awar+%28default-war%29+on+project+MyBatis_demo1%3A+Error+assembling+WAR%3A+webxml+attribute+is+required+%28or+pre-existing+WEB-INF%2Fweb.xml+if+&spm=1018.2226.3001.4187

3.代码没有编译错误运行却报错: "程序包xxx不存在"的问题

参考：https://www.cnblogs.com/chengjinsheng/p/13520787.html

其他错误，未能记得，遇到时，在做补充！

5、添加日志信息

1. 在pom.xml中加入依赖

<!-- log4j日志 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>

2. 加入log4j的配置文件
   1. log4j的配置文件名为log4j.xml，存放的位置是src/main/resources目录下
   2. 日志的级别：FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试) 从左到右打印的内容越来越详细

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration debug="true">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

6、实现修改，删除和查找功能

UserMapper接口

package com.huweiqi.mybatis.mapper;

import com.huweiqi.mybatis.pojo.User;

import java.util.List;

public interface UserMapper {
   /**
    * MyBatis面向接口编程的两个一致
    * 1、映射文件的namespace要和mapper接口的全类名一致！
    * 2、映射文件中的sql语句的id要和mapper接口中的方法名一致！
    */
   /**
    * 添加用户信息的方法
    */
   int insertUser();
   /**
    * 修改功能
    */
   int updateUser();
   /**
    * 删除功能
    */
   int deleteUser();
   /**
    * 查询功能
    * 根据id值查询用户对象
    */
   User getUserById();
   /**
    * 查询所有的用户信息
    */
   List<User> getAllUser();

}

1、修改功能

UserMapper.xml

<!--	int updateUser();-->
   <update id="updateUser">
   	update t_user set username = "张三" where id=4;
   </update>

test文件

 @Test
    /*
   更新功能
    */
    public void testUpdate() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = build.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int result = mapper.deleteUser();
        System.out.println("result:" + result);
    }

2、删除功能

UserMapper.xml

<!--    int deleteUser-->
   <delete id="deleteUser" >
   	delete from t_user where id=3;
   </delete>

test文件

 @Test
    /*
    删除功能
    */
    public void testDelete() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = build.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int result = mapper.deleteUser();
        System.out.println("result:" + result);
    }

###3、查询功能

UserMapper.xml

<!--
   	查询功能的标签必须设置resultType或者resultMap
   	resultType：设置默认的映射关系
   	resultMap：设置自定义的映射关系
-->
<!--	User getUserById();-->
   <select id="getUserById" resultType="com.huweiqi.mybatis.pojo.User">
   	select * from t_user where id=2;
   </select>
<!--	List<User> getAllUser();-->
   <select id="getAllUser" resultType="com.huweiqi.mybatis.pojo.User">
   	select * from t_user ;
   </select>

test文件

    @Test
    /*
   查询一个用户信息的功能
    */
    public void testGetUserById() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = build.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById();
        System.out.println("result:" + user);
    }

    @Test
    /*
   查询所有用户信息的功能
    */
    public void testGetAllUser() throws IOException {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = build.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> allUser = mapper.getAllUser();
        System.out.println("result:" + allUser);
    }

增删改查的核心部分就是在xml文件中写sql语句，唯一需要注意的就是在实现查找功能的时候需要去在xml文件中中这只返回值类型。

三、核心配置文件详解

核心配置文件中的标签必须按照固定的顺序(有的标签可以不写，但顺序一定不能乱)：
properties、settings、typeAliases、typeHandlers、objectFactory、objectWrapperFactory、reflectorFactory、plugins、environments、databaseIdProvider、mappers

<?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文件-->
    <properties resource="jdbc.properties"/>
<!--    设置类型别名(不区分大小写)-->
    <typeAliases>
        <!--
        typeAlias：设置某个类型的别名
        属性：
            type：设置需要设置别名的类型
            alias：设置某个类型的别名，若不再设置该属性，那么该类型拥有默认的别名，即类名不区分大小写
        -->
<!--        <typeAlias type="com.huweiqi.mybatis.pojo.User" alias="User"></typeAlias>-->
<!--        以包为单位将包下所有的类型设置默认的类型别名，即类名且不区分大小写-->
        <package name="com.huweiqi.mybatis.pojo"/>
    </typeAliases>

    <!--
    environments:配置多个连接数据库的环境
    属性：
        default：用来设置表示默认使用的环境的id；
    -->

    <environments default="development">
        <!--
         environment:用于配置某个具体的环境
         属性：
             id：表示连接数据库的环境的唯一标识，不能重复
         -->
        <environment id="development">
            <!--
            transactionManager:设置事务管理的模式
            属性：
                    type=“JDBC“/”MANAGED“
                    JDBC:表示当前环境中，执行SQL时，使用的是JDBC中原生的事务管理方式，事务的提交或回滚需要手动处理
                    MANAGED：表示被管理，例如Spring
            -->
            <transactionManager type="JDBC"/>
            <!--
              dataSource：配置数据源
              属性：
                    type:设置属于源的类型
                    type=“POOLED”;"UNPOOLED";"JNDI"
                    POOLED:表示使用数据库连接池缓存数据库连接
                    UNPOOLED：表示不使用数据库连接池
                    JNDI：表示使用上下文中更的数据源

            -->
            <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>
    <!--引入映射文件-->
    <mappers>
<!--        <mapper resource="mappers/UserMapper.xml"/>-->
        <!--
            以包围单位引入映射文件
            要求：
                1、mapper接口所在的包要和映射文件所在的包一致
                2、mapper接口要和映射文件的名字一致
        -->
        <package name="com.huweiqi.mybatis.mapper"/>
    </mappers>
    
    
</configuration>

注意事项：

1. 在引入映射文件的时候，以包为单位，需要考虑两个因素吗，在上图中已给出
   
   2.在resourse文件夹下不能用从com.huweiqi.mybatis来创建文件夹，此处创建的只是一个文件夹
   需要使用的是com/huweiqi/mybatis来创建多级别的文件夹！

五、MyBatis获取参数值的两种方式（重点）

MyBatis获取参数值的两种方式：${}和#{}
${}的本质就是字符串拼接，
#{}的本质就是占位符赋值
${}使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号；
#{}使用占位符赋值的方式拼接sql，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号

1、mapper接口方法的参数为单个的字面量类型

mapper.xml

<!--    User getUserByName(String username);-->
<select id="getUserByName" resultType="User">
    <!--select * from t_user where username = #{username}-->
    select * from t_user where username = '${username}'
</select>

test

    @Test

    /*
   查询所有用户信息的功能
    */
    public void testGetUserByName() throws IOException {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
        User user = mapper.getUserByName("admin");
        System.out.println(user);
    }

这里需要注意以下几个问题：

1. 对于参数为单个的字面量类型，可以通过${}和#{}以任意的字符串获取参数值，但是需要注意的是 ${}的单引号问题；
2. 该字符串不能为空！
3. 该字符串最好和接口传递的参数名称保持一致；

2、mapper接口的参数为多个

mapper.xml

<!--    User checkLogin(String username,String password);-->
    <select id="checkLogin" resultType="User">
        select * from t_user where username= #{arg0} and password= #{arg1}
    </select>

test

 @Test

   /*
  登录功能
   */
   public void testCheckLogin() throws IOException {
       SqlSession sqlSession = SqlSessionUtils.getSqlSession();
       ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
       User huweiqi = mapper.checkLogin("huweiqi", "123");
       System.out.println(huweiqi);
   }

在mapper.xml文件中需要注意以下几点（均以该案例为例）

1. username和password 被存放在了一个键值对中，arg0-param1；arg1-param2中；
2. 那么实际上是将多个参数保存到了map集合当中，arg为键，param为值；
3. 在写SQL语句的时候可以混着用，但最好别；
4. 同样需要注意到的是${}的单引号问题；

3、mapper接口方法的参数有多个时，可以手动将参数放到一个map集合中进行存储（即参数为map集合的时候）

mapper.xml

<!--    User checkLoginByMap(Map<String,Object> map);-->
    <select id="checkLoginByMap" resultType="User">
        select * from t_user where username= #{username} and password= #{password}
    </select>

test

   @Test

   /*
  登录功能(使用map)
   */
   public void testCheckLoginByMap() throws IOException {
       SqlSession sqlSession = SqlSessionUtils.getSqlSession();
       ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
       Map<String, Object> map = new HashMap<String, Object>();
       map.put("username","admin");
       map.put("password","123");
       User user = mapper.checkLoginByMap(map);
       System.out.println(user);
   }

这里在写sql语句的时候相当于，在#{}内部写的就是键，然后通过键，来获取值。
本质与上一中方法如出一辙；

4、mapper接口的参数是一个实体类类型的参数

mapper.xml

<!--    int insertUser(User user);-->
  <insert id="insertUser">
      insert into t_user value (null,#{username},#{password},#{age},#{sex},#{email});
  </insert>

test

   @Test

   /*
 添加员工
   */
   public void testInsertUser() throws IOException {
       SqlSession sqlSession = SqlSessionUtils.getSqlSession();
       ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
       User user = new User(null, "李四", "123", 23, "男", "456@qq.com");
       int i = mapper.insertUser(user);
       System.out.println(i);
   }

只需要通过#{}和${}以属性的方式访问属性值即可；

5、使用@Param注解来命名参数

mapper的接口文件：

User checkLoginByParam(@Param("username") String username, @Param("password") String password);

本质上还是保存到了一个map集合当中：
@Param中的字符串就是map集合当中的键，而后面的字符串就是值；本质上还是构建了一个map数组
mapper .xml

<!--    User checkLoginByParam(@Param("username") String username, @Param("password") String password);-->
    <select id="checkLoginByParam" resultType="User">
        select * from t_user where username= #{username} and password= #{password}
    </select>

此时的SQL语句当中的#{}内容不可以为随意的字符串，其实只要是涉及到map集合就必须得是键。但是考虑到多参数的情况下，由mybatis自己封装成map集合，键值一样，所以才可以混着用。

六、MyBatis的查询功能

1、查询一个实体类对象或查询一个List集合

mapper的接口文件

  /**
     * 根据id查询用户信息
     */
    User getUserById(@Param("id")Integer id);
    /**
     * 查询所有的用户信息
     */
    List<User> getAllUserById();

mapper.xml文件

<!--    User getUserById(@Param("id")Integer id);-->
<select id="getUserById" resultType="User">
    select * from t_user where id=#{id}
</select>
<!--    List<User> getAllUserById();-->
    <select id="getAllUserById" resultType="User">
        select * from t_user
    </select>

test

  @Test
    public void testGetUserById(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        User userById = mapper.getUserById(4);
        System.out.println(userById);
    }

    /**
     * 查询所有的用户信息
     */
    @Test
    public void testGetAllUserById(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        List<User> allUserById = mapper.getAllUserById();
        System.out.println(allUserById);
    }

需要注意的是：
1、若查询出来的数据只有一条，可以通过实体类对象或者集合接受
2、若查询出来的数据有多条，那一定不能使用实体类对象接受异常；只能以List集合来接收

2、查询单个数据

mapper的接口文件

     /**
     * 查询用户信息的总记录数
     */
    int getCount();

mapper.xml文件

    <!--    int getCount();-->
    <select id="getCount" resultType="java.lang.Integer">
        select count(*) from t_user
    </select>

test

  /**
     * 查询所有的用户信息的条数
     */
    @Test
    public void testGetCount(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        int count = mapper.getCount();
        System.out.println(count);
    }

    }

MyBatis中设置了默认的类型别名：
java.lang.Integer----->int，integer
int ---->_int ,_integer
Map---->map
String—>string

3、查询一条数据为map集合

mapper的接口文件

  /**
     * 根据id查询用户信息为一个map集合
     */
    Map<String,Object> getUserByIdToMap(@Param("id")Integer id);

mapper.xml文件

   <!--    Map<String,Object> getUserByIdToMap(@Param("id")Integer id);-->
    <select id="getUserByIdToMap" resultType="map">
        select * from t_user where id=#{id}
    </select>

test

    /**
     * 通过id查询用户，并用map进行封装
     */
    @Test
    public void testGetUserByIdToMap(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        Map<String, Object> userByIdToMap = mapper.getUserByIdToMap(1);
        System.out.println(userByIdToMap);
    }

效果图：

本质上就是更改了mapper.xml文件中的resultType的类型；然后map集合作为方法的返回值。

4、查询多条数据为map集合

4.1 方法一：

mapper的接口文件

  /**
     * 查询所有的信息为map集合
     */
    
    List<Map<String,Object>> getUserToMap();

mapper.xml文件

<!--    Map<String,Object> getUserToMap();-->
    <select id="getUserToMap" resultType="map">
        select * from t_user
    </select>

test

    /**
     * 查询所有用户，并用map进行封装
     */
    @Test
    public void testGetUserToMap(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        List<Map<String, Object>> userToMap = mapper.getUserToMap();
        System.out.println(userToMap);
    }

实际上就是把map作为对象，放置在了List集合里面；
效果图：

4.2 方法二：

唯一不同的就是接口文件

    /**
     * 查询所有的信息为map集合
     */
    @MapKey("id")
    Map<String,Object> getUserToMap(); 

test

 /**
     * 查询所有用户，并用map进行封装
     */
    @Test
    public void testGetUserToMap(){
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
       Map<String, Object> userToMap = mapper.getUserToMap();
        System.out.println(userToMap);
    }

效果图：

在mapper接口的方法上添加@MapKey注解，此时就可以将每条数据转化为map集合作为值，以某一个字段作为键；