02-Mybatis、代理dao、参数、配置

能够掌握mybatis中的接口的CRUD
能够掌握mybatis中的dao实现类方式的CRUD
了解mybatis主配置文件的标签的使用

二、基于代理Dao实现CRUD操作
使用要求： 
1、持久层接口和持久层接口的映射配置必须在相同的包下 
2、持久层映射配置中 mapper 标签的 namespace 属性取值必须是持久层接口的全限定类名 
3、SQL 语句的配置标签<select>,<insert>,<delete>,<update>的 id 属性必须和持久层接口的 方法名相同。

2.1、根据ID查询
2.1.1在持久层接口中添加findById方法
　　User findById(Integer userId);  

2.1.2、在用户的配置文件中配置
<!-- 根据 id 查询 --> 

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

细节： 
resultType 属性：
　　 用于指定结果集的类型。 
parameterType 属性：
　　用于指定传入参数的类型。 
sql 语句中使用#{}字符： 
　　它代表占位符，相当于原来 jdbc 部分所学的?，都是用于执行语句时替换实际的数据。 
　　具体的数据是由#{}里面的内容决定的。 
#{}中内容的写法： 
　　由于数据类型是基本类型，所以此处可以随意写。--->最好还是写字段名

2.1.3、在测试类中添加测试

2.2、保存操作
2.2.1、在持久层接口中添加新增方法
　　int saveUser(User user); 

2.2.2、在用户的映射配置文件中配置

<!-- 保存用户--> 
<insert id="saveUser" parameterType="com.itheima.domain.User"> 
　　insert into user(username,birthday,sex,address) 
　　　　values(#{username},#{birthday},#{sex},#{address}) 
</insert>

细节： 
parameterType 属性： 
　　代表参数的类型，因为我们要传入的是一个类的对象，所以类型就写类的全名称。
　　-->不写parameterType属性或者写resultType也可以执行。
#{}中内容的写法： 
　　由于我们保存方法的参数是 一个 User 对象，此处要写 User 对象中的属性名称。 
　　它用的是 ognl 表达式。 
ognl 表达式： 
　　它是 apache 提供的一种表达式语言，全称是： 
　　Object Graphic Navigation Language 对象图导航语言 
　　它是按照一定的语法格式来获取数据的。 
　　语法格式就是使用 #{对象.对象}的方式
　　#{user.username}它会先去找 user 对象，然后在 user 对象中找到 username 属性，并调用 getUsername()方法把值取出来。但是我们在 parameterType 属性上指定了实体类名称，所以可以省略 user. 而直接写 username。 

2.2.3、测试方法的注意事项

public class MybatisTest {
    InputStream in;
    SqlSession sqlSession;
    IUserDao userDao;
    @Before
    public void init() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        sqlSession = factory.openSession();
        userDao = sqlSession.getMapper(IUserDao.class);
    }
    
    @After
    public void destroy() throws IOException {
        //提交所有
        sqlSession.commit();
        //释放资源
        sqlSession.close();
        in.close();
    }
    
    @Test
    public void testFindAll() throws IOException {
        List<User> users = userDao.findAll();
        for(User user:users){
            System.out.println(user);
        }
    }
    
    @Test
    public void testSaveUser(){
        User user = new User();
        user.setUsername("payn");
        user.setAddress("pppppp");
        user.setSex("男");
        user.setBirthday(new Date());
        System.out.println("保存之前"+user);
        userDao.saveUser(user);
        System.out.println("保存之后"+user);
    }
    
    @Test
    public void testUpdateUser(){
        User user = new User();
        user.setId(65);
        user.setUsername("'payn'");
        user.setAddress("'BBB'");
        user.setSex("'男'");
        user.setBirthday(new Date());
        int res = userDao.updateUser(user);
        System.out.println(res);
    }
/*    
    @Test
    public void testFindById(){
        User user = new User();
        user.setId( 58);
        User user1 = userDao.findById(user);
        System.out.println(user1);
    }*/
    
    @Test
    public void testDeleteUser(){
        userDao.deleteUser(54);
    }
    
    @Test
    public void testFindByName(){
        List<User> users = userDao.findByName("王");
        for(User user:users){
            System.out.println(user);
        }
    }
    
    @Test
    public void testFindTotal(){
        int total = userDao.findTotal();
        System.out.println(total);
    }
    
    @Test
    public void testFindUserByVo(){
        QueryVo vo = new QueryVo();
        User user = new User();
        user.setUsername("%王%");
        vo.setUser(user);
        List<User> users = userDao.findUserByVo(vo);
        for(User u:users){
            System.out.println(u);
        }
    }
    
}

和 jdbc 一样，在实现增删改时一定要去控制事务的提交，那么在 mybatis 中如何控制事务提交呢？ 
可以使用:
　　session.commit();   //来实现事务提交。

2.2.4、新增的用户id的返回值

<insert id="saveUser" parameterType="com.itheima.domain.User">  
    insert into user(username,birthday,sex,address)      
    values(#{username},#{birthday},#{sex},#{address}) 
</insert> 
<!-- 上述修改成如下 -->  
<insert id="saveUser" parameterType="USER">  (USER是别名。也可以写全限定名)
    <!-- 配置保存时获取插入的 id -->  
    <selectKey keyColumn="id" keyProperty="id" resultType="int">   
        select last_insert_id();  
    </selectKey>  
    insert into user(username,birthday,sex,address)   
    values(#{username},#{birthday},#{sex},#{address}) 
</insert> 

<selectKey keyColumn="id" keyProperty="id" resultType="int"> 
　　select last_insert_id(); 
</selectKey>    -->将id值设置给对象

2.3、用户更新
2.3.1、在持久层接口中添加更新方法
　　int updateUser(User user); 

2.3.2、在用户映射配置文件中配置

<!-- 更新用户 --> 
<update id="updateUser" parameterType="com.itheima.domain.User"> 
　　update user set username=#{username},birthday=#{birthday},sex=#{sex}, address=#{address} where id=#{id} 
</update>

2.4、用户删除
2.4.1、在持久层接口中添加删除方法
　　int deleteUser(Integer userId);

2.4.2、在用户的映射配置文件中配置

<!-- 删除用户 --> 
<delete id="deleteUser" parameterType="java.lang.Integer">  
    delete from user where id = #{uid} 
</delete>

2.5、用户模糊查询
2.5.1、在持久层接口中添加删除方法
　　List<User> findByName(String username); 

2.5.2、在用户的映射配置文件中配置

<!-- 根据名称模糊查询 --> 
<select id="findByName" resultType="com.itheima.domain.User" parameterType="String">     
    select * from user where username like #{username} 
</select>

在控制台输出的SQl语句：


2.5.4、模糊查询的另一种配置方式

<!-- 根据名称模糊查询 --> 
<select id="findByName" parameterType="string" resultType="com.itheima.domain.User">       
    select * from user where username like '%${value}%' 
</select> 

上面将原来的#{}占位符，改成了${value}。注意如果用模糊查询的这种写法，那么${value}的写法就是固定的，不能写成其它名字。 


以上两种方式的实现效果是一样的，但执行的语句是不一样的。 

2.5.5、#{ }和${ }的区别
#{}表示一个占位符号 
　　通过#{}可以实现 preparedStatement 向占位符中设置值，自动进行 java 类型和 jdbc 类型转换， 
　　#{}可以有效防止 sql 注入。 #{}可以接收简单类型值或 pojo 属性值。 
　　如果 parameterType 传输单个简单类型值，#{}括号中可以是 value 或其它名称。 
${}表示拼接 sql 串 
　　通过${}可以将 parameterType 传入的内容拼接在 sql中且不进行 jdbc 类型转换， 
　　${}可以接收简单类型值或 pojo 属性值，如果 parameterType 传输单个简单类型值，${}括号中只能是 value。
详解：
1、如果是使用#{}

参数是带类型的。因此，如在sql语句中可以知道传来的参数是一个字符串。而不是直接拼接在sql语句中。
2、如果是使用${ }

因为是直接传递参数而不进行JDBC类型转化。因此直接拼接在sql语句中。
只能预先在传递的参数外额外添加 ‘ ’(单引号，或格式转换)

@Test
public void testUpdateUser(){
    User user = new User();
    user.setId(65);
    user.setUsername("'payn'");
    user.setAddress("'BBB'");
    user.setSex("'男'");
    user.setBirthday(new Date());
    int res = userDao.updateUser(user);
    System.out.println(res);
}

2.5.6、模糊插叙的${value}源码分析

 TextSqlNode 类的源码

源码中指定了读取的 key 的名字就是”value”，所以我们在绑定参数时就只能叫 value 的名字 。

2.6、查询使用聚合函数
2.6.1、在持久层中添加方法
　　int findTotal();

2.6.2、在用户映射配置文件中配置

<select id="findTotal"  resultType="int">
    select count(*) from user;
</select>

2.7、Mybatis与JDBC编程的比较

1.数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。 
解决：在 SqlMapConfig.xml 中配置数据链接池，使用连接池管理数据库链接。 
2.Sql 语句写在代码中造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变 java 代码。 
解决：将 Sql 语句配置在 XXXXmapper.xml 文件中与 java 代码分离。 
3.向sql语句传参数麻烦，因为sql语句的where 条件不一定，可能多也可能少，占位符需要和参数对应。 
解决：Mybatis自动将 java 对象映射至 sql 语句，通过 statement 中的 parameterType 定义输入参数的 类型。 
4.对结果集解析麻烦，sql 变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成 pojo 对 象解析比较方便。 
解决：Mybatis自动将 sql执行结果映射至 java 对象，通过statement中的resultType 定义输出结果的类型。 

三、Mybatis的参数
3.1、ParameterType配置参数
3.1.1、使用说明
ParameterType：该属性的取值可以是基本类型，引用类型（例如:String 类型），还可以是实体类类型（POJO 类）。同时也可以使用实体类的包装类。
--->但是不能是任意类型。因为需要的类型可以转成JDBC类型或者与表的列有关系的。
关于JavaBean和POJO的区别：

POJO 和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Pure Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比 POJO复杂很多， Java Bean 是可复用的组件，对 Java Bean 并没有严格的规范，理论上讲，任何一个 Java 类都可以是一个 Bean 。但通常情况下，由于 Java Bean 是被容器所创建（如 Tomcat) 的，所以 Java Bean 应具有一个无参的构造器，另外，通常 Java Bean 还要实现 Serializable 接口用于实现 Bean 的持久性。 Java Bean 是不能被跨进程访问的。JavaBean是一种组件技术，就好像你做了一个扳子，而这个扳子会在很多地方被拿去用，这个扳子也提供多种功能(你可以拿这个扳子扳、锤、撬等等)，而这个扳子就是一个组件。一般在web应用程序中建立一个数据库的映射对象时，我们只能称它为POJO。POJO(Plain Old Java Object)这个名字用来强调它是一个普通java对象，而不是一个特殊的对象，其主要用来指代那些没有遵从特定的Java对象模型、约定或框架（如EJB）的Java对象。理想地讲，一个POJO是一个不受任何限制的Java对象（除了Java语言规范）

3.1.2、注意事项
基本类型和 String 我 们可以直接写类型名称 ，也可以使用包名.类名的方式 例如 ： java.lang.String。 
实体类类型，目前我们只能使用全限定类名。 
究其原因，是 mybaits 在加载时已经把常用的数据类型注册了别名，从而我们在使用时可以不写包名， 
而我们的是实体类并没有注册别名，所以必须写全限定类名。后续章节中将讲解如何注册实体类的别名。

默认支持的别名
别名 　　映射的类型
_byte　　   byte
_long　　   long
_short 　　  short
_int 　　　　int
_integer 　　int
_double 　　double
_float 　　　　float
_boolean 　　boolean
string 　　　　String
byte 　　　　Byte
long 　　　　Long
short 　　　　Short
int　　　　   Integer
integer　　   Integer
double　　   Double
float　　　　 Float
boolean 　　Boolean
date 　　　　 Date
decimal 　　BigDecimal
bigdecimal 　　BigDecimal
object 　　　　Object
map　　　　   Map
hashmap 　　HashMap
list 　　　　　　List
arraylist 　　　　ArrayList
collection　　　　Collection
iterator 　　　　Iterator
这些都是支持的默认别名。我们也可以从源码角度来看它们分别都是如何定义出来的。 
可以参考 TypeAliasRegistery.class 的源码。 

3.2、传递pojo包装对象
开发中通过 pojo 传递查询条件 ，查询条件是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。 Pojo 类中包含 pojo。 需求：根据用户名查询用户信息，查询条件放到 QueryVo 的 user 属性中。

3.2.1、编写QueryVo

public class QueryVo {

    private User user;

    public User getUser() {
        return user;
    }

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

3.2.2、编写持久层接口

public interface IUserDao {


    /**根据QueryVo中的条件查询用户
     * @param vo
     * @return
     */
    List<User> findUserByVo(QueryVo vo);

}

3.2.3、持久层接口的映射文件

<select id="findUserByVo"  resultType="com.itheima.domain.User"  parameterType="com.itheima.domain.QueryVo">
    select * from user where username like #{user.username}; 
</select>

3.2.4、测试包装类作为参数

@Test
public void testFindUserByVo(){
    QueryVo vo = new QueryVo();
    User user = new User();
    user.setUsername("%王%");
    vo.setUser(user);
    List<User> users = userDao.findUserByVo(vo);
    for(User u:users){
        System.out.println(u);
    }
}

四、Mybatis的输出结果封装
4.1、resultType配置结果类型
resultType 属性：可以指定结果集的类型，它支持基本类型和实体类类型。 
需要注意的是，它和 parameterType 一样，如果注册过类型别名的，可以直接使用别名。没有注册过的必须使用全限定类名。
例如：我们的实体类此时必须是全限定类名（后续章节会讲解如何配置实体类的别名） 
同时，当是实体类名称时，还有一个要求，实体类中的属性名称必须和查询语句中的列名保持一致，否则无法实现封装。

4.1.1、基本类型示例

<select id="findTotal"  resultType="int">
    select count(*) from user;
</select>

4.1.2、实体类型示例

<select id="findAll" resultType="com.itheima.domain.User">
    select * from user; 
</select>  ...

4.1.3、特殊情况示例
4.1.3.1、修改实体类-->(此时的实体类属性和数据库表的列名已经不一致

public class User implements Serializable{
    //实体类代码如下：(此时的实体类属性和数据库表的列名已经不一致了) 
    private Integer userId;
    private String username;
    private Date userBirthday;
    private String userSex;
    private String userAddress;

    public User() {
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

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

    public Date getUserBirthday() {
        return userBirthday;
    }

    public void setUserBirthday(Date userBirthday) {
        this.userBirthday = userBirthday;
    }

    public String getUserSex() {
        return userSex;
    }

    public void setUserSex(String userSex) {
        this.userSex = userSex;
    }

    public String getUserAddress() {
        return userAddress;
    }

    public void setUserAddress(String userAddress) {
        this.userAddress = userAddress;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", username='" + username + '\'' +
                ", userBirthday=" + userBirthday +
                ", userSex='" + userSex + '\'' +
                ", userAddress='" + userAddress + '\'' +
                '}';
    }
}

查询结果：

 为什么名称会有值？  因为：mysql 在 windows 系统中不区分大小写！ 

4.1.3.5、修改映射配置
使用别名查询 ：

<!-- 配置查询所有操作 --> 
<select id="findAll" resultType="com.itheima.domain.User">  
    select id as userId,username as userName,birthday as userBirthday,  sex as userSex,address as userAddress from user 
</select> 

即：将数据库表中的字段名转成java对象的属性名。
但是：如果我们的查询很多，都使用别名的话写起来会很麻烦。

4.2、resltMap结果类型
resultMap 标签可以建立查询的列名和实体类的属性名称不一致时建立对应关系。从而实现封装。 
在 select 标签中使用 resultMap 属性指定引用即可。
同时 resultMap 可以实现将查询结果映射为复杂类型的 pojo，比如在查询结果映射对象中包括 pojo 和 list 实现一对一查询和一对多查询。

4.2.1、定义resultMap

 <!-- 配置 查询结果的列名和实体类的属性名的对应关系 
      type 属性：指定实体类的全限定类名  
      id 属性：给定一个唯一标识，是给查询 select 标签引用用的。 
 -->
 <resultMap id="userMap" type="com.itheima.domain.User">
    <!-- 主键字段的对应 -->
    <id property="userId" column="id"></id>
    <!--非主键字段的对应-->
    <result property="username" column="username"></result>
    <result property="userAddress" column="address"></result>
    <result property="userSex" column="sex"></result>
    <result property="userBirthday" column="birthday"></result>
</resultMap>

　　id 标签：用于指定主键字段 
　　result 标签：用于指定非主键字段 
　　column 属性：用于指定数据库列名 
　　property 属性：用于指定实体类属性名称

4.2.2映射配置

  <resultMap id="userMap" type="com.itheima.domain.User">
    <!-- 主键字段的对应 -->
    <id property="userId" column="id"></id>
    <!--非主键字段的对应-->
    <result property="username" column="username"></result>
    <result property="userAddress" column="address"></result>
    <result property="userSex" column="sex"></result>
    <result property="userBirthday" column="birthday"></result>
  </resultMap>
  
  
<!--  <select id="findAll" resultType="com.itheima.domain.User">
  &lt;!&ndash;select * from user; &ndash;&gt;
  select id as userId,username as userName,birthday as userBirthday,  sex as userSex,address as userAddress from user 
  </select>-->
  <select id="findAll" resultMap="userMap">
    <!-- select id as userId,username as userName,birthday as userBirthday,  sex as userSex,address as userAddress from user-->
    select * from user;
  </select>

 
五、Mybatis传统DAO层开发(了解)
使用 Mybatis 开发 Dao，通常有两个方法，即原始 Dao开发方式和 Mapper 接口代理开发方式。而现在主流 的开发方式是接口代理开发方式，这种方式总体上更加简便。

5.1、Mybaitis实现DAO的传统开发方式
5.1.1、持久层Dao、接口
5.1.1、持久层Dao接口

public interface IUserDao {
    /**查询所有的用户
     * @return
     */
    List<User> findAll();

    User findById(Integer id);
    
    /**保存用户
     * @param user
     */
    int saveUser(User user);

    /**更新用户
     * @param user
     */
    int updateUser(User user);

    /**根据id删除用户
     * @param id
     */
    int deleteUser(Integer id);

    /**根据名称模糊查询
     * @param username
     * @return
     */
    List<User> findByName(String username);

    /**查询总用户数
     * @return
     */
    int findTotal();

    /**根据QueryVo中的条件查询用户
     * @param vo
     * @return
     */
    List<User> findUserByVo(QueryVo vo);

}

5.1.2、持久层Dao实现类

public class UserDaoImpl implements IUserDao{
    private SqlSessionFactory factory;

    public UserDaoImpl(SqlSessionFactory factory) {
        this.factory = factory;
    }
    
    public List<User> findAll() {
        SqlSession sqlSession = factory.openSession();
        List<User> users = sqlSession.selectList("com.itheima.dao.IUserDao.findAll");
        sqlSession.close();
        return users;
    }

    @Override
    public User findById(Integer id) {
        SqlSession sqlSession = factory.openSession();
        User user = sqlSession.selectOne("com.itheima.dao.IUserDao.findById", id);
        sqlSession.close();
        return user;
    }

    @Override
    public int saveUser(User user) {
        SqlSession sqlSession = factory.openSession();
        int res = sqlSession.insert("com.itheima.dao.IUserDao.saveUser",user);
        //提交事务
        sqlSession.commit();
        sqlSession.close();
        return res;
    }

    @Override
    public int updateUser(User user) {
        SqlSession sqlSession = factory.openSession();
        int res = sqlSession.update("com.itheima.dao.IUserDao.updateUser", user);
        sqlSession.commit();
        sqlSession.close();
        return res;
    }

    public int deleteUser(Integer id) {
        SqlSession sqlSession = factory.openSession();
        int res = sqlSession.delete("com.itheima.dao.IUserDao.deleteUser", id);
        sqlSession.commit();
        sqlSession.close();
        return res;
    }

    public List<User> findByName(String username) {
        SqlSession sqlSession = factory.openSession();
        List<User> users = sqlSession.selectList("com.itheima.dao.IUserDao.findByName", username);
        sqlSession.commit();
        sqlSession.close();
        return users;
    }

    public int findTotal() {
        SqlSession sqlSession = factory.openSession();
        int res = sqlSession.selectOne("com.itheima.dao.IUserDao.findTotal");
        sqlSession.close();
        return res;
    }

    public List<User> findUserByVo(QueryVo vo) {
        SqlSession sqlSession = factory.openSession();
        List<User> users = sqlSession.selectList("com.itheima.dao.IUserDao.findUserByVo", vo);
        sqlSession.close();
        return users;
    }
}

查询操作可以不用提交事务？
5.1.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="com.itheima.dao.IUserDao">

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

  <!--根据id查询-->
  <select id="findById" resultType="com.itheima.domain.User" parameterType="int">
    <!-- select id as userId,username as userName,birthday as userBirthday,  sex as userSex,address as userAddress from user-->
    select * from user where id=#{id};
  </select>
  
  <!--保存用户-->
    <!-- 保存用户    
    ognl 表达式：它是 apache 提供的一种表达式语言，在 struts2 中也有应用。   
    Object Graphic Navigation Language  对象图导航语言   
    它是按照一定的语法格式来获取数据的。   
    语法格式就是使用  #{对象.对象}的方式    
    #{user.username}它会先去找user 对象，然后在 user对象中找到username            
    属性，并把值取 出来  --> 
  <insert id="saveUser" parameterType="com.itheima.domain.User">
    <!-- 配置插入操作后，获取插入数据的id -->
    <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
      select last_insert_id();
    </selectKey>
      INSERT INTO user(username,address,sex,birthday) VALUES (#{username},#{address},#{sex},#{birthday});
  </insert>
  
  <!--更新用户-->
  <update id="updateUser" parameterType="com.itheima.domain.User">
    UPDATE user set username=#{username},address=#{address},sex=#{sex},birthday=#{birthday} where id=#{id};
  </update>

  <!--删除用户-->
  <delete id="deleteUser" parameterType="java.lang.Integer">
    delete from user where id = #{aaa};
  </delete>

<!--  <select id="findByName" parameterType="java.lang.String" resultType="com.itheima.domain.User">
    select * from user where username like #{mingzi};
  </select>-->
  <!--根据用户名模糊查询-->
  <select id="findByName" parameterType="string" resultType="com.itheima.domain.User">
    select * from user where username like '%${value}%'
  </select>

  <!--查询总数-->
  <select id="findTotal"  resultType="int">
    select count(*) from user;
  </select>

  <select id="findUserByVo"  resultType="com.itheima.domain.User"  parameterType="com.itheima.domain.QueryVo">
  select * from user where username like #{user.username};
</select>
  
</mapper>

5.1.4、测试类

public class MybatisCRUDTest {
    InputStream in;
    SqlSession sqlSession;
    SqlSessionFactory factory;
    IUserDao userDao;
    @Before
    public void init() throws IOException {
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        factory = builder.build(in);
        sqlSession = factory.openSession();
        userDao = new UserDaoImpl(factory);
    }

    @After
    public void destroy() throws IOException {
        //提交所有
//        sqlSession.commit();
        //释放资源
//        sqlSession.close();
        in.close();
    }
    
    @Test
    public void testFindAll(){
        List<User> users = userDao.findAll();
        for(User user:users){
            System.out.println(user);
        }
    }
    
    @Test
    public void testFindONe(){
        User user = userDao.findById(50);
        System.out.println(user);
    }
    
    @Test
    public void testSaveUser(){
        User user = new User();
        user.setUsername("mybatis dao user");
        int res = userDao.saveUser(user);
        System.out.println(res);
        System.out.println(user.getId());
    }
    
    @Test
    public void testUpdateUser(){
        User user = userDao.findById(50);
        user.setAddress("china---");
        int res = userDao.updateUser(user);
        System.out.println(res);
    }
    
    @Test
    public void testDeleteUser(){
        int res = userDao.deleteUser(64);
        System.out.println(res);
    }
    
    @Test
    public void testFindByName(){
        List<User> users = userDao.findByName("王");
        for(User user:users){
            System.out.println(user);
        }
    }
    
    @Test
    public void testFindTotal(){
        int res = userDao.findTotal();
        System.out.println(res);
    }
    
    @Test
    public void testFindUserByVo(){
        QueryVo vo = new QueryVo();
        User user = new User();
        user.setUsername("%王%");
        vo.setUser(user);
        List<User> users = userDao.findUserByVo(vo);
        for(User u:users){
            System.out.println(u);
        }
    }
    
}

六、SqlMapConfig.xml配置文件
6.1、配置内容
6.1.1、SqlMapConfig.xml中的配置被容和顺序
-properties（属性） 
　　--property 
-settings（全局配置参数）
　　--setting 
-typeAliases（类型别名） 
　　--typeAliase 
　　--package 
-typeHandlers（类型处理器） 
-objectFactory（对象工厂） 
-plugins（插件） 
-environments（环境集合属性对象） 
　　--environment（环境子属性对象） 
　　　　---transactionManager（事务管理） 
　　　　---dataSource（数据源） 
-mappers（映射器） 
　　--mapper 
　　--package

6.2、properties(属性)
在使用 properties 标签配置时，我们可以采用两种方式指定属性配置。 

6.2.1、第一种

<properties>
    <property name="driver" value="${jdbc.driver}"></property>
    <property name="url" value="${jdbc.url}"></property>
    <property name="username" value="${jdbc.username}"></property>
    <property name="password" value="${jdbc.password}"></property>
</properties>
<!--下面修改成-->
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>

6.2.2、第二种   --->表达式语言
6.2.2.1、在classpath定义db.properties文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/eesy_mybatis
jdbc.username=root
jdbc.password=root

6.2.2.2、properties标签配置

<properties url="file:///F:\CODE_SPACE\SouceCode\ITHEIMA\Frameworks\mybatis\day02_02mybatisDAO\src\main\resources\jdbcConfig.properties">
      <!--  <property name="driver" value="com.mysql.jdbc.Driver"/>
      <property name="url" value="jdbc:mysql://localhost:3306/eesy_mybatis"/>
      <property name="username" value="root"/>
      <property name="password" value="root"/>-->
</properties>

6.2.2.3、此时dataSource标签就变成上面引用的配置

<property name="driver" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>

6.3、typeAliases(类型别名)
6.3.1、自定义别名

<typeAliases> 
    <!-- 单个别名定义 --> 
    <typeAlias alias="user" type="com.itheima.domain.User"/> 
    <!-- 批量别名定义，扫描整个包下的类，别名为类名（首字母大写或小写都可以） --> 
    <package name="com.itheima.domain"/> 
    <package name=" 其它包 "/> 
</typeAliases>

6.4、mappers(映射器)
6.4.1、<mapper resource=" "/>
　　使用相对于类路径的资源 
　　如：<mapper resource="com/itheima/dao/IUserDao.xml" />

6.4.2、<mapper class=" ">
　　使用 mapper 接口类路径 
　　如：<mapper class="com.itheima.dao.UserDao"/> 
　　注意：此种方法要求 mapper 接口名称和 mapper 映射文件名称相同，且放在同一个目录中。

6.4.3、<package name=" ">
　　注册指定包下的所有 mapper 接口 
　　如：<package name="cn.itcast.mybatis.mapper"/> 
　　注意：此种方法要求 mapper 接口名称和 mapper 映射文件名称相同，且放在同一个目录中。

执行流程分析：