首页 > 资讯 > 其他综合 > 正文

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

16-06-23 来源：[db:作者]

收藏我要投稿

1 mybatis开发过程

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

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

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

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

4、通过SqlSessionFactory获取SqlSession

5、通过SqlSession操作数据库

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

6、SqlSesion使用完成要关闭

2mybatis使用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标签中配置属性值
    -->
   <propertiesresource="db.properties">
      <!-- <property name=""value=""/> -->
   </properties>
  
   <!-- 定义别名 -->
   <typeAliases>
      <!--
      单个别名的定义
      alias：别名，type：别名映射的类型 -->
      <!-- <typeAliastype="cn.itcast.mybatis.po.User" alias="user"/> -->
      <!-- 批量别名定义
      指定包路径，自动扫描包下边的pojo，定义别名，别名默认为类名（首字母小写或大写）
       -->
      <packagename="cn.itcast.mybatis.po"/>
     
   </typeAliases>
  
   <!-- 和spring整合后 environments配置将废除-->
   <environmentsdefault="development">
      <environmentid="development">
      <!-- 使用jdbc事务管理-->
         <transactionManagertype="JDBC"/>
      <!-- 数据库连接池-->
         <dataSourcetype="POOLED">
            <propertyname="driver"value="${jdbc.driver}"/>
            <propertyname="url"value="${jdbc.url}"/>
            <propertyname="username"value="${jdbc.username}"/>
            <propertyname="password"value="${jdbc.password}"/>
         </dataSource>
      </environment>
   </environments>
  
   <!--加载mapper映射
   如果将和spring整合后，可以使用整合包中提供的mapper扫描器，此处的mappers不用配置了。
    -->
   <mappers>
      <!-- 通过resource引用mapper的映射文件 -->
      <mapperresource="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接口的全限定名
 -->
<mappernamespace="daoAndMapper">
<!--在mapper.xml文件中配置很多的sql语句，执行每个sql语句时，封装为MappedStatement对象
mapper.xml以statement为单位管理sql语句
 -->
 
   <!-- 根据id查询用户信息 -->
   <!--
      id：唯一标识一个statement
      #{}：表示一个占位符，如果#{}中传入简单类型的参数，#{}中的名称随意
      parameterType：输入参数的类型，通过#{}接收parameterType输入的参数
      resultType：输出结果类型，不管返回是多条还是单条，指定单条记录映射的pojo类型
    -->
   <selectid="findUserById"parameterType="int"resultType="cn.itcast.mybatis.po.User">
      SELECT * FROM USER WHERE id= #{id}
  
   </select>
  
   <!-- 根据用户名称查询用户信息，可能返回多条
   ${}：表示sql的拼接，通过${}接收参数，将参数的内容不加任何修饰拼接在sql中。
  
    -->
   <selectid="findUserByName"parameterType="java.lang.String"resultType="cn.itcast.mybatis.po.User">
      select * from user where usernamelike '%${value}%'
   </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()的结果类型
  
    -->
   <insertid="insertUser"parameterType="cn.itcast.mybatis.po.User">
      <selectKeykeyProperty="id"order="AFTER"resultType="int">
         select LAST_INSERT_ID()
      </selectKey>
     
      INSERT INTO USER(username,birthday,sex,address)VALUES(#{username},#{birthday},#{sex},#{address})
   </insert>
   <!-- 用户删除 -->
   <deleteid="deleteUser"parameterType="int">
    deletefrom 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>

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;



importorg.apache.ibatis.session.SqlSession;

importorg.apache.ibatis.session.SqlSessionFactory;



import cn.itcast.mybatis.po.User;



public class UserDaoImpl implements UserDao{



privateSqlSessionFactory sqlSessionFactory;



//将SqlSessionFactory注入

publicUserDaoImpl(SqlSessionFactory sqlSessionFactory) {

this.sqlSessionFactory= sqlSessionFactory;

}



@Override

publicUser findUserById(int id) throws Exception {



//创建SqlSession

SqlSessionsqlSession = sqlSessionFactory.openSession();



//根据id查询用户信息

Useruser = sqlSession.selectOne("daoAndMapper.findUserById",id);



sqlSession.close();



returnuser;



}



@Override

publicList findUserByUsername(String username) throws Exception {

//创建SqlSession

SqlSessionsqlSession = sqlSessionFactory.openSession();

Listlist = sqlSession.selectList("daoAndMapper.findUserByName",username);

sqlSession.close();

returnlist;

}



@Override

publicvoid insertUser(User user) throws Exception {

//创建SqlSession

SqlSessionsqlSession = 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;

importorg.apache.ibatis.session.SqlSessionFactoryBuilder;

import org.junit.Before;

import org.junit.Test;



import cn.itcast.mybatis.po.User;



public class UserDaoImplTest {



//会话工厂

privateSqlSessionFactory sqlSessionFactory;



//创建工厂

@Before

publicvoid init() throws IOException {



//配置文件（SqlMapConfig.xml）

Stringresource = "SqlMapConfig.xml";



//加载配置文件到输入流

InputStreaminputStream = Resources.getResourceAsStream(resource);



//创建会话工厂

sqlSessionFactory= new SqlSessionFactoryBuilder().build(inputStream);



}



@Test

publicvoid testFindUserById() throws Exception {



UserDaouserDao = new UserDaoImpl(sqlSessionFactory);



Useruser = userDao.findUserById(1);

System.out.println(user);



}



@Test

publicvoid testFindUserByUsername() throws Exception {

UserDaouserDao = new UserDaoImpl(sqlSessionFactory);

ListuserList = userDao.findUserByUsername("小明");

for(User user : userList) {

System.out.println(user.getUsername());

}

}



@Test

publicvoid testInsertUser() throws Exception {

UserDaouserDao = new UserDaoImpl(sqlSessionFactory);

Useruser = new User();

user.setUsername("小小明");

user.setAddress("天津市滨海新区五大道6号");

user.setBirthday(newDate());

user.setSex("男");

userDao.insertUser(user);

}

}

3mybatis使用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接口的全限定名

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

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

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

"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接口的权限定名

<?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文件中配置很多的sql语句，执行每个sql语句时，封装为MappedStatement对象
mapper.xml以statement为单位管理sql语句
 -->
  
   <!-- 将用户查询条件定义为sql片段
   建议对单表的查询条件单独抽取sql片段，提高公用性
   注意：不要将where标签放在sql片段
     -->
   <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 and ids!=''">
             <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>
             -->
            <!-- 还有其他的查询条件 -->
 
   </sql>
 
   <!-- 定义resultMap，列名和属性名映射配置
   id：mapper.xml中的唯一标识
   type：最终要映射的pojo类型
    -->
   <resultMapid="userListResultMap"type="user">
      <!-- 列名
      id_,username_,birthday_
      id：要映射结果集的唯一标识，称为主键
      column：结果集的列名
      property：type指定的哪个属性中
       -->
       <idcolumn="id_"property="id"/>
       <!-- result就是普通列的映射配置 -->
       <resultcolumn="username_"property="username"/>
       <resultcolumn="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中。
  
    -->
   <selectid="findUserByName"parameterType="java.lang.String"resultType="cn.itcast.mybatis.po.User">
      select * from user where usernamelike '%${value}%'
   </select>
  
   <!-- 自定义查询条件查询用户的信息
   parameterType：指定包装类型
   %${userCustom.username}%：userCustom是userQueryVo中的属性，通过OGNL获取属性的值
    -->
   <selectid="findUserList"parameterType="userQueryVo"resultType="user">
  
      select id,username,birthday fromuser
      <!-- where标签相当于where关键字，可以自动去除第一个and -->
      <where>
         <!-- 引用sql片段，如果sql片段和引用处不在同一个mapper必须前边加namespace -->
         <includerefid="query_user_where"></include>
         <!-- 下边还有很其它的条件 -->
         <!-- <include refid="其它的sql片段"></include> -->
      </where>
     
     
     
   </select>
  
   <!-- 使用resultMap作结果映射
   resultMap：如果引用resultMap的位置和resultMap的定义在同一个mapper.xml，
   直接使用resultMap的id，如果不在同一个mapper.xml要在resultMap的id前边加namespace
  
    -->
   <selectid="findUserListResultMap"parameterType="userQueryVo"resultMap="userListResultMap">
  
      select id id_,usernameusername_,birthday birthday_ from user whereusername like'%${userCustom.username}%'
   </select>
  
   <!-- 输出简单类型
   功能：自定义查询条件，返回查询记录个数，通常用于实现查询分页
    -->
    <selectid="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()的结果类型
  
    -->
   <insertid="insertUser"parameterType="cn.itcast.mybatis.po.User">
      <selectKeykeyProperty="id"order="AFTER"resultType="int">
         select LAST_INSERT_ID()
      </selectKey>
     
      INSERT INTO USER(username,birthday,sex,address)VALUES(#{username},#{birthday},#{sex},#{address})
   </insert>
   <!-- 用户删除 -->
   <deleteid="deleteUser"parameterType="int">
    deletefrom 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查询用户信息

publicUser findUserById(int id) throws Exception;



//根据用户名称 查询用户信息

publicList findUserByName(String username) throws Exception;



//自定义查询条件查询用户信息

publicList findUserList(UserQueryVo userQueryVo) throws Exception;



//查询用户，使用resultMap进行映射

publicList findUserListResultMap(UserQueryVo userQueryVo)throwsException;

//查询用户，返回记录个数

publicint findUserCount(UserQueryVo userQueryVo) throws Exception;

//插入用户

publicvoid insertUser(User user)throws Exception;

//删除用户

publicvoid deleteUser(int id) throws Exception;

//修改用户

publicvoid 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标签中配置属性值
    -->
   <propertiesresource="db.properties">
      <!-- <property name=""value=""/> -->
   </properties>
  
   <!-- 定义别名 -->
   <typeAliases>
      <!--
      单个别名的定义
      alias：别名，type：别名映射的类型 -->
      <!-- <typeAliastype="cn.itcast.mybatis.po.User" alias="user"/> -->
      <!-- 批量别名定义
      指定包路径，自动扫描包下边的pojo，定义别名，别名默认为类名（首字母小写或大写）
       -->
      <packagename="cn.itcast.mybatis.po"/>
     
   </typeAliases>
  
   <!-- 和spring整合后 environments配置将废除-->
   <environmentsdefault="development">
      <environmentid="development">
      <!-- 使用jdbc事务管理-->
         <transactionManagertype="JDBC"/>
      <!-- 数据库连接池-->
         <dataSourcetype="POOLED">
            <propertyname="driver"value="${jdbc.driver}"/>
            <propertyname="url"value="${jdbc.url}"/>
            <propertyname="username"value="${jdbc.username}"/>
            <propertyname="password"value="${jdbc.password}"/>
         </dataSource>
      </environment>
   </environments>
  
   <!--加载mapper映射
   如果将和spring整合后，可以使用整合包中提供的mapper扫描器，此处的mappers不用配置了。
    -->
   <mappers>
      <!-- 通过resource引用mapper的映射文件 -->
      <mapperresource="mapper/UserMapper.xml"/>
</mappers>
  
  
</configuration>

3.6 使用mapper代理的方式小结

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

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

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

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

select id,username,birthday fromuser

<>"query_user_where">

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;

importjava.util.List;

public class UserQueryVo {

//用户信息

private Useruser;

//自定义user的扩展对象

private UserCustomuserCustom;

//用户id集合

private Listids;

public User getUser() {

return user;

}

public void setUser(User user) {

this.user = user;

}

public UserCustom getUserCustom() {

return userCustom;

}

public void setUserCustom(UserCustomuserCustom) {

this.userCustom = userCustom;

}

public List getIds() {

return ids;

}

public void setIds(List ids) {

this.ids = ids;

}

UserCustom.java

packagecn.itcast.mybatis.po;

public class 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）

Stringresource = "SqlMapConfig.xml";



//加载配置文件到输入流

InputStreaminputStream = Resources.getResourceAsStream(resource);



//创建会话工厂

sqlSessionFactory= new SqlSessionFactoryBuilder().build(inputStream);



}



@Test

publicvoid testFindUserById() throws Exception {



SqlSessionsqlSession = sqlSessionFactory.openSession();

//创建代理对象

UserMapperuserMapper = sqlSession.getMapper(UserMapper.class);



Useruser = userMapper.findUserById(1);



System.out.println(user);



}



@Test

publicvoid testFindUserByUsername() throws Exception {



SqlSessionsqlSession = sqlSessionFactory.openSession();

//创建代理对象

UserMapperuserMapper = sqlSession.getMapper(UserMapper.class);



Listlist = userMapper.findUserByName("小明");



System.out.println(list);



}



@Test

publicvoid testInsertUser() throws Exception {



SqlSessionsqlSession = sqlSessionFactory.openSession();

//创建代理对象

UserMapperuserMapper = sqlSession.getMapper(UserMapper.class);



//插入对象

Useruser = new User();

user.setUsername("李奎");

userMapper.insertUser(user);

sqlSession.commit();

sqlSession.close();



}



//通过包装类型查询用户信息

@Test

publicvoid testFindUserList() throws Exception {



SqlSessionsqlSession = sqlSessionFactory.openSession();

//创建代理对象

UserMapperuserMapper = sqlSession.getMapper(UserMapper.class);

//构造查询条件

UserQueryVouserQueryVo = new UserQueryVo();

UserCustomuserCustom = new UserCustom();

userCustom.setUsername("小明");

userCustom.setSex("1");

userQueryVo.setUserCustom(userCustom);



//id集合

Listids = new ArrayList();

ids.add(16);

ids.add(22);

userQueryVo.setIds(ids);



Listlist = userMapper.findUserList(userQueryVo);



sqlSession.close();



System.out.println(list);



}



//使用resultMap进行结果映射

@Test

publicvoid testFindUserListResultMap() throws Exception {



SqlSessionsqlSession = sqlSessionFactory.openSession();

//创建代理对象

UserMapperuserMapper = sqlSession.getMapper(UserMapper.class);

//构造查询条件

UserQueryVouserQueryVo = new UserQueryVo();



UserCustomuserCustom = new UserCustom();

userCustom.setUsername("小明");

userQueryVo.setUserCustom(userCustom);



Listlist = userMapper.findUserListResultMap(userQueryVo);



sqlSession.close();



System.out.println(list);



}



//返回查询记录总数

@Test

publicvoid testFindUserCount() throws Exception {



SqlSessionsqlSession = sqlSessionFactory.openSession();

//创建代理对象

UserMapperuserMapper = sqlSession.getMapper(UserMapper.class);

//构造查询条件

UserQueryVouserQueryVo = new UserQueryVo();

UserCustomuserCustom = new UserCustom();

userCustom.setUsername("小明");

userQueryVo.setUserCustom(userCustom);



intcount = 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!=''">
             <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>
             -->
            <!-- 还有很的查询条件 -->
 
   </sql>

4.3 引用sql片段

<!--自定义查询条件查询用户的信息
   parameterType：指定包装类型
   %${userCustom.username}%：userCustom是userQueryVo中的属性，通过OGNL获取属性的值
    -->
   <selectid="findUserList"parameterType="userQueryVo"resultType="user">
  
      select id,username,birthday fromuser
      <!-- where标签相当于where关键字，可以自动去除第一个and -->
      <where>
         <!-- 引用sql片段，如果sql片段和引用处不在同一个mapper必须前边加namespace -->
         <includerefid="query_user_where"></include>
         <!-- 下边还有很其它的条件 -->
         <!-- <include refid="其它的sql片段"></include> -->
      </where>
 
<!--输出简单类型
   功能：自定义查询条件，返回查询记录个数，通常用于实现查询分页
    -->
    <selectid="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>

4.4 动态sql中的foreach

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

需求：

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

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

UserQueryvo.java

PrivateList ids;

加上get()和set()方法

使用foreach遍历list：

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

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

#{id}

4.5 测试使用动态sql

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

//通过包装类型查询用户信息

@Test

publicvoid testFindUserList() throws Exception {



SqlSessionsqlSession = sqlSessionFactory.openSession();

//创建代理对象

UserMapperuserMapper = sqlSession.getMapper(UserMapper.class);

//构造查询条件

UserQueryVouserQueryVo = new UserQueryVo();

UserCustomuserCustom = new UserCustom();

userCustom.setUsername("小明");

userCustom.setSex("1");

userQueryVo.setUserCustom(userCustom);



//id集合

Listids = new ArrayList();

ids.add(16);

ids.add(22);

userQueryVo.setIds(ids);



Listlist = userMapper.findUserList(userQueryVo);



sqlSession.close();



System.out.println(list);



}



// 返回查询记录总数

@Test

publicvoid testFindUserCount() throws Exception {



SqlSessionsqlSession = sqlSessionFactory.openSession();

//创建代理对象

UserMapperuserMapper = sqlSession.getMapper(UserMapper.class);

//构造查询条件

UserQueryVouserQueryVo = new UserQueryVo();

UserCustomuserCustom = new UserCustom();

userCustom.setUsername("小明");

userQueryVo.setUserCustom(userCustom);



intcount = userMapper.findUserCount(userQueryVo);



sqlSession.close();



System.out.println(count);



}

点击复制链接与好友分享!回本站首页