先说下问题产生的背景：

　　最近在做一个用到MyBatis的项目，其中有个业务涉及到关联查询，我是将两个查询分开来写的，即嵌套查询，个人感觉这样更方便重用；

　　关联的查询使用到了动态sql，在执行查询时就出现了如下错误：Caused by: org.apache.ibatis.reflection.ReflectionException: There is no getter for property named ‘id’ in ‘class java.lang.Integer’

　　因为出现了这个问题，在解决的时候一连串又发现了一些其它新的问题，比如关联查询时的效率问题，以及映射。通过百度，看文档基本解决，做个笔记。

现在简单的用学生和年级两个对象来做实验，学生有一个年级属性，年级有一个学生集合属性。

先把一些基础的代码贴出来：

学生实体：

 1 package com.lizhou.entity;  2 
 3 import java.io.Serializable;  4 
 5 /**
 6  * 学生  7  * @author bojiangzhou  8  * @date 2016年3月30日  9  */
10 public class Student implements Serializable { 11     
12     private static final long serialVersionUID = -4165939686905301187L; 13     
14     private Integer id; 15     //学生姓名
16     private String name; 17     //年龄
18     private int age; 19     //学生所属年级
20     private Grade grade; 21 
22     //getter/setter...
23 
24 }

年级实体：

 1 package com.lizhou.entity;  2 
 3 import java.io.Serializable;  4 import java.util.ArrayList;  5 import java.util.List;  6 
 7 /**
 8  * 年级  9  * @author bojiangzhou 10  * @date 2016年3月30日 11  */
12 public class Grade implements Serializable { 13     
14     private static final long serialVersionUID = -3469035301959740223L; 15 
16     private Integer id; 17     //年级名称
18     private String name; 19     //年级下的学生集合
20     private List<Student> studentList = new ArrayList<Student>(); 21 
22     //getter/setter...
23     
24 }

学生数据接口：

 1 package com.lizhou.dao;  2 
 3 import java.util.List;  4 
 5 import com.lizhou.entity.Student;  6 
 7 /**
 8  * 数据层  9  * @author bojiangzhou 10  * @date 2016年3月30日 11  */
12 public interface StudentDao { 13     
14     /**
15  * 获取学生信息 16  * @param student 17  * @return
18      */
19  Student getStudent(Student student); 20     
21     /**
22  * 获取学生集合 23  * @param student 24  * @return
25      */
26     List<Student> getStudentList(Student student); 27 }

年级数据接口：

 1 package com.lizhou.dao;  2 
 3 import com.lizhou.entity.Grade;  4 
 5 /**
 6  * 数据层  7  * @author bojiangzhou  8  * @date 2016年3月30日  9  */
10 public interface GradeDao { 11     
12     /**
13  * 获取某个年级 14  * @param grade 15  * @return
16      */
17  Grade getGrade(Grade grade); 18     
19     /**
20  * 获取年级集合 21  * @param grade 22  * @return
23      */
24  Grade getGradeList(Grade grade); 25     
26 }

加载配置文件获取SqlSession工具类：

 1 package com.lizhou.tools;  2 
 3 import java.io.IOException;  4 import java.io.InputStream;  5 
 6 import org.apache.ibatis.io.Resources;  7 import org.apache.ibatis.session.SqlSession;  8 import org.apache.ibatis.session.SqlSessionFactory;  9 import org.apache.ibatis.session.SqlSessionFactoryBuilder; 10 
11 /**
12  * 加载配置文件获取SqlSession工具类 13  * @author bojiangzhou 14  * @date 2016年3月30日 15  */
16 public class SqlSessionFactoryTool { 17     
18     private static SqlSessionFactory sqlSessionFactory; 19     
20     public static SqlSessionFactory getSqlSessionFactory(){ 21         if(sqlSessionFactory == null){ 22             try { 23                 InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); 24                 sqlSessionFactory = new SqlSessionFactoryBuilder().build(is); 25             } catch (IOException e) { 26  e.printStackTrace(); 27  } 28  } 29         return sqlSessionFactory; 30  } 31     
32     public static SqlSession openSession(){ 33         return getSqlSessionFactory().openSession(); 34  } 35     
36 }

测试类：

 1 package com.lizhou.service;  2 
 3 import java.util.LinkedHashMap;  4 import java.util.List;  5 import java.util.Map;  6 
 7 import org.apache.ibatis.session.SqlSession;  8 import org.junit.After;  9 import org.junit.Before; 10 import org.junit.Test; 11 
12 import com.lizhou.entity.Grade; 13 import com.lizhou.entity.Student; 14 import com.lizhou.dao.GradeDao; 15 import com.lizhou.dao.StudentDao; 16 import com.lizhou.tools.SqlSessionFactoryTool; 17 
18 /**
19  * 测试类 20  * @author bojiangzhou 21  * @date 2016年3月30日 22  */
23 public class TestService { 24     
25     private SqlSession sqlSession = null; 26     
27     private StudentDao studentDao = null; 28     private GradeDao gradeDao = null; 29     
30     /**
31  * 测试方法前调用 32  * @throws Exception 33      */
34  @Before 35     public void setUp() throws Exception { 36         sqlSession = SqlSessionFactoryTool.openSession(); 37         studentDao = sqlSession.getMapper(StudentDao.class); 38         gradeDao = sqlSession.getMapper(GradeDao.class); 39  } 40     
41     /**
42  * 测试方法后调用 43  * @throws Exception 44      */
45  @After 46     public void tearDown() throws Exception { 47  sqlSession.close(); 48  } 49     
50     /**
51  * 测试方法 52      */
53  @Test 54     public void test() { 55         
56  } 57 
58 }

**************************************************************************************************************************

一、mybatis嵌套查询(即SQL语句分离的)时报类似于There is no getter for property named ‘id’ in ‘class java.lang.Integer’ 的错误

先看看产生问题的与学生和年级对应的映射配置：

StudentMapper.xml：这里是通过association查询年级的（第10行代码）。

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE mapper  3 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  4 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 5 <mapper namespace="com.lizhou.dao.StudentDao">
 6     
 7     <resultMap type="Student" id="studentResult">
 8         <id property="id" column="id"/>
 9         
10         <association property="grade" column="gradeId" select="com.lizhou.dao.GradeDao.getGrade"></association>
11     </resultMap>
12     
13     <select id="getStudent" resultMap="studentResult">
14  SELECT * FROM student 15         <where>
16             <if test="id != null">
17  AND id=#{id} 18             </if>
19         </where>
20     </select>
21     
22 </mapper> 

GradeMapper.xml：动态Sql，本意是想如果有一个查询所有年级和根据id来查询年级的业务时就可以使用同一个查询了。

注意这里年级还有一个学生集合没有映射到gradeResult里面，如果映射了会循环查询最终导致栈溢出的，后面再说。

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE mapper  3 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  4 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 5 <mapper namespace="com.lizhou.dao.GradeDao">
 6     
 7     <resultMap type="Grade" id="gradeResult">
 8         <id property="id" column="id"/>
 9         
10     </resultMap>
11     
12     <select id="getGrade" parameterType="Grade" resultMap="gradeResult">
13  SELECT * FROM grade 14         <where>
15             <if test="id != null">
16  AND id=#{id} 17             </if>
18         </where>
19     </select>
20     
21 </mapper> 

测试代码：

1 @Test 2 public void test() { 3     Student student = new Student(); 4     student.setId(1); 5     //根据id查询学生
6     student = studentDao.getStudent(student); 7     
8  System.out.println(student); 9 }

我的本意是各自的业务分开来写，我要查询学生时就调用getStudent，要查询年级时就调用getGrade，而我要查询学生的同时还要查询其关联的年级，这样我也可以调用getGrade来完成，这样能很好的实现重用。

但结果并不是这样的，报错：Caused by: org.apache.ibatis.reflection.ReflectionException: There is no getter for property named ‘id’ in ‘class java.lang.Integer’

刚开始真的没明白怎么回事，在Integer中找不到id属性？？

我将GradeMapper.xml中的select语句改成如下时，就可以：

 1 <mapper namespace="com.lizhou.dao.GradeDao">
 2     
 3     <resultMap type="Grade" id="gradeResult">
 4         <id property="id" column="id"/>
 5         
 6     </resultMap>
 7     
 8     <select id="getGrade" parameterType="Grade" resultMap="gradeResult">
 9  SELECT * FROM grade WHERE id=#{id} 10     </select>
11     
12 </mapper> 

百度了很久，原因是在查询到一条记录的时候就会将id注入，而且不管#{id}的名称，就是说你随便写也能查出结果来，第9行代码：

 1 <mapper namespace="com.lizhou.dao.GradeDao">
 2     
 3     <resultMap type="Grade" id="gradeResult">
 4         <id property="id" column="id"/>
 5         
 6     </resultMap>
 7     
 8     <select id="getGrade" parameterType="Grade" resultMap="gradeResult">
 9  SELECT * FROM grade WHERE id=#{id-xxxxxx} 10     </select>
11     
12 </mapper>

结论》》联合查询时：

不管输入参数名称是什么，mybatis最终会执行：

效果为：select * from grade where id =resultSet.getInt(“id”)；

所以我之前用动态sql时去判断id，其实是不存在id的，所以导致那样的错误！！

这里参考原文解释：MyBatis中Association联合select使用

——————————————————————————————————————————————————————

二、嵌套结果查询导致的循环查询栈溢出

如果这样使用联合查询，其实还存在另外一个问题：学生下有年级，年级下有学生集合，这样查询下去只有栈溢出了….

看代码：

StudentMapper.xml：年级也有映射

 1 <mapper namespace="com.lizhou.dao.StudentDao">
 2     
 3     <resultMap type="Student" id="studentResult">
 4         <id property="id" column="id"/>
 5         
 6         <association property="grade" column="gradeId" select="com.lizhou.dao.GradeDao.getGrade"></association>
 7     </resultMap>
 8     
 9     <select id="getStudent" resultMap="studentResult">
10  SELECT * FROM student WHERE gradeId=#{gradeId} 11     </select>
12     
13 </mapper> 

GradeMapper.xml：注意此时映射了学生集合的，第6行代码

 1 <mapper namespace="com.lizhou.dao.GradeDao">
 2     
 3     <resultMap type="Grade" id="gradeResult">
 4         <id property="id" column="id"/>
 5         
 6         <collection property="studentList" column="id" ofType="Student" select="com.lizhou.dao.StudentDao.getStudent"></collection>
 7     </resultMap>
 8     
 9     <select id="getGrade" parameterType="Grade" resultMap="gradeResult">
10  SELECT * FROM grade WHERE id=#{id} 11     </select>
12     
13 </mapper> 

不管是查询学生还是年级，结果报错：java.lang.StackOverflowError

这样看来，最终都还是要分开写，就是说我想查询年级和查询学生时联合查询年级要写两个select才行，并没能达到重用的目的。

但是相信程序员都是有强迫症的，这样有点不爽，我就又百度，看能不能很好的重用，结果是没有百度到。

但是在看文档的时候，发现了另一个问题：联合查询分开写查询语句是很消耗性能的，明明可以只用执行一次查询，却执行了两次甚至更多次。

文档是这样说的：这种方式很简单，但是对于大型数据集合和列表将不会表现很好。问题就是我们熟知的“N+1 查询问题”。

N+1 查询问题可以是这样引起的：

1. 你执行了一个单独的 SQL 语句来获取结果列表（就是“+1”）

2.对返回的每条记录，你执行了一个查询语句来为每个加载细节（就是“N”）

这个问题会导致成百上千的 SQL 语句被执行。这通常不是期望的。

——————————————————————————————————————————————————————

三、关联的嵌套结果

上面的叫做[关联的嵌套查询]

所以自然有另一种方法—-[关联的嵌套结果](文档上这样说的)：联合两张表在一起，代替了执行一个分离的语句。

看代码：

 1 <mapper namespace="com.lizhou.dao.StudentDao">
 2     
 3     <resultMap type="Student" id="studentResult">
 4         <id property="id" column="id"/>
 5         <result property="name" column="name"/>
 6         <result property="age" column="age"/>
 7         <association property="grade" column="gradeId" javaType="Grade">
 8             <id property="id" column="id"/>
 9             <result property="name" column="name"/>
10         </association>
11     </resultMap>
12     
13     <select id="getStudent" resultMap="studentResult">
14  SELECT * FROM student LEFT OUTER JOIN grade ON grade.id=student.gradeId WHERE student.id=#{id} 15     </select>
16     
17 </mapper> 

映射的时候是将年级和学生一起映射的，这个就叫做嵌套结果映射。然后是sql语句，使用的是联合查询。

——————————————————————————————————————————————————————

四、映射、效率

这里又遇到了几个问题：

1.在之前写resultMap映射时，我是一般不爱将属性映射写出来的，因为mybatis会自动映射的，但是这里不行了。

在嵌套结果映射时，哪个属性没有映射那么这个值就是空的，查询出来的结果不会注入到对象中。所以必须将所有属性都显示映射出来。

2.先看看映射都OK时输出的结果：Student [id=2, name=罗若亚卓落, age=22, grade=Grade [id=2, name=罗若亚卓落, studentList=[]]]

输出结果中，grade中的数据和student中的一样了….因为Student的id和name跟Grade的id和name属性名一样。

mybatis其实就是使用resultSet.getString(“name”)这样的方式来获取值的，所以联合查询时两张表的字段名不能重复。

或者可以在配置文件中配置好映射和sql语句。如下：注意第8、9行代码，重新配置column；以及sql语句。但是如果属性过多，sql代码可能就有点长了，所以最好还是保持字段名不一样吧。

 1 <mapper namespace="com.lizhou.dao.StudentDao">
 2     
 3     <resultMap type="Student" id="studentResult">
 4         <id property="id" column="id"/>
 5         <result property="name" column="name"/>
 6         <result property="age" column="age"/>
 7         <association property="grade" column="gradeId" javaType="Grade">
 8             <id property="id" column="grade_id"/>
 9             <result property="name" column="grade_name"/>
10         </association>
11     </resultMap>
12     
13     <select id="getStudent" resultMap="studentResult">
14  SELECT 15  s.id, 16  s.name, 17  s.age, 18  g.id as grade_id, 19  g.name as grade_name 20  FROM student s LEFT OUTER JOIN grade g ON g.id=s.gradeId 21  WHERE s.id=#{id} 22     </select>
23     
24 </mapper>

3.最后是在文档中看到的一个比较重要的问题，最好是要显示映射出id。直接复制原话：

非常重要：在嵌套结果映射中 id 元素扮演了非常重要的角色。应该通常指定一个或多个属性，它们可以用来唯一标识结果。

实际上就是如果你不使用它（id 元素） ，但是会产生一个严重的性能问题，不过 MyBatis 仍然可以正常工作。

选择的属性越少越好，它们可以唯一地标识结果。主键就是一个显而易见的选择（即便是联合主键）。

============================================================================================

刚学完mybatis不久，现在正在做的这个项目(视频教程，当练手)本来是struts+spring+ibatis的，我想着ibatis也算是过去式了，恰好前阵刚学了mybatis还没实战过，就把ibatis换成了mybatis。

不过只是知道怎么使用，很多细节性的东西还没深入了解。所以这篇博客也只是开发中遇到的一些问题解决后做个笔记，大部分都属于个人理解，有些可能不全面，希望有不同见解的朋友一起交流~~O(∩_∩)O~~