5. mybatis基础

1.MyBatis:MyBatis是支持普通SQL查询,存储过程和高级映射的优秀sql映射的持久层框架.
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。

2.MyBatis的优点
2.1:简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
2.2:灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优化。通过sql基本上可以实现我们不使用数据访问框架可以实现的所有功能，或许更多。
2.3:解除sql与程序代码的耦合：通过提供DAL层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
2.4:提供映射标签，支持对象与数据库的orm字段关系映射
2.5:提供对象关系映射标签，支持对象关系组建维护
2.6:提供xml标签，支持编写动态sql

3.MyBatis的总体流程:加载配置并初始化->接收调用请求->处理操作请求->返回处理结果将最终 的处理结果返回.

4.MyBatis的功能框架:

5.MyBatis的体系结构:

6. MyBatis和数据交互的方式:
   6.1:使用传统的MyBatis提供的API;(类似DBUtils操作)
   

   6.2:使用Mapper接口;
   

7.MyBatis的基本应用:

	7.1:使用步骤
		7.1.1:第一步:导入pom.xml包
				<!--单元测试的包-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- 添加mybatis的核心包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <!-- 添加mybatis与Spring整合的核心包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.caches</groupId>
            <artifactId>mybatis-ehcache</artifactId>
            <version>1.1.0</version>
        </dependency>


        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
            <scope>test</scope>
        </dependency>

        <!-- 日志包 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.7</version>
        </dependency>
        <!-- slf4j日志框架和log4j 转换包 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.7</version>
        </dependency>
        <!--日志包-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging-api</artifactId>
            <version>1.1</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.14</version>
        </dependency>

7.1.2:配置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>
    <!-- 加载properties文件
    先加载property子标签的内容，后加载properties文件
    如果名称相同，后边覆盖前边内容
     -->
    <properties resource="jdbc.properties">
        <property name="jdbc.password" value="12345"/>
    </properties>
    <!-- 全局参数配置：二级缓存，延迟加载
    <settings></settings>
    -->
    <!-- 定义别名
    <typeAliases>-->
        <!-- 给单个的类起别名
        <typeAlias type="com.qf.domain.User" alias="user"/>
        -->
    </typeAliases>-->
    <!-- 配置mybatis的环境信息 -->
    <environments default="development">
        <environment id="development">
            <!-- 配置JDBC事务控制，由mybatis进行管理 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源，采用mybatis连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driverClass}" />
                <property name="url" value="${jdbc.jdbcUrl}" />
                <property name="username" value="${jdbc.user}" />
                <property name="password" value="${jdbc.password}" />
            </dataSource>
        </environment>
    </environments>
    <!-- 加载映射文件 -->
    <mappers>
        <mapper resource="mapper/UserDaoMapper.xml"></mapper>
    </mappers>
</configuration>

3.配置映射文件
	<?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>

7.2:mybatis实现crud操作

	<?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">
<!--配置命名空间,与对应dao接口名字作为命名空间-->
<mapper namespace="dao1.IUserDao">
    <!--id名与dao接口中对应的方法名一致,parameterType配置参数的全全限定类型名,#{}表示占位符,简单类型,大括号中名称随便写,对象类型,大括号中参数名称与对象属性对应-->
    <insert id="addUser" parameterType="bean.UserInfo">
        <!--获得最后一个自动生成的主键也即UId,keyProperty对应的是UserInfo中属性名-->
        <selectKey keyProperty="uid" resultType="int" order="AFTER">
            select last_insert_id()
        </selectKey>
        insert into t_user(uname,age,address,upassword) values(#{uname},#{age},#{address},#{upassword})
    </insert>

    <update id="updateUser" parameterType="bean.UserInfo">
        update t_user set uname=#{uname},age=#{age},address=#{address},upassword=#{upassword} where uid=#{uid}
    </update>

    <delete id="deleteUser" parameterType="int">
        delete from t_user where uid=#{uid}
    </delete>

    <select id="findUserCount" resultType="int">
        select count(uid) from t_user
    </select>

    <!--#{}表示占位符,可以防止sql注入,简单类型(int,double,string...),大括号中名称随便写,对象类型,大括号中参数名称与对象属性对应-->
    <select id="findUserById" parameterType="int" resultType="bean.UserInfo">
        select uid,uname,age,address,upassword from t_user where uid=#{aa}
    </select>

    <select id="findAllUser" resultType="bean.UserInfo">
        select uid,uname,age,address,upassword from t_user
    </select>

    <!--${}sql拼接的占位符,不能防止sql注入,大括号中参数名如果是普通类型(int,double,string),直接用value替换;如果参数是对象,大括号名称用属性名-->
    <select id="findLikeUname" parameterType="java.lang.String" resultType="bean.UserInfo">
        select uid,uname,age,address,upassword from t_user where uname like '%${value}%'
    </select>
	  <select id="findLikeUname2" parameterType="bean.UserInfo" resultType="bean.UserInfo">
    select uid,uname,age,address,upassword from t_user where uname like '%${uname}%'
</select>

</mapper>

	  public class IUserDaoTest {
    /**
     * 添加用户信息
     */
    @Test
    public void addUserTest() throws IOException {
        //创建用户对象
        UserInfo u1=new UserInfo("亮哥",18,"北京","123");

        //1.加载mybatis的配置文件,加载到内存中
        InputStream is= Resources.getResourceAsStream("mybatis.xml");
        //2.根据配置文件创建会话工厂
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
        //3.创建会话对象
        SqlSession session=factory.openSession();
        //4.调用会话对象的方法执行sql语句
        int result=session.insert("dao1.IUserDao.addUser",u1);
        //打印用户编号
        System.out.println("自动生成最后一个编号:"+u1.getUid());
        if (result>0){
            System.out.println("操作成功");
        }else{
            System.out.println("操作失败");
        }
        //5.提交事务
        session.commit();
    }

    /**
     * 修改用户信息
     */
    @Test
    public void updateUserTest() throws IOException {
        //创建用户对象
        UserInfo u1=new UserInfo(213,"冯磊2",28,"西安","456");

        //1.加载mybatis的配置文件,加载到内存中
        InputStream is= Resources.getResourceAsStream("mybatis.xml");
        //2.根据配置文件创建会话工厂
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
        //3.创建会话对象
        SqlSession session=factory.openSession();
        //4.调用会话对象的方法执行sql语句
        int result=session.update("dao1.IUserDao.updateUser",u1);

        if (result>0){
            System.out.println("操作成功");
        }else{
            System.out.println("操作失败");
        }
        //5.提交事务
        session.commit();
    }

    /**
     * 删除用户信息
     */
    @Test
    public void deleteUserTest() throws IOException {
        //1.加载mybatis的配置文件,加载到内存中
        InputStream is= Resources.getResourceAsStream("mybatis.xml");
        //2.根据配置文件创建会话工厂
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
        //3.创建会话对象
        SqlSession session=factory.openSession();
        //4.调用会话对象的方法执行sql语句
        int result=session.delete("dao1.IUserDao.deleteUser",206);

        if (result>0){
            System.out.println("操作成功");
        }else{
            System.out.println("操作失败");
        }
        //5.提交事务
        session.commit();
    }

    /**
     * 查询表中总记录数
     */
    @Test
    public void findUserCountTest() throws IOException {
        //1.加载mybatis的配置文件,加载到内存中
        InputStream is= Resources.getResourceAsStream("mybatis.xml");
        //2.根据配置文件创建会话工厂
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
        //3.创建会话对象
        SqlSession session=factory.openSession();
        //4.调用会话对象的方法执行sql语句
        int result=session.selectOne("dao1.IUserDao.findUserCount");
        System.out.println("表中总记录数为:"+result);
    }

    /**
     * 根据编号查询用户信息
     */
    @Test
    public void findUserByIdTest() throws IOException {
        //1.加载mybatis的配置文件,加载到内存中
        InputStream is= Resources.getResourceAsStream("mybatis.xml");
        //2.根据配置文件创建会话工厂
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
        //3.创建会话对象
        SqlSession session=factory.openSession();
        //4.调用会话对象的方法执行sql语句
        UserInfo u=session.selectOne("dao1.IUserDao.findUserById",214);
        System.out.println("编号为214的用户信息为:"+u);
    }

    /**
     * 查询用户信息
     */
    @Test
    public void findAllUserTest() throws IOException {
        //1.加载mybatis的配置文件,加载到内存中
        InputStream is= Resources.getResourceAsStream("mybatis.xml");
        //2.根据配置文件创建会话工厂
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
        //3.创建会话对象
        SqlSession session=factory.openSession();
        //4.调用会话对象的方法执行sql语句
        List<UserInfo> ulist=session.selectList("dao1.IUserDao.findAllUser");
        ulist.stream().forEach(System.out::println);
    }

    /**
     * 根据用户名模糊查询用户信息
     */
    @Test
    public void findLikeUname() throws IOException {
        //1.加载mybatis的配置文件,加载到内存中
        InputStream is= Resources.getResourceAsStream("mybatis.xml");
        //2.根据配置文件创建会话工厂
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
        //3.创建会话对象
        SqlSession session=factory.openSession();
        //4.调用会话对象的方法执行sql语句
        List<UserInfo> ulist=session.selectList("dao1.IUserDao.findLikeUname","李%");
        ulist.stream().forEach(System.out::println);
    }

		/**
 * 根据用户名模糊查询用户信息
 */
@Test
public void findLikeUname2() throws IOException {
    //创建用户对象
    UserInfo u1=new UserInfo(213,"张",28,"西安","456");


    //1.加载mybatis的配置文件,加载到内存中
    InputStream is= Resources.getResourceAsStream("mybatis.xml");
    //2.根据配置文件创建会话工厂
    SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
    //3.创建会话对象
    SqlSession session=factory.openSession();
    //4.调用会话对象的方法执行sql语句
    List<UserInfo> ulist=session.selectList("dao1.IUserDao.findLikeUname2",u1);
    ulist.stream().forEach(System.out::println);
}

}

7.3:在MyBatis的映射文件中#{}和${}的区别

7.3.1:#{}是占位符,如果参数是普通类型(int,double,String...),#{形参名可任意},如果参数是对象类型,#{属性名};
	 ${}是sql拼接符号,如果参数是普通类型(int,double,String...),${value}
				如果参数是对象类型,${属性名};
7.3.2:#{}是采用预编译传参,参数在dbms中起作用,可以有效防止sql注入;
	 ${}是直接拼接参数,本质是字符串替换,参数在dbms前起作用,不能防止sql注入;
7.3.3:#{}在解析时自带引号;${}在sql解析时,会原样输出不会带引号.
总结:能用#{},就不要用${};表名作参数时，必须用${};order by 时，参数作为排序列名时必须用 ${};

7.4:分页及MyBatis的传参方式

	7.4.1:使用map传参,用sqlSession调用方法执行sql语句
		7.4.2:使用对象传参,用sqlSession调用方法执行sql语句
		 7.4.3:使用注解传参@param(""),配合接口Mapper对象一起用才能将参数映射到sql语句中
		7.4.4:使用序号传参arg0...,配合接口Mapper对象一起用才能将参数映射到sql语句中
			总结:如果是用sqlsession调用方法直接执行映射文件中sql时,只能传入一个参数,这个参数可以是任意类型;如果是用接口Mapper对象调用方法执行映射文件中sql时,可以传入多个参数.
			/**
 * 用map作为参数,分页查询用户信息
 * @param hmap
 * @return List<UserInfo>
 */
List<UserInfo> findByPage1(Map<String,Integer> hmap);

/**
 * 用对象作为参数,分页查询用户信息
 * @param page
 * @return List<UserInfo>
 */
List<UserInfo> findByPage2(PageTool page);

/**
 * 用注解传参,分页查询用户信息,配合接口Mapper对象一起用才能将参数映射到sql语句中
 * @param start
 * @param pagecount
 * @return List<UserInfo>
 */
List<UserInfo> findByPage3(@Param("start") int start,@Param("pageCount") int pagecount);

/**
 * 用序号传参,分页查询用户信息,映射文件中形参只能用arg0...或param1...
 * 配合接口Mapper对象一起用才能将参数映射到sql语句中
 * @param start
 * @param pagecount
 * @return List<UserInfo>
 */
List<UserInfo> findByPage4(int start,int pagecount);

<!--用map传参数,#{}中形参数名必须与map中Key一致-->
<select id="findByPage1" parameterType="java.util.Map" resultType="bean.UserInfo">
    select uid,uname,age,address,upassword from t_user limit #{start},#{pageCount}
</select>

<!--用对象传参数,#{}中形参数名必须与对象中属性名一致-->
<select id="findByPage2" parameterType="bean.PageTool" resultType="bean.UserInfo">
    select uid,uname,age,address,upassword from t_user limit #{start},#{pageCount}
</select>

<!--用注解传参数,#{}中形参数名必须与注解括号中名称一致,配合接口Mapper对象一起用才能将参数映射到sql语句中-->
<select id="findByPage3" resultType="bean.UserInfo">
    select uid,uname,age,address,upassword from t_user limit #{start},#{pageCount}
</select>

<!--用序号传参数,#{}中形参数名arg0..或param1...,配合接口Mapper对象一起用才能将参数映射到sql语句中-->
<select id="findByPage4" resultType="bean.UserInfo">
    select uid,uname,age,address,upassword from t_user limit #{arg0},#{arg1}
</select>


/**
 * 用map作为参数分页查询用户信息
 */
@Test
public void findByPage1() throws IOException {

    //准备map参数
    Map<String,Integer> hmap=new HashMap();
    hmap.put("start",0);
    hmap.put("pageCount",5);

    //1.加载mybatis的配置文件,加载到内存中
    InputStream is= Resources.getResourceAsStream("mybatis.xml");
    //2.根据配置文件创建会话工厂
    SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
    //3.创建会话对象
    SqlSession session=factory.openSession();
    //4.调用会话对象的方法执行sql语句
    List<UserInfo> ulist=session.selectList("dao1.IUserDao.findByPage1",hmap);
    ulist.stream().forEach(System.out::println);
}

/**
 * 用对象作为参数分页查询用户信息
 */
@Test
public void findByPage2() throws IOException {

   //准备对象
    PageTool page=new PageTool(0,5);

    //1.加载mybatis的配置文件,加载到内存中
    InputStream is= Resources.getResourceAsStream("mybatis.xml");
    //2.根据配置文件创建会话工厂
    SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
    //3.创建会话对象
    SqlSession session=factory.openSession();
    //4.调用会话对象的方法执行sql语句
    List<UserInfo> ulist=session.selectList("dao1.IUserDao.findByPage2",page);
    ulist.stream().forEach(System.out::println);
}

/**
 * 用注解传参数分页查询用户信息
 */
@Test
public void findByPage3() throws IOException {

    //1.加载mybatis的配置文件,加载到内存中
    InputStream is= Resources.getResourceAsStream("mybatis.xml");
    //2.根据配置文件创建会话工厂
    SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
    //3.创建会话对象
    SqlSession session=factory.openSession();
    //4.用会话对象创建接口映射对象
    IUserDao userDao=session.getMapper(dao1.IUserDao.class);

    //4.调用会话对象的方法执行sql语句
    List<UserInfo> ulist=userDao.findByPage3(5,5);
    ulist.stream().forEach(System.out::println);
}

/**
 * 用注解传参数分页查询用户信息
 */
@Test
public void findByPage4() throws IOException {

    //1.加载mybatis的配置文件,加载到内存中
    InputStream is= Resources.getResourceAsStream("mybatis.xml");
    //2.根据配置文件创建会话工厂
    SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
    //3.创建会话对象
    SqlSession session=factory.openSession();
    //4.用会话对象创建接口映射对象
    IUserDao userDao=session.getMapper(dao1.IUserDao.class);

    //4.调用会话对象的方法执行sql语句
    List<UserInfo> ulist=userDao.findByPage4(10,5);
    ulist.stream().forEach(System.out::println);
}

7.5:Mybatis返回map类型查询结果

	/**
 * 查询所有用户信息
 * @return List<Map<String,Object>>
 */
List<Map<String,Object>> findAllUser2();

<!--返回List<Map<String,Object>>,查询的每行记录对应一个map集合,列名对应map中Key,列值对应value-->
<select id="findAllUser2" resultType="java.util.Map">
    select uid,uname,age,address,upassword from t_user
</select>

/**
 * 查询用户信息,返回List<Map<String,Object>>
 */
@Test
public void findAllUser2Test() throws IOException {
    //1.加载mybatis的配置文件,加载到内存中
    InputStream is= Resources.getResourceAsStream("mybatis.xml");
    //2.根据配置文件创建会话工厂
    SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
    //3.创建会话对象
    SqlSession session=factory.openSession();
    //4.调用会话对象的方法执行sql语句
    List<Map<String,Object>> ulist=session.selectList("dao1.IUserDao.findAllUser2");
    ulist.stream().forEach(System.out::println);
}

7.6:单元测试中@before的用法

	eg:/**
 * dao1包的测试类
 * @version 1.0
 * @auth sx
 * @date 2020/5/6
 */
public class IUserDaoTest {
    /**
     * 声明一个会话工厂对象
     */
    private SqlSessionFactory factory;

    /**
     * 单元测试中注解,在测试方法执行之前,执行一些初始化操作
     */
    @Before
    public void init() throws IOException {
        //1.加载mybatis的配置文件,加载到内存中
        InputStream is= Resources.getResourceAsStream("mybatis.xml");
        //2.根据配置文件创建会话工厂
        factory=new SqlSessionFactoryBuilder().build(is);
    }

    /**
     * 查询用户信息,返回List<Map<String,Object>>
     */
    @Test
    public void findAllUser2Test() throws IOException {
       
        //3.创建会话对象
        SqlSession session=factory.openSession();
        //4.调用会话对象的方法执行sql语句
        List<Map<String,Object>> ulist=session.selectList("dao1.IUserDao.findAllUser2");
        ulist.stream().forEach(System.out::println);
    }
}

8.MyBatis的Mapper映射和Mapper接口注解

	8.1:使用Mapper映射器:采用代理模式,创建接口代理类,用接口代理对象直接调用接口的方							法.
		8.1.1:规范:
			8.1.1.1:mapper接口的全限定名要和mapper映射文件的namespace的值相同。
			8.1.1.2:mapper接口的方法名称要和mapper映射文件中的statement的id相同；
			8.1.1.3:mapper接口的方法参数只能有一个，且类型要和mapper映射文件中							statement的parameterType的值保持一致。
			8.1.1.4:mapper接口的返回值类型要和mapper映射文件中statement的resultType值或resultMap中的type值保持一致；
		eg:public class UserMapperTest {
    /**
     * 声明一个会话工厂对象
     */
    private SqlSessionFactory factory;

    /**
     * 单元测试中注解,在测试方法执行之前,执行一些初始化操作
     */
    @Before
    public void init() throws IOException {
        //1.加载mybatis的配置文件,加载到内存中
        InputStream is= Resources.getResourceAsStream("mybatis.xml");
        //2.根据配置文件创建会话工厂
        factory=new SqlSessionFactoryBuilder().build(is);
    }

    /**
     * 添加用户信息
     */
    @Test
    public void addUserTest() throws IOException {
        //创建用户对象
        UserInfo u1=new UserInfo("王磊",18,"北京","123");

        //3.创建会话对象
        SqlSession session=factory.openSession();
        //4.获得接口映射器
        UserMapper um=session.getMapper(dao2.UserMapper.class);
        //4.调用会话对象的方法执行sql语句
        int result=um.addUser(u1);
        //打印用户编号
        System.out.println("自动生成最后一个编号:"+u1.getUid());
        if (result>0){
            System.out.println("操作成功");
        }else{
            System.out.println("操作失败");
        }
        //5.提交事务
        session.commit();
    }

    /**
     * 修改用户信息
     */
    @Test
    public void updateUserTest() throws IOException {
        //创建用户对象
        UserInfo u1=new UserInfo(215,"王磊",28,"西安","456");

        //3.创建会话对象
        SqlSession session=factory.openSession();
        //4.获得接口映射器
        UserMapper um=session.getMapper(dao2.UserMapper.class);
        //4.调用方法执行sql语句
        int result=um.updateUser(u1);

        if (result>0){
            System.out.println("操作成功");
        }else{
            System.out.println("操作失败");
        }
        //5.提交事务
        session.commit();
    }

    /**
     * 删除用户信息
     */
    @Test
    public void deleteUserTest() throws IOException {

        //3.创建会话对象
        SqlSession session=factory.openSession();
        //4.获得接口映射器
        UserMapper um=session.getMapper(dao2.UserMapper.class);
        //5.调用方法执行sql语句
        int result=um.deleteUser(216);

        if (result>0){
            System.out.println("操作成功");
        }else{
            System.out.println("操作失败");
        }
        //5.提交事务
        session.commit();
    }

    /**
     * 查询表中总记录数
     */
    @Test
    public void findUserCountTest() throws IOException {

        //3.创建会话对象
        SqlSession session=factory.openSession();
        //4.获得接口映射器
        UserMapper um=session.getMapper(dao2.UserMapper.class);
        //5.调用方法执行sql语句
        int result=um.findUserCount();
        System.out.println("表中总记录数为:"+result);
    }

    /**
     * 根据编号查询用户信息
     */
    @Test
    public void findUserByIdTest() throws IOException {

        //3.创建会话对象
        SqlSession session=factory.openSession();
        //4.获得接口映射器
        UserMapper um=session.getMapper(dao2.UserMapper.class);
        //5.调用会话对象的方法执行sql语句
        UserInfo u=um.findUserById(214);
        System.out.println("编号为214的用户信息为:"+u);
    }

    /**
     * 查询用户信息,返回List<UserInfo>
     */
    @Test
    public void findAllUserTest() throws IOException {

        //3.创建会话对象
        SqlSession session=factory.openSession();
        //4.获得接口映射器
        UserMapper um=session.getMapper(dao2.UserMapper.class);
        //5.调用会话对象的方法执行sql语句
        List<UserInfo> ulist=um.findAllUser();
        ulist.stream().forEach(System.out::println);
    }
}

	8.2:使用ResultMapper映射定义
		<?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">
<!--配置命名空间,与对应dao接口名字作为命名空间-->
<mapper namespace="dao2.UserMapper">
    
    <!--#{}表示占位符,可以防止sql注入,简单类型(int,double,string...),大括号中名称随便写,对象类型,大括号中参数名称与对象属性对应-->
    <select id="findUserById" parameterType="int" resultMap="userInfo2Map">
        select uid,uname,age,address,upassword from t_user where uid=#{aa}
    </select>

    <!--第一种:当列名与对象的属性名不同时,给列取别名,让别名与属性名一一对应-->
<!--    <select id="findAllUser" resultType="bean.UserInfo2">-->
<!--        &lt;!&ndash;直接返回List<UserInfo2>,因为UserInfo2的属性名与查询出每行记录的列名不同,所以返回的值是null-->
<!--        select uid,uname,age,address,upassword from t_user&ndash;&gt;-->
<!--        select uid as userId,uname as userName,age as userAge,address as userAddress,upassword as userPassword from t_user-->
<!--    </select>-->

    <!--第二种:当列名与对象的属性名不同时,定义一个resultMap,将列名与属性的映射关系配好-->
    <!--自定义resultMap结果,如果sql语句中想返回对象或对象集合,就可以引用id名-->
    <resultMap id="userInfo2Map" type="bean.UserInfo2">
        <!--id标签对应主键列-->
        <id column="uid" property="userId"></id>
        <!--对象普通列-->
        <result column="uname" property="userName"></result>
        <result column="age" property="userAge"></result>
        <result column="address" property="userAddress"></result>
        <result column="upassword" property="userPassword"></result>
    </resultMap>

    <select id="findAllUser" resultMap="userInfo2Map">
        select uid,uname,age,address,upassword from t_user
    </select>
</mapper>

	8.3: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">
<configuration>
    <!--加载jdbc配置文件-->
    <properties resource="jdbc.properties"></properties>

    <!--给类或包取别名
    <typeAliases>
        <typeAlias type="com.qf.bean.Userinfo" alias="userinfo"></typeAlias>
    </typeAliases>-->

    <!--配置缓存
    <settings>
        <setting name="" value=""/>
    </settings>-->

    <!--配置连接池环境-->
    <environments default="development">
        <!--数据库连接池的名称-->
        <environment id="development">
            <!--配置事务管理,JDBC表示由MyBatis来管理事务-->
            <transactionManager type="JDBC"/>
            <!--启用连接池-->
            <dataSource type="POOLED">
                <!--连接池的重要属性-->
                <property name="driver" value="${c3p0.driverClass}"/>
                <property name="url" value="${c3p0.jdbcUrl}"/>
                <property name="username" value="${c3p0.user}"/>
                <property name="password" value="${c3p0.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!--配置sql映射文件-->
    <mappers>
        <!--将sql的映射文件的配置-->
        <mapper resource="mapper/IUserDaoMapper.xml"></mapper>
        <mapper resource="mapper/UserMapper.xml"></mapper>

        <!--将注解版的Dao接口配置-->
        <mapper class="dao3.UserMapper3"></mapper>
    </mappers>
</configuration>

/**
 * 用户映射接口(以前Dao接口)
 * @version 1.0
 * @auth sx
 * @date 2020/5/7
 */
public interface UserMapper3 {
    /**
     * 添加用户信息
     * @param u
     * @return int
     */
    @Options(useGeneratedKeys = true,keyProperty ="uid")//获得当前插入的这个用户自动生成主键
    @Insert("insert into t_user(uname,age,address,upassword) values(#{uname},#{age},#{address},#{upassword})")
    int addUser(UserInfo u);

    /**
     * 修改用户信息
     * @param u
     * @return int
     */
    @Update("update t_user set uname=#{uname},age=#{age},address=#{address},upassword=#{upassword} where uid=#{uid}")
    int updateUser(UserInfo u);

    /**
     * 删除用户信息
     * @param uid
     * @return int
     */
    @Delete("delete from t_user where uid=#{uid}")
    int deleteUser(int uid);

    /**
     * 查询表中总记录数
     * @return int
     */
    @Select("select count(uid) from t_user")
    int findUserCount();

    /**
     * 根据编号查询表中一个用户信息
     * 第一种:当查询出列名与对象属性名不相同时,给列取别名,让列的别名与属性名相同
     * 第二种:用注解声明results来接收结果
     * @return UserInfo
     */
    @Results(id = "userInfo2Map",value = {
            @Result(id = true,column = "uid",property = "userId"),
            @Result(column = "uname",property = "userName"),
            @Result(column = "age",property = "userAge"),
            @Result(column = "address",property = "userAddress"),
            @Result(column = "upassword",property = "userPassword")
    })
    @Select("select uid,uname,age,address,upassword from t_user where uid=#{aa}")
    UserInfo2 findUserById(int uid);

    /**
     * 查询所有用户信息
     * @return List<UserInfo>
     */
    @ResultMap("userInfo2Map")
    @Select("select uid,uname,age,address,upassword from t_user")
    List<UserInfo2> findAllUser();
}

9.MyBatis Generator自动生成
	第一步:在pom.xml中加依赖包和插件
			<!--MyBatis Generator自动生成的Jar包-->
<dependency>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-core</artifactId>
    <version>1.3.5</version>
</dependency>

<build>
    <plugins>
        <!-- 编译插件，指定编译用的jdk版本 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.1</version><!-- 必须指定版本 -->
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
        <!--配置MyBatis Generator自动生成插件-->
        <plugin>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-maven-plugin</artifactId>
            <version>1.3.5</version>
            <configuration>
                <verbose>true</verbose>
                <overwrite>true</overwrite>
            </configuration>
        </plugin>
    </plugins>
</build>

	第二步:在resources下放置配置文件generatorConfig.xml
		<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd" >
<generatorConfiguration >
    <!-- 链接数据库的jar包的完整路径，一定要注意跟自己的仓库路径一致 ，注意修改  -->
    <classPathEntry location="D:\apache-maven-3.6.3-bin\apache-maven-3.6.3\repo\mysql\mysql-connector-java\5.1.38\mysql-connector-java-5.1.38.jar" ></classPathEntry>
    <context id="context1" >
        <commentGenerator>
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
        <!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/nz1901myschool?characterEncoding=utf-8"
                        userId="root"
                        password="root" />
        <!-- 生成POJO类的位置,targetPackage生成的实体类的包名,targetProject是实体类包名生成的位置 -->
        <javaModelGenerator targetPackage="com.qf.pojo" targetProject="src/main/java" />
        <!-- mapper映射文件生成的位置 -->
        <sqlMapGenerator targetPackage="com.qf.mapper" targetProject="src/main/java" />
        <!-- mapper接口生成的位置 -->
        <javaClientGenerator targetPackage="com.qf.dao" targetProject="src/main/java" type="XMLMAPPER" />
        <!-- tableName指定数据库表  domainObjectName实体的名称
      <table  tableName="userinfo" domainObjectName="Userinfo"
			<!--自动生成增删除改查的方法和映射sql例子-->
              enableCountByExample="false"
              enableUpdateByExample="false"
              enableSelectByExample="false"
              enableDeleteByExample="false"
      ></table>
      -->
        <table  tableName="t_student" domainObjectName="Student"
                enableCountByExample="false"
                enableUpdateByExample="false"
                enableSelectByExample="false"
                enableDeleteByExample="false"
        ></table>
        <table  tableName="t_teacher" domainObjectName="Teacher"
                enableCountByExample="false"
                enableUpdateByExample="false"
                enableSelectByExample="false"
                enableDeleteByExample="false"
        ></table>
    </context>
</generatorConfiguration>


	第三步:自动生成与表对应的实体类,接口,sql映射文件