通过iBatis的queryForMap方法比较resultClass与resultMap

最新推荐文章于 2023-11-08 17:43:09 发布

zouxuhong

最新推荐文章于 2023-11-08 17:43:09 发布

阅读量1.5w

点赞数

分类专栏： ibatis 文章标签： ibatis user hashmap 数据库 null object

ibatis 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Batis的返回值参数类型也有种：resultMap与resultClass

这两种类型的选择可以用两句话说明之：

一：当结果集列名和类的属性名完全相对应的时候，则可直接用resultClass直接指定查询结果类型。

二：当查询结果集与属性名对应不上的时候，就可以采用resultMap指定列名与对象属性名之间的对应关系，否则对应不上的属性将为null或0.

resultMap映射结果的目的就是要将查询的结果集绑定到映射对象的属性上。其实对于这种情况用resultClass也是可以解决的，
就是直接在Sql语句中采用as重命名的方式将结果集中与对象属性名不相同的字段用as重命名。

对于resultMap和resultClass有个很有趣的例子：

iBatis的查询方法中有这样一个查询方法：

暂且不说这个方法是什么，假使我们有这样的需求，数据库中很多条数据，有一个字段假使是name，每一条数据映射我们一个实体对象

我们的需求是将所有的数据查询出来，根据不同的name属性值要做不同的处理。

首先想到的肯定是先将所有的数据查询出来而不是根据不同的name重复查询多次，将所有的数据查询出来也有两种方式，

第一种我们常用的List<?>集合的形式，另一种Map<?,?>的形式。

就这个需求而言显然是直接查询出Map<?,?>比较还一点，这样我们就可以直接在程序中根据已知的name找到对应的对象，而不必循环遍历。

这样的需求可能不多，这儿就就事论事一回吧。

第一个方法：
public java.util.Map queryForMap(java.lang.String id,
java.lang.Object parameterObject,
java.lang.String keyProp)throws java.sql.SQLException

该方法有三个参数，第一个是statement，第二个是查询入参，第三个是返回的Map集合的key属性。

    public Map<String, User> getUserMap2() throws SQLException
    {
        return sqlMapClient.queryForMap("User.queryForMap2", null, "userID");
    }

Dao里面有这样两个方法，第一个作用就是查询出所有的User对象，以User对象的userID为key存放到Map集合中返回。

xml映射文件：
<select id="queryForMap2" resultClass="java.util.HashMap">//注意此处不能写java.util.Map，必须是具体的实现类，否则iBatis无法实例化
select * from t_user
</select>

测试代码：
Map<String, User> user = dao.getUserMap2();
System.out.println(user);

查询Map结果：
{null={AGE=28, USERID=6, USERNAME=zhangbo}}//输出结果十分诡异，数据库里面有六条数据，为什么只查询出来最后一条，而且key还是null

而且value并不是一个User对象，User对象的里面没有USERNAME的属性，{AGE=28, USERID=6, USERNAME=zhangbo}只是数据库里面的一条数据而已。
Map<String, User> user = dao.getUserMap2();
System.out.println(user);

User user2 = user.get(null);
//尝试从Map中获取key为null的User对象，抛类型转换异常，即Map里面的根本不是User对象，因为User对象根本没有username的属性。
System.out.println(user2.getName());

设置将Map<String, User>中的User写成任何类型都没有问题。即：
Map<String, String> user = dao.getUserMap2();
System.out.println(user);
执行输出结果和是一样的。

为什么？其实iBatis底层的确是不知道我有个User类型的对象，那么它是怎么将数据库数据映射的呢？
其实关于key为null可不可以这样理解：
我在Dao里面这样写的 return sqlMapClient.queryForMap("User.queryForMap2", null, "userID");
指定Map集合的key的名称为“userID”，我想的是拿User对象的“userID”作为key，但是iBatis根本就不知道User对象是个什么东西，映射文件
里面根本就没有哪儿出现过User对象，因为映射文件指定的resultClass是java.util.HashMap，哪儿有userID的属性。
关于查询出来的数据只有最后一条数可以这样理解的：
iBatis的queryForMap()方法，其实也是先根据条件查询出一个List集合，然后遍历List集合，将对象以Key，Value的形式存入Map中返回。
其实List集合确实查询了数据库满足条件的6条数据，只是这6条数据指定的key都为null。遍历的时候先将List中的第一条以key为null的形式
存入Map中，然后又将第二条再以key为null放入Map中，显而易见，key相同，相当于替换了第一条，以此类推，Map中始终只能只有最后一条数据了。

至于key为什么是null，一时我说不上来。有待研究！肯定一个根本的原因就是使用了resultClass，而HashMap又没有“userID”属性？？？

那么我们不妨来试一下使用一下resultMap，并给HashMap指定属性：
<resultMap class="java.util.HashMap" id="resultMap-UserMap2">
  <result property="userID" column="userID"/>
  <result property="username" column="username"/>
  <result property="userage" column="age"/>
</resultMap>
<select id="queryForMap2" parameterClass="java.lang.String" resultMap="resultMap-UserMap2">
  select * from t_user
</select>

public Map<String, User> getUserMap2() throws SQLException
{
      return sqlMapClient.queryForMap("User.queryForMap2", null, "userID");
}
这样一来，我们就指定了数据库字段与实体对象之间的映射，先来看一下执行结果：
{
3={userID=3, username=zhangbo, userage=25},

5={userID=5, username=zhangbo, userage=27},
2={userID=2, username=zhangbo, userage=24},
4={userID=4, username=zhangbo, userage=26},
6={userID=6, username=zhangbo, userage=28},
1={userID=1, username=zhangbo, userage=23}
}
输出结果似乎是正确的，有两个疑问，为什么顺序是乱的？value真的是Map<String, User>中的User对象？
Map<String, User> user = dao.getUserMap2();
System.out.println(user);
User user2 = user.get("3");//抛类型转换异常，即Map里面的根本不是User对象，因为User对象根本没有username的属性。
System.out.println(user2.getName());

那么是不是如果我们的resultMap的xml中如果我们将数据库的字段映射成User的三个属性就不会再有类型转化异常了呢？
试一试：
<resultMap class="java.util.HashMap" id="resultMap-UserMap2">

<result property="userID" column="userID"/>
  <result property="name" column="username"/>
  <result property="age" column="age"/>
</resultMap>
<select id="queryForMap2" parameterClass="java.lang.String" resultMap="resultMap-UserMap2">
  select * from t_user
</select>

public Map<String, User> getUserMap2() throws SQLException
{
      return sqlMapClient.queryForMap("User.queryForMap2", null, "userID");
}

注：User对象的三个属性，userID, name, age。

好的，以上xml映射文件中将数据库字段映射到User对象的三个属性上，而且返回resultClass依然是java.util.HashMap。
我们的目的是将数据库中的数据查询出来封装成具体的User对象，然后以userID为Key，该User对象为Value存放到Map中，
试想能不能实现？似乎能，
1.我们似乎在queryForMap中已经指定了Map的key为“userID”（sqlMapClient.queryForMap("User.queryForMap2", null, "userID");）。
2.我们似乎已经告诉iBatis我们需要在Map中存放User对象，因为我们方法的返回值为<String, User>写的清清楚楚。

好，再试一下：
Map<String, User> user = dao.getUserMap2();
System.out.println(user);
User user2 = user.get("3");//还是抛类型转换异常。
尝试将iBatis给我们的Map<Object, Object>集合中的Object转化成User失败，那么iBatis返回的Map中的Object
为什么不是User对象？
究竟是什么玩意？
揭开其神秘的面纱：
既然我们不知道Map中的Object究竟是什么玩意，我们不妨这样来，将Dao方法的返回值改成Map<Object, Object>,再一下结果
Map<Object, Object> map = dao.getUserMap2();
System.out.println(map.getClass().getName());//这个肯定是一个java.util.HashMap类型

System.out.println(map.get("1").getClass().getName());//这个居然也是java.util.HashMap类型，
以上结果表明，查询结果是Map中放了一个我们指定的"userID"为key，一个HashMap为value的HashMap集合。
怎么解释？
从头至尾总觉得有点不对劲的地方，因为我们一直没有告诉iBatis我们要返回User对象，因为我们的resultClass是java.util.HashMap
虽然我们的方法返回值是Map<String, User>, 但是它实际的返回值是Map<Object, Object>,所以我们
的方法返回值返回任何类型的Map集合都能编译通过，java中任何类型都是Object的子类型，这只是一个假象而已。
User user2 = user.get("3");到了我们真正想将Object类型转化成User类型的时候，报错了，HashMap到User的转化，显而易见。

从这一点上来看iBatis还是比较灵活的，我们可以通过queryForMap指定我们放在Map中的key,
return sqlMapClient.queryForMap("User.queryForMap2", null, "xxx");
如果我们想返回Map<Object, Map<>>形式，这里不是必须写成"userID"，它只是一个形式参数，只要和映射文件中的resultMap中的某个
property属性相同即可，当然这个属性对应的数据库字段值就将被当成key。
   <resultMap class="java.util.HashMap" id="resultMap-UserMap2">
  <result property="xxx" column="userID"/>
  <result property="name" column="username"/>
  <result property="age" column="age"/>
</resultMap>
如果我们指定的key在数据库中由重复怎么办？例如：
<resultMap class="java.util.HashMap" id="resultMap-UserMap2">
  <result property="xxx" column="userID"/>
  <result property="ooo" column="username"/>
  <result property="age" column="age"/>
</resultMap>
return sqlMapClient.queryForMap("User.queryForMap2", null, "ooo");//将数据库username字段值作为key
不出我们所料，结果：
{zhangbo={age=28, xxx=6, ooo=zhangbo}}，至于为什么只有一条记录而且是最后一条，不再累述。可见我们写在
resultMap映射文件中的“property”便是我们Map<Object, Map<>>中，里面个Map的key值。

这样一来iBatis就很灵活了，对应一张数据库表，我想用iBatis进行增删该查，特别是查，我们不是非得要有需要一个对象与
表结果对应，我们可以没有一个对象对应这张表，依然可以将表中的数据查询出来封装到Map中供我们很方便的使用。

那么按照我们的初衷，将一个对象放到Map中，以这个对象的某个属性为key，这个对象为value放到Map中返回是不是也可以实现了，
答案非常肯定，可以，稍作修改：

完整的映射文件：
<resultMap class="com.ibatis.entity.User" id="resultMap-UserMap2">
  <result property="userID" column="userID"/>//指定User的每个属性和数据库字段的映射关系
  <result property="name" column="username"/>
  <result property="age" column="age"/>
</resultMap>
<select id="queryForMap2" parameterClass="java.lang.String" resultMap="resultMap-UserMap2">
  select * from t_user
</select>
完整的Dao代码：
   @SuppressWarnings("unchecked")
    public Map<String, User> getUserMap2() throws SQLException
    {

       return sqlMapClient.queryForMap("User.queryForMap2", null, "userID");//这里指定的key的名称应该是User的某个属性名称
    }
完整的测试代码：
    Map<String, User> user = dao.getUserMap2();

    System.out.println(user);
    System.out.println(user.get("1").getName());
完整的输出结果：
{
   3=User: age=25 &userID=3 &name=zhangbo ,
   5=User: age=27 &userID=5 &name=zhangbo ,
   2=User: age=24 &userID=2 &name=zhangbo ,
   4=User: age=26 &userID=4 &name=zhangbo ,
   6=User: age=28 &userID=6 &name=zhangbo ,
   1=User: age=23 &userID=1 &name=zhangbo
}
   zhangbo

所以想要达到这种效果，我们的resultMap中的resultClass应该是具体的对象，而不是我们想当然的java.util.HashMap

还有一个queryForMap方法的重写方法
public java.util.Map queryForMap(java.lang.String id,
                                 java.lang.Object parameterObject,
                                 java.lang.String keyProp,
                                 java.lang.String valueProp)

   这个方法不但指定了我们返回的Map中的key，而且也指定了Map中的value。通过这个方法我们就可以查询一个表中的特定的两个字段值
   一个字段的值作为key，一个字段的值作为value。
   举个例子：

   完整的Dao代码：
    @SuppressWarnings("unchecked")
    public Map<String, String> getUserMap3(String userID) throws SQLException
    {
     //同样，“xxx”， “ooo”只是形参，任意字符串
        return sqlMapClient.queryForMap("User.queryForMap3", userID, "xxx","ooo");//查询指定userID的一条数据，至于哪个字段是key，哪个字段是value，只有resultMap映射字段能控制。
    }

resultMap映射文件：
<resultMap class="java.util.HashMap" id="resultMap-UserMap3">

  <result property="xxx" column="username"/>//指明xxx, ooo 对应的数据库字段名称，到底是数据库的哪个字段值作为key，哪个作为value。
  <result property="ooo" column="age"/>
</resultMap>
<select id="queryForMap3" parameterClass="java.lang.String" resultMap="resultMap-UserMap3">
  select * from t_user where userID=#aaa# //"aaa"也是一个形式参数，任意字符串
</select>

测试代码：
Map<String, String> map = dao.getUserMap3("3");
    System.out.println(map);

输出结果：
{zhangbo=25}

有一个地方值得注意：
<select id="queryForMap3" parameterClass="java.lang.String" resultClass="java.util.HashMap">//这里直接写成HashMap可以吗？
  select * from t_user where userID=#aaa#
</select>
return sqlMapClient.queryForMap("User.queryForMap3", userID, "xxx","ooo");//假设"xxx", "ooo"就是数据库两个字段的名称

因为我们知道，当我们的对象属性名称和数据字段相同的情况下，我们是直接写resultClass="xxx.xxx.xxx"即可的，只有当我们数据库的
字段名称与对象的属性不同的情况下我们才需要一个resultMap将数据库字段与对象属性名称对应起来。

即使这样，以上的假设是不可以的，这样的情况必须是resultMap来指定数据库字段对应HashMap的key和value, 其实也挺好理解的，
1.如果直接指定成resultClass="java.util.HashMap", 那么HashMap没有一个叫"xxx", "ooo"的属性，所以iBatis无法跟一般的对象
一样将数据库字段自动映射到对象相同名称的属性上。
2.此处的resultMap不是指定数据库哪个字段对应对象哪个属性，而是指定数据库的哪个字段作为key，哪个字段作为value。那么到底哪个
作为key，哪个作为value是在我们调用queryForMap的方法时候指定的。

总结：
针对第一个只指定key的queryForMap方法：
如果resultMap中依然设定resultClass="java.util.HashMap".iBatis的处理方式就是
将数据库指定的key值作为key，再将所有的字段封装成HashMap作为返回Map的value。将所有字段封转成HashMap的时候，以resultMap
中我们指定的名称作为key，数据库对应字段值作为value的。
如果设定resultClass="具体对象"，那么iBatis就会将数据库字段值设置到该对象的指定属性上作为Value，Key依然是指定的该对象的一个
属性。
针对第二个指定key，value的queryForMap方法：
就是查询数据库的任意两个字段值，一个作为返回Map的key，一个作为返回Map的value，至于哪个作为key，哪个作为value，由查询方法
和resultMap一起决定，resultMap中的resultClass=“java.util.HashMap”。

从这两个方法看iBatis的resultclass和resultMap还是非常的灵活和有用的，尽管queryForMap方法在具体的工作中可能用的不是很多，
但是有这两个方法的存在，iBatis显得更加的强大了，对数据库的操作不一定非要与某个我们的对象模型关联了，用java的HashMap就
可以搞定。从这一点来看，HashMap和一个pojo对象有惊人的相似点，自己体会去吧。