Result Maps

TheresultMapelement is the most important and powerful element in MyBatis. It's what allows you to do away with 90% of the code that JDBC requires to retrieve data fromResultSets,and in some cases allows you to do things that JDBC does not even support. In fact,to write the equivalent code for something like a join mapping for a complex statement could probably span thousands of lines of code. The design of theResultMaps is such that simple statements don't require explicit result mappings at all,and more complex statements require no more than is absolutely necessary to describe the relationships.

You've already seen examples of simple mapped statements that don't have an explicitresultMap. For example:

<select id="selectUsers" resultType="map">
  select id,hashedPassword
  from some_table
  where id = #{id}
</select>

Such a statement simply results in all columns being automatically mapped to the keys of aHashMap,as specified by theresultTypeattribute. While useful in many cases,aHashMapdoesn't make a very good domain model. It's more likely that your application will use JavaBeans or POJOs (Plain Old Java Objects) for the domain model. MyBatis supports both. Consider the following JavaBean:

package com.someapp.model;
public class User {
  private int id;
  private String username;
  private String hashedPassword;
  
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public String getUsername() {
    return username;
  }
  public void setUsername(String username) {
    this.username = username;
  }
  public String getHashedPassword() {
    return hashedPassword;
  }
  public void setHashedPassword(String hashedPassword) {
    this.hashedPassword = hashedPassword;
  }
}

Based on the JavaBeans specification,the above class has 3 properties: id,and hashedPassword. These match up exactly with the column names in the select statement.

Such a JavaBean could be mapped to aResultSetjust as easily as theHashMap.

<select id="selectUsers" resultType="com.someapp.model.User">
  select id,hashedPassword
  from some_table
  where id = #{id}
</select>

And remember that TypeAliases are your friend. Use them so that you don't have to keep typing the fully qualified path of your class out. For example:

<!-- In Config XML file -->
<typeAlias type="com.someapp.model.User" alias="User"/>

<!-- In sql Mapping XML file -->
<select id="selectUsers" resultType="User">
  select id,hashedPassword
  from some_table
  where id = #{id}
</select>

In these cases MyBatis is automatically creating aResultMapbehind the scenes to auto-map the columns to the JavaBean properties based on name. If the column names did not match exactly,you could employ select clause aliases (a standard sql feature) on the column names to make the labels match. For example:

<select id="selectUsers" resultType="User">
  select
    user_id             as "id",user_name           as "userName",hashed_password     as "hashedPassword"
  from some_table
  where id = #{id}
</select>

The great thing aboutResultMaps is that you've already learned a lot about them,but you haven't even seen one yet! These simple cases don't require any more than you've seen here. Just for example sake,let's see what this last example would look like as an external

<resultMap id="userResultMap" type="User">
  <id property="id" column="user_id" />
  <result property="username" column="user_name"/>
  <result property="password" column="hashed_password"/>
</resultMap>

• constructor- used for injecting results into the constructor of a class upon instantiation
  • idArg- ID argument; flagging results as ID will help improve overall performance
  • arg- a normal result injected into the constructor
• id– an ID result; flagging results as ID will help improve overall performance
• result– a normal result injected into a field or JavaBean property
• association– a complex type association; many results will roll up into this type
  • nested result mappings – associations areresultMaps themselves,or can refer to one
• collection– a collection of complex types
  • nested result mappings – collections arediscriminator– uses a result value to determine whichresultMapto use
    • case– a case is a result map based on some value
      • nested result mappings – a case is also a result map itself,and thus can contain many of these same elements,or it can refer to an external resultMap.

  ResultMap Attributes

  Attribute	Description
  id	A unique identifier in this namespace that can be used to reference this result map.
  type	A fully qualified Java class name,or a type alias (see the table above for the list of built-in type aliases).
  autoMapping	If present,MyBatis will enable or disable the automapping for this ResultMap. This attribute overrides the global autoMappingBehavior. Default: unset.

  Best PracticeAlways build ResultMaps incrementally. Unit tests really help out here. If you try to build a giganticresultMaplike the one above all at once,it's likely you'll get it wrong and it will be hard to work with. Start simple,and evolve it a step at a time. And unit test! The downside to using frameworks is that they are sometimes a bit of a black Box (open source or not). Your best bet to ensure that you're achieving the behavIoUr that you intend,is to write unit tests. It also helps to have them when submitting bugs.

  The next sections will walk through each of the elements in more detail.

id & result

<id property="id" column="post_id"/>
<result property="subject" column="post_subject"/>

These are the most basic of result mappings. Bothid,andresultmap a single column value to a single property or field of a simple data type (String,int,double,Date,etc.).

The only difference between the two is thatidwill flag the result as an identifier property to be used when comparing object instances. This helps to improve general performance,but especially performance of caching and nested result mapping (i.e. join mapping).

Each has a number of attributes:

Supported JDBC Types

For future reference,MyBatis supports the following JDBC Types via the included JdbcType enumeration.

constructor<constructor> <idArg column="id" javaType="int"/> <arg column="username" javaType="String"/> </constructor>