Mybatis框架学习（二）—DAO开发方式和Mapper代理的开发方式

通过第一篇文章《Mybatis框架学习(一)—快速入门》我们基本上了解了mybatis是什么，mybatis的整体架构以及它解决了对于程序直接使用jdbc连接数据库所产生的问题。接下来讲下mybatis开发的两种方式，以及输入输出参数和动态sql相关的知识。

1  mybatis开发过程

1、编写mybatis的配置文件SqlMapConfig.xml

2、编写mybatis的映射文件mapper.xml

         这里主要是定义了statement和sql语句

3、编程通过配置文件创建SqlSessionFactory

4、通过SqlSessionFactory获取SqlSession

5、通过SqlSession操作数据库

         如果执行添加、更新、删除需要调用SqlSession.commit()

6、SqlSesion使用完成要关闭

2       mybatis使用DAO的开发方式

2.1   Mybatis的配置文件（sqlMapConfig.xml）

 <!DOCTYPEconfiguration
PUBLIC"-//mybatis.org//DTDConfig 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
 
   <!-- 属性定义
   加载一个properties文件
   在 properties标签中配置属性值
    -->
   <properties resource="db.properties">
   </properties>
 
   <!-- 定义别名 -->
   <typeAliases>
      <!--
      单个别名的定义
      alias：别名，type：别名映射的类型 -->
      <!-- <typeAliastype="cn.itcast.mybatis.po.User" alias="user"/> -->
      <!--批量别名定义
      指定包路径，自动扫描包下边的pojo，定义别名，别名默认为类名（首字母小写或大写）
       -->
      <package name="cn.itcast.mybatis.po"/>
   </typeAliases>
  
   <!-- 和spring整合后 environments配置将废除-->
   <environments default="development">
      <environment id="development">
      <!--使用jdbc事务管理-->
         <transactionManager type="JDBC"/>
      <!--数据库连接池-->
         <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>
  
   <!--加载mapper映射
   如果将和spring整合后，可以使用整合包中提供的mapper扫描器，此处的mappers不用配置了。
    -->
   <mappers>
      <!--通过resource引用mapper的映射文件 -->
      <mapper resource="sqlmap/User.xml"/>
   </mappers>
</configuration>

2.2  数据库配置文件db.properties

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

2.3   Mybatis的映射文件user.xml文件

（这个映射文件的名字建议命名规则：表名+mapper.xml早期ibatis命名规则：表名.xml，这里我们先用user.xml一会使用mapper代理的方式则改为userMapper.xml）

 <?xmlversion="1.0"encoding="UTF-8"?>
<!DOCTYPEmapper
PUBLIC"-//mybatis.org//DTDMapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace命名空间，为了对sql语句进行隔离，方便管理，mapper开发dao方式，使用namespace有特殊作用
mapper代理开发时将namespace指定为mapper接口的全限定名
 -->
<mapper namespace ="daoAndMapper">
<!--在mapper.xml文件中配置很多的sql语句，执行每个sql语句时，封装为MappedStatement对象
mapper.xml以statement为单位管理sql语句
 -->
 
   <!-- 根据id查询用户信息 -->
   <!--
      id：唯一标识一个statement
      #{}：表示一个占位符，如果#{}中传入简单类型的参数，#{}中的名称随意
      parameterType：输入参数的类型，通过#{}接收parameterType输入的参数
      resultType：输出结果类型，不管返回是多条还是单条，指定单条记录映射的pojo类型
    -->
   <select id="findUserById" parameterType="int" resultType="cn.itcast.mybatis.po.User">
      SELECT * FROM USER WHERE id= #{id}
   </select>
     <!--根据用户名称查询用户信息，可能返回多条
   ${}：表示sql的拼接，通过${}接收参数，将参数的内容不加任何修饰拼接在sql中。
    -->
   <select id="findUserByName" parameterType="java.lang.String" resultType ="cn.itcast.mybatis.po.User">
      select * from user where username like '%${value}%'
   </select>
   <!-- 添加用户
   parameterType：输入参数的类型，User对象包括username,birthday,sex,address
   #{}接收pojo数据，可以使用OGNL解析出pojo的属性值
   selectKey：用于进行主键返回，定义了获取主键值的sql
   order：设置selectKey中sql执行的顺序，相对于insert语句来说
   keyProperty：将主键值设置到哪个属性
   resultType：select LAST_INSERT_ID()的结果类型
  
    -->
   <insert id="insertUser" parameterType="cn.itcast.mybatis.po.User">
      <selectKey keyProperty="id" order="AFTER" resultType="int">
         select LAST_INSERT_ID()
      </selectKey>
      INSERT INTO USER(username,birthday,sex,address) VALUES (#{username},#{birthday},#{sex},#{address})
   </insert>
   <!-- 用户删除 -->
   <delete id="deleteUser" parameterType ="int">
    delete from user where id=#{id}
   </delete>
   <!-- 用户更新
   要求：传入的user对象中包括 id属性值
   -->
   <update id="updateUser" parameterType="cn.itcast.mybatis.po.User">
      update user set username=#{username},birthday=#{birthday},sex=#{sex},address=#{address}where id=#{id}
   </update>
</mapper>

2.4  DAO接口

package cn.itcast.mybatis.dao;
 
import java.util.List;
 
import cn.itcast.mybatis.po.User;
 
 
public interface UserDao {
        
         //根据id查询用户信息
         publicUser findUserById(int id) throws Exception;
         //根据用户名称模糊查询用户列表
         publicList<User> findUserByUsername(String username) throws Exception;
         //插入用户
         publicvoid insertUser(User user) throws Exception;
 
}

2.5  DAO接口实现类

package cn.itcast.mybatis.dao;
 
import java.util.List;
 
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
 
import cn.itcast.mybatis.po.User;
 
public class UserDaoImpl implements UserDao{
 
         private SqlSessionFactory sqlSessionFactory;
 
         //将SqlSessionFactory注入
         public UserDaoImpl(SqlSessionFactory sqlSessionFactory) {
                   this.sqlSessionFactory= sqlSessionFactory;
         }
 
         @Override
         public User findUserById(int id) throws Exception {
 
                   //创建SqlSession
                   SqlSession sqlSession = sqlSessionFactory.openSession();
                   //根据id查询用户信息
                   Useruser = sqlSession.selectOne("daoAndMapper.findUserById",id);
                   sqlSession.close();
                   returnuser;
 
         }
 
         @Override
         public List<User> findUserByUsername(String username) throws Exception {
                   //创建SqlSession
                   SqlSession sqlSession = sqlSessionFactory.openSession();
                   List<User> list = sqlSession.selectList("daoAndMapper.findUserByName",username);
                   sqlSession.close();
                   returnlist;
         }
 
         @Override
         publicvoid insertUser(User user) throws Exception {
                   //创建SqlSession
                   SqlSession sqlSession = sqlSessionFactory.openSession();
                   sqlSession.insert("daoAndMapper.insertUser", user);
                   sqlSession.commit();
                    //关闭SqlSession
                   sqlSession.close();
                  
         }
 
}

2.6  DAO方式测试类 UserDaoImplTest.java

package cn.itcast.mybatis.dao;
 
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;
 
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;
 
import cn.itcast.mybatis.po.User;
 
public class UserDaoImplTest {
 
         //会话工厂
         private SqlSessionFactory sqlSessionFactory;
 
         //创建工厂
         @Before
         public void init() throws IOException {
 
                   //配置文件（SqlMapConfig.xml）
                   String resource = "SqlMapConfig.xml";
 
                   //加载配置文件到输入流
                   InputStream inputStream = Resources.getResourceAsStream(resource);
 
                   //创建会话工厂
                   sqlSessionFactory= new SqlSessionFactoryBuilder().build(inputStream);
 
         }
 
         @Test
         public void testFindUserById() throws Exception {
 
                   UserDao userDao = new UserDaoImpl(sqlSessionFactory);
                   User user = userDao.findUserById(1);
                   System.out.println(user);
 
         }
 
         @Test
         public void testFindUserByUsername() throws Exception {
                   UserDao userDao = new UserDaoImpl(sqlSessionFactory);
                   List<User> userList = userDao.findUserByUsername("小明");
                   for(User user : userList) {
                            System.out.println(user.getUsername());
                   }
         }
 
         @Test
         public void testInsertUser() throws Exception {
                   UserDao userDao = new UserDaoImpl(sqlSessionFactory);
                   User user = new User();
                   user.setUsername("小小明");
                   user.setAddress("天津市滨海新区五大道6号");
                   user.setBirthday(newDate());
                   user.setSex("男");
                   userDao.insertUser(user);
         }
}

3      mybatis使用mapper代理的开发方式

mapper代理的方式使得程序员只需要写dao接口，dao接口实现则由mybatis自动生成代理对象。

3.1 使用DAO开发方式存在的问题

1、dao的实现类中存在重复代码，整个mybatis操作的过程代码模板重复（先创建sqlsession、调用sqlsession的方法、关闭sqlsession）

2、dao的实现类中存在硬编码，调用sqlsession方法时将statement的id硬编码。

3.2 使用mapper代理开发规范

要想让mybatis自动创建dao接口实现类的代理对象，必须遵循一些规则：

 

1、  mapper.xml中namespace指定为mapper接口的全限定名

<?xmlversion="1.0"encoding="UTF-8"?>

<!DOCTYPEmapper

PUBLIC"-//mybatis.org//DTDMapper 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!--namespace命名空间，为了对sql语句进行隔离，方便管理，mapper开发dao方式，使用namespace有特殊作用

mapper代理开发时将namespace指定为mapper接口的全限定名

 -->

<mappernamespace="cn.itcast.mybatis.mapper.UserMapper">

此步骤目的：通过mapper.xml和mapper.java进行关联。

 

2、mapper.xml中statement的id就是mapper.java中的方法名

 

3、mapper.xml中statement的parameterType和mapper.java中的方法输入参数类型一致

 

4、mapper.xml中statement的resultType和mapper.java中方法返回值类型一致.

3.3  mybatis的映射文件（UserMapper.xml）

这里我们对mapper映射文件的命名方式使用mybatis的建议：表名+Mapper.xml

namespace制定为mapper接口的全限定名

<?xml version="1.0"encoding="UTF-8"?>
<!DOCTYPEmapper
PUBLIC"-//mybatis.org//DTDMapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace命名空间，为了对sql语句进行隔离，方便管理，mapper开发dao方式，使用namespace有特殊作用
mapper代理开发时将namespace指定为mapper接口的全限定名
 -->
<mapper namespace="cn.itcast.mybatis.mapper.UserMapper">
<!--在mapper.xml文件中配置很多的sql语句，执行每个sql语句时，封装为MappedStatement对象
mapper.xml以statement为单位管理sql语句
 -->
  
   <!-- 将用户查询条件定义为sql片段
   建议对单表的查询条件单独抽取sql片段，提高公用性
   注意：不要将where标签放在sql片段
     -->
   <sql id="query_user_where">
         <!-- 如果 userQueryVo中传入查询条件，再进行sql拼接-->
         <!-- test中userCustom.username表示从userQueryVo读取属性值-->
         <if test="userCustom!=null">
            <if test="userCustom.username!=null anduserCustom.username!=''">
                and username like'%${userCustom.username}%'
            </if>
            <if test="userCustom.sex!=null and userCustom.sex!=''">
                and sex = #{userCustom.sex}
            </if>
         </if>
<!--根据id集合查询用户信息 -->
            <!-- 最终拼接的效果：
            SELECT id ,username,birthday  FROM USER WHEREusernameLIKE '%小明%' AND id IN (16,22,25)
            collection：集合的属性
            open：开始循环拼接的串
            close：结束循环拼接的串
            item：每次循环取到的对象
            separator：每两次循环中间拼接的串
             -->
            <if test="ids!=null and ids!=''">
             <foreach collection="ids"open=" AND id IN ( "close=")"item="id"separator=",">
               #{id}
             </foreach>
             </if>         <!--
             SELECT id ,username ,birthday  FROM USER WHEREusername LIKE '%小明%' AND (id = 16 OR id = 22 OR id =25)
             <foreach collection="ids" open=" AND ( "close=")" item="id" separator="OR">
               id =#{id}
             </foreach>
             -->
            <!-- 还有其他的查询条件 -->
 
   </sql>
 
   <!-- 定义resultMap，列名和属性名映射配置
   id：mapper.xml中的唯一标识
   type：最终要映射的pojo类型
    -->
   <resultMap id="userListResultMap"type="user">
      <!--列名
      id_,username_,birthday_
      id：要映射结果集的唯一标识，称为主键
      column：结果集的列名
      property：type指定的哪个属性中
       -->
       <id column="id_" property="id"/>
       <!-- result就是普通列的映射配置 -->
       <result column="username_" property="username"/>
       <result column="birthday_" property="birthday"/>
   </resultMap>
 
   <!-- 根据id查询用户信息 -->
   <!--
      id：唯一标识一个statement
      #{}：表示一个占位符，如果#{}中传入简单类型的参数，#{}中的名称随意
      parameterType：输入参数的类型，通过#{}接收parameterType输入的参数
      resultType：输出结果类型，不管返回是多条还是单条，指定单条记录映射的pojo类型
    -->
   <selectid="findUserById" parameterType="int" resultType="user">
      SELECT * FROM USER WHERE id= #{id}
   </select>
  
   <!-- 根据用户名称查询用户信息，可能返回多条
   ${}：表示sql的拼接，通过${}接收参数，将参数的内容不加任何修饰拼接在sql中。
  
    -->
   <select id="findUserByName" parameterType="java.lang.String" resultType="cn.itcast.mybatis.po.User">
      select * from user where usernamelike '%${value}%'
   </select>
  
   <!-- 自定义查询条件查询用户的信息
   parameterType：指定包装类型
   %${userCustom.username}%：userCustom是userQueryVo中的属性，通过OGNL获取属性的值
    -->
   <select id="findUserList" parameterType="userQueryVo" resultType="user">
  
      select id,username,birthday from user
      <!-- where标签相当于where关键字，可以自动去除第一个and -->
      <where>
         <!-- 引用sql片段，如果sql片段和引用处不在同一个mapper必须前边加namespace -->
         <include refid="query_user_where"></include>
         <!-- 下边还有很其它的条件 -->
         <!-- <include refid="其它的sql片段"></include> -->
      </where>
   
   </select>
  
   <!-- 使用resultMap作结果映射
   resultMap：如果引用resultMap的位置和resultMap的定义在同一个mapper.xml，
   直接使用resultMap的id，如果不在同一个mapper.xml要在resultMap的id前边加namespace-->
   <select id="findUserListResultMap"parameterType="userQueryVo"resultMap="userListResultMap">
  
      select id id_,username username_,birthday birthday_ from user where username like'%${userCustom.username}%'
   </select>
  
   <!-- 输出简单类型
   功能：自定义查询条件，返回查询记录个数，通常用于实现查询分页
    -->
    <select id="findUserCount" parameterType="userQueryVo" resultType="int">
      select count(*) from user
      <!-- where标签相当于where关键字，可以自动去除第一个and -->
      <where>
         <!-- 引用sql片段，如果sql片段和引用处不在同一个mapper必须前边加namespace -->
         <includerefid="query_user_where"></include>
         <!-- 下边还有很其它的条件 -->
         <!-- <include refid="其它的sql片段"></include> -->
      </where>
    </select>
  
   <!-- 添加用户
   parameterType：输入参数的类型，User对象包括username,birthday,sex,address
   #{}接收pojo数据，可以使用OGNL解析出pojo的属性值
   #{username}表示从parameterType中获取pojo的属性值
   selectKey：用于进行主键返回，定义了获取主键值的sql
   order：设置selectKey中sql执行的顺序，相对于insert语句来说
   keyProperty：将主键值设置到哪个属性
   resultType：select LAST_INSERT_ID()的结果类型
  
    -->
   <insert id="insertUser" parameterType="cn.itcast.mybatis.po.User">
      <selectKey keyProperty="id" order="AFTER" resultType="int">
         select LAST_INSERT_ID()
      </selectKey>
     
      INSERT INTO USER(username,birthday,sex,address)VALUES(#{username},#{birthday},#{sex},#{address})
   </insert>
   <!-- 用户删除 -->
   <delete id="deleteUser" parameterType="int">
    delete from user where id=#{id}
   </delete>
   <!-- 用户更新
   要求：传入的user对象中包括 id属性值
   -->
   <updateid="updateUser"parameterType="cn.itcast.mybatis.po.User">
      update user set username=#{username},birthday=#{birthday},sex=#{sex},address=#{address}where id=#{id}
   </update>
 
</mapper>

3.4  mapper接口（UserMapper.java）

mybatis提出了mapper接口，相当 于dao 接口。

mapper接口的命名方式建议：表名+Mapper

package cn.itcast.mybatis.mapper;
 
import java.util.List;
 
import cn.itcast.mybatis.po.User;
import cn.itcast.mybatis.po.UserQueryVo;
 
 
public interface UserMapper {
        
         //根据用户id查询用户信息
         public User findUserById(int id) throws Exception;
        
         //根据用户名称  查询用户信息
         public List<User> findUserByName(String username) throws Exception;
        
         //自定义查询条件查询用户信息
         public List<User> findUserList(UserQueryVo userQueryVo) throws Exception;
        
         //查询用户，使用resultMap进行映射
         public List<User> findUserListResultMap(UserQueryVo userQueryVo)throwsException;
         //查询用户，返回记录个数
         public int findUserCount(UserQueryVo userQueryVo) throws Exception;
         //插入用户
         public void insertUser(User user)throws Exception;
         //删除用户
         publicvoid deleteUser(int id) throws Exception;
         //修改用户
         public void updateUser(User user) throws Exception;
 
}

3.5 在mybatis的配置文件SqlMapConfig.xml

<!DOCTYPEconfiguration
PUBLIC"-//mybatis.org//DTDConfig 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
 
   <!-- 属性定义
   加载一个properties文件
   在 properties标签中配置属性值
    -->
   <properties resource="db.properties">
      <!-- <property name=""value=""/> -->
   </properties>
  
   <!-- 定义别名 -->
   <typeAliases>
      <!--
      单个别名的定义
      alias：别名，type：别名映射的类型 -->
      <!-- <typeAliastype="cn.itcast.mybatis.po.User" alias="user"/> -->
      <!--批量别名定义
      指定包路径，自动扫描包下边的pojo，定义别名，别名默认为类名（首字母小写或大写）
       -->
      <package name="cn.itcast.mybatis.po"/>
     
   </typeAliases>
  
   <!-- 和spring整合后 environments配置将废除-->
   <environments default="development">
      <environment id="development">
      <!--使用jdbc事务管理-->
         <transactionManager type="JDBC"/>
      <!--数据库连接池-->
         <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>
  
   <!--加载mapper映射
   如果将和spring整合后，可以使用整合包中提供的mapper扫描器，此处的mappers不用配置了。
    -->
   <mappers>
      <!--通过resource引用mapper的映射文件 -->
      <mapper resource="mapper/UserMapper.xml"/>
</mappers>
  
</configuration>

3.6 使用mapper代理的方式小结

1、不管查询记录是单条还是多条，在statement中resultType定义一致，都是单条记录映射的pojo类型。

mapper接口方法返回值，如果是返回的单个对象，返回值类型是pojo类型，生成的代理对象内部通过selectOne获取记录，如果返回值类型是集合对象，生成的代理对象内部通过selectList获取记录。

2、使用mapper代理的方式开发，mapper接口方法输入参数只有一个，这个参数可以是简单的类型也可以是pojo（普通的java对象）类型或者是自定义的pojo包装类型如UserMapper.xml使用的自定义查询条件查询用户信息的例子：

 <!-- 自定义查询条件查询用户的信息

   parameterType：指定包装类型

   %${userCustom.username}%：userCustom是userQueryVo中的属性，通过OGNL获取属性的值

    -->

   <select id="findUserList" parameterType="userQueryVo" resultType="user">

      select id,username,birthday fromuser

      <!-- where标签相当于where关键字，可以自动去除第一个and -->

      <where>

         <!-- 引用sql片段，如果sql片段和引用处不在同一个mapper必须前边加namespace -->

         <include refid="query_user_where"></include>

         <!-- 下边还有很其它的条件 -->

         <!-- <include refid="其它的sql片段"></include> -->

      </where>

   </select>

3、输入映射resultType和resultMap之间的区别

resultType ：指定输出结果的类型（pojo、简单类型、hashmap等），将sql查询结果映射为java对象 。

         使用resultType注意：sql查询的列名要和resultType指定pojo的属性名相同，指定相同属性方可映射成功，如果sql查询的列名和resultType指定pojo的属性名全部不相同，list中无法创建pojo对象的。

 

resultMap：将sql查询结果映射为java对象。

         如果sql查询列名和最终要映射的pojo的属性名不一致，使用resultMap将列名和pojo的属性名做一个对应关系 （列名和属性名映射配置）

3.7 自定义的包装类型

UserQueryVO.java

package cn.itcast.mybatis.po;
 
import java.util.List;
 
publicclass UserQueryVo {
  
   //用户信息
   private User user;
  
   //自定义user的扩展对象
   private UserCustom userCustom;
  
   //用户id集合
   private List<Integer> ids;
 
   public User getUser() {
      returnuser;
   }
 
   publicvoid setUser(User user) {
      this.user = user;
   }
 
   public UserCustom getUserCustom() {
      returnuserCustom;
   }
 
   publicvoid setUserCustom(UserCustom userCustom) {
      this.userCustom = userCustom;
   }
 
   public List<Integer> getIds() {
      returnids;
   }
   publicvoid setIds(List<Integer> ids) {
      this.ids = ids;
   }
}

UserCustom.java

package cn.itcast.mybatis.po;
 
 
publicclass UserCustom extends User {
  
   //添加一些扩展字段
 
}

3.8 mapper代理的开发方式测试

UserMapperTest.java

package cn.itcast.mybatis.mapper;
 
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
 
import org.apache.ibatis.io.Resources;
importorg.apache.ibatis.session.SqlSession;
importorg.apache.ibatis.session.SqlSessionFactory;
importorg.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;
 
import cn.itcast.mybatis.po.User;
import cn.itcast.mybatis.po.UserCustom;
import cn.itcast.mybatis.po.UserQueryVo;
 
public class UserMapperTest {
 
         //会话工厂
         privateSqlSessionFactory sqlSessionFactory;
 
         //创建工厂
         @Before
         publicvoid init() throws IOException {
 
                   //配置文件（SqlMapConfig.xml）
                   String resource = "SqlMapConfig.xml";
 
                   //加载配置文件到输入流
                   InputStream inputStream = Resources.getResourceAsStream(resource);
 
                   //创建会话工厂
                   sqlSessionFactory= new SqlSessionFactoryBuilder().build(inputStream);
 
         }
 
         @Test
         public void testFindUserById() throws Exception {
 
                   SqlSession sqlSession = sqlSessionFactory.openSession();
                   //创建代理对象
                   UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
 
                   User user = userMapper.findUserById(1);
 
                   System.out.println(user);
 
         }
 
         @Test
         public void testFindUserByUsername() throws Exception {
 
                   SqlSession sqlSession = sqlSessionFactory.openSession();
                   //创建代理对象
                   UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
 
                   List<User> list = userMapper.findUserByName("小明");
 
                   System.out.println(list);
 
         }
 
         @Test
         public void testInsertUser() throws Exception {
 
                   SqlSession sqlSession = sqlSessionFactory.openSession();
                   //创建代理对象
                   UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
 
                   //插入对象
                   User user = new User();
                   user.setUsername("李奎");
                   userMapper.insertUser(user);
                   sqlSession.commit();
                   sqlSession.close();
 
         }
 
         //通过包装类型查询用户信息
         @Test
         public void testFindUserList() throws Exception {
 
                   SqlSession sqlSession = sqlSessionFactory.openSession();
                   //创建代理对象
                   UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
                   //构造查询条件
                   UserQueryVo userQueryVo = new UserQueryVo();
                   UserCustom userCustom = new UserCustom();
                   userCustom.setUsername("小明");
                   userCustom.setSex("1");
                   userQueryVo.setUserCustom(userCustom);
                  
                   //id集合
                   List<Integer> ids  = new ArrayList<Integer>();
                   ids.add(16);
                   ids.add(22);
                   userQueryVo.setIds(ids);
 
                   List<User>list = userMapper.findUserList(userQueryVo);
 
                   sqlSession.close();
 
                   System.out.println(list);
 
         }
 
         //使用resultMap进行结果映射
         @Test
         public void testFindUserListResultMap() throws Exception {
 
                   SqlSession sqlSession = sqlSessionFactory.openSession();
                   //创建代理对象
                   UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
                   //构造查询条件
                   UserQueryVo userQueryVo = new UserQueryVo();
                  
                   UserCustom userCustom = new UserCustom();
                   userCustom.setUsername("小明");
                   userQueryVo.setUserCustom(userCustom);
 
                   List<User> list = userMapper.findUserListResultMap(userQueryVo);
 
                   sqlSession.close();
 
                   System.out.println(list);
 
         }
 
         //返回查询记录总数
         @Test
         public void testFindUserCount() throws Exception {
 
                   SqlSession sqlSession = sqlSessionFactory.openSession();
                   //创建代理对象
                   UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
                   //构造查询条件
                   UserQueryVo userQueryVo = new UserQueryVo();
                   UserCustom userCustom = new UserCustom();
                   userCustom.setUsername("小明");
                   userQueryVo.setUserCustom(userCustom);
 
                   int count = userMapper.findUserCount(userQueryVo);
 
                   sqlSession.close();
 
                   System.out.println(count);
 
         }
 
}

3.9整个工程的目录如下：

4 mapper.xml文件使用动态sql

mybatis重点是对sql的灵活解析和处理。

4.1 需求

将自定义查询条件查询用户列表和查询用户列表总记录数这两个方法改为动态sql

4.2 sql片段和sql片段的定义

sql片段：是将通用的sql语句抽取出来，单独定义，在其它的statement中可以引用

<sqlid="query_user_where">

         <!-- 如果 userQueryVo中传入查询条件，再进行sql拼接-->

         <!-- test中userCustom.username表示从userQueryVo读取属性值-->

         <iftest="userCustom!=null">

            <iftest="userCustom.username!=null anduserCustom.username!=''">

                and username like'%${userCustom.username}%'

            </if>

            <iftest="userCustom.sex!=null and userCustom.sex!=''">

                and sex = #{userCustom.sex}

            </if>

         </if>

<!--根据id集合查询用户信息 -->

            <!-- 最终拼接的效果：

            SELECT id ,username,birthday  FROM USER WHEREusernameLIKE '%小明%' AND id IN (16,22,25)

            collection：集合的属性

            open：开始循环拼接的串

            close：结束循环拼接的串

            item：每次循环取到的对象

            separator：每两次循环中间拼接的串

             -->

             <iftest="ids!=null andids!=''">

             <foreach collection="ids"open=" AND id IN ( "close=")"item="id"separator=",">

               #{id}

             </foreach>

             </if>

             <!--

             SELECT id ,username ,birthday  FROM USER WHEREusername LIKE '%小明%' AND (id = 16 OR id = 22 OR id =25)

             <foreach collection="ids" open=" AND ( "close=")" item="id" separator="OR">

               id =#{id}

             </foreach>

             -->

            <!-- 还有很的查询条件 -->

   </sql>

4.3 引用sql片段

<!--自定义查询条件查询用户的信息

   parameterType：指定包装类型

   %${userCustom.username}%：userCustom是userQueryVo中的属性，通过OGNL获取属性的值

    -->

   <select id="findUserList"parameterType="userQueryVo"resultType="user">

  

      select id,username,birthday fromuser

      <!-- where标签相当于where关键字，可以自动去除第一个and -->

      <where>

         <!-- 引用sql片段，如果sql片段和引用处不在同一个mapper必须前边加namespace -->

         <include refid="query_user_where"></include>

         <!-- 下边还有很其它的条件 -->

         <!-- <include refid="其它的sql片段"></include> -->

      </where>

 

<!--输出简单类型

   功能：自定义查询条件，返回查询记录个数，通常用于实现查询分页

    -->

    <select id="findUserCount"parameterType="userQueryVo"resultType="int">

      select count(*) from user

      <!-- where标签相当于where关键字，可以自动去除第一个and -->

      <where>

         <!-- 引用sql片段，如果sql片段和引用处不在同一个mapper必须前边加namespace -->

         <include refid="query_user_where"></include>

         <!-- 下边还有很其它的条件 -->

         <!-- <include refid="其它的sql片段"></include> -->

      </where>

    </select>

4.4 动态sql中的foreach

在statement通过foreach遍历parameterType中的集合类型。

 

需求：

根据多个用户id查询用户信息。

在userQueryvo中定义list<Integer> ids存储多个id

UserQueryvo.java

PrivateList<Integer> ids;

加上get()和set()方法

使用foreach遍历list：

<!--根据id集合查询用户信息 -->

            <!-- 最终拼接的效果：

            SELECT id ,username,birthday  FROM USER WHEREusernameLIKE '%小明%' AND id IN (16,22,25)

            collection：集合的属性

            open：开始循环拼接的串

            close：结束循环拼接的串

            item：每次循环取到的对象

            separator：每两次循环中间拼接的串

             -->

             <iftest="ids!=null andids!=''">

             <foreachcollection="ids"open=" AND id IN ( "close=")"item="id"separator=",">

               #{id}

             </foreach>

             </if>

             <!--

             SELECT id ,username ,birthday  FROM USER WHEREusername LIKE '%小明%' AND (id = 16 OR id = 22 OR id =25)

             <foreach collection="ids" open=" AND ( "close=")" item="id" separator="OR">

               id =#{id}

             </foreach>

             -->

            <!-- 还有很的查询条件 -->

4.5 测试使用动态sql

UserMapperTest.java里面的testFindUserList()和testFindUserCount()这两个方法

     //通过包装类型查询用户信息
         @Test
         public void testFindUserList() throws Exception {
 
                   SqlSession sqlSession = sqlSessionFactory.openSession();
                   //创建代理对象
                   UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
                   //构造查询条件
                   UserQueryVo userQueryVo = new UserQueryVo();
                   UserCustom userCustom = new UserCustom();
                   userCustom.setUsername("小明");
                   userCustom.setSex("1");
                   userQueryVo.setUserCustom(userCustom);
                  
                   //id集合
                   List<Integer> ids  = new ArrayList<Integer>();
                   ids.add(16);
                   ids.add(22);
                   userQueryVo.setIds(ids);
 
                   List<User> list = userMapper.findUserList(userQueryVo);
 
                   sqlSession.close();
 
                   System.out.println(list);
 
         }
 
// 返回查询记录总数
         @Test
         public void testFindUserCount() throws Exception {
 
                   SqlSession sqlSession = sqlSessionFactory.openSession();
                   //创建代理对象
                   UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
                   //构造查询条件
                   UserQueryVo userQueryVo = new UserQueryVo();
                   UserCustom userCustom = new UserCustom();
                   userCustom.setUsername("小明");
                   userQueryVo.setUserCustom(userCustom);
 
                   int count = userMapper.findUserCount(userQueryVo);
 
                   sqlSession.close();
 
                   System.out.println(count);
 
         }