resultmap_resultmap别名 - CSDN
精华内容
参与话题
  • MyBatis基础用法--使用resultMap自定义高级映射规则

    万次阅读 多人点赞 2019-03-28 09:52:35
    resultMap简介 resultMap的用法 id & result constructor association 嵌套查询 嵌套结果 collection 嵌套查询 嵌套结果 discriminator resultMap简介 在前面两篇文章中,我们都是通过使用select...

    目录

    resultMap简介

    resultMap的用法

    id & result

    constructor

    association

    嵌套查询

    嵌套结果

    collection

    嵌套查询

    嵌套结果

    discriminator


    resultMap简介

    在前面两篇文章中,我们都是通过使用select元素的resultType属性指定查询结果的返回值类型,来让MyBatis自动将查询结果集封装成我们希望的类型进行返回。

    resultType属性非常有用,但在返回结果类型比较复杂的情况下却无能为力,为此,MyBatisselect元素中还为我们提供了另外一个resultMap属性,用于引用一个使用<resultMap/>元素定义好的自定义结果集映射规则。

    <resultMap/>算是MyBatis中最重要、最强大的元素了,它可以让你比使用JDBC调用结果集省掉90%的代码,也可以让你做许多JDBC不支持的事。 事实上,编写类似的对复杂语句联合映射的代码也许会需要上千行。resultMap的设计就是简单语句不需要明确的结果映射,而很多复杂语句确实需要描述它们的关系。  

    resultMap的用法

    <resultMap/>元素有很多子元素: 

    <constructor>		 /*用来将查询结果作为参数注入到实例的构造方法中*/
    	<idArg />	 /*标记结果作为 ID*/
    
    	<arg />		 /*标记结果作为普通参数*/
    
    </constructor>
    <id/>			 /*一个ID结果,标记结果作为 ID*/
    <result/>		 /*一个普通结果,JavaBean的普通属性或字段*/
    <association>		 /*关联其他的对象*/
    </association>
    <collection>		 /*关联其他的对象集合*/
    </collection>
    <discriminator>	         /*鉴别器,根据结果值进行判断,决定如何映射*/
    	<case></case>	 /*结果值的一种情况,将对应一种映射规则*/
    </discriminator>

    在一个<resultMap/>元素中,这些子元素出现的先后顺序是有严格规定的,它们从前到后依次是:constructor-->id --> result--> association-->collection -->discriminator。  

    id & result

    <id/><result/>resultMap中最基本的映射内容,它们都可以将查询结果中一个单独列的值映射为返回结果对象中的简单数据类型(字符串,整型,双精度浮点数,日期等)的单独属性或字段。这两者之间的唯一不同是id 表示的结果将是当比较对象实例时用到的标识属性。这帮助来改进整体表现,特别是缓存和嵌入结果映射(也就是联合映射) 。 

    <!-- 返回javaBean对象 -->
    <resultMap type="org.mybatis.entity.StudentEntity" id="studentResultMap">
    	<id column="STUDENT_ID" property="studentId" />
    	<result column="STUDENT_NAME" property="studentName" />
    	<result column="STUDENT_GENDER" property="studentGender" />
    	<result column="STUDENT_BIRTHDAY" property="studentBirthday" />
    	<result column="STUDENT_AGE" property="studentAge" />
    </resultMap>
    <!-- 返回Map对象 -->
    <resultMap type="map" id="studentResultMap">
    	<id column="STUDENT_ID" property="studentId" javaType="long"/>
    	<result column="STUDENT_NAME" property="studentName" javaType="string"/>
    	<result column="STUDENT_GENDER" property="studentGender" javaType="string"/>
    	<result column="STUDENT_BIRTHDAY" property="studentBirthday" javaType="date"/>
    	<result column="STUDENT_AGE" property="studentAge" javaType="int"/>
    </resultMap>

    <id/><result/>都支持以下几个属性: 

    属性 描述
    column 从数据库中查询到的结果集的列名或列别名
    property 将 column属性指定的列结果映射到对象的哪个属性
    javaType 列结果在对象中所对应的Java数据类型,返回类型为Map时需指定
    jdbcType 列结果在数据库中所支持的JDBC 类型
    typeHandler 所使用的类型处理器

    为了未来的参考,MyBatis 通过包含的 jdbcType 枚举型,支持下面的 JDBC 类型。

    BIT FLOAT CHAR TIMESTAMP OTHER UNDEFINED
    TINYINT REAL VARCHAR BINARY BLOB NVARCHAR
    SMALLINT DOUBLE LONGVARCHAR VARBINARY CLOB NCHAR
    INTEGER NUMERIC DATE LONGVARBINARY BOOLEAN NCLOB
    BIGINT DECIMAL TIME NULL CURSOR ARRAY

    constructor

    使用<constructor/>元素可以在对象实例化时,将查询到结果集作为参数注入到实例的构造方法中,以实现对实例化对象的特殊处理。

    例如,为了防止由于数据库学生表中的年龄字段长期未更新,而导致查询出来的学生年龄信息不准确,我们希望查询学生信息时根据学生的生日计算出学生的年龄,而不再直接从数据库中获取学生的年龄信息。

    首先在学生实体类StudentEntity中增加如下构造方法:

    private static final SimpleDateFormat yearFormat = new SimpleDateFormat(
    			"yyyy");
    public StudentEntity(Long studentId, Date studentBirthday) {
    	super();
    	this.studentId = studentId;
    	if (null != studentBirthday) {
            	this.studentBirthday = studentBirthday;
    		int startYear = Integer
    				.parseInt(yearFormat.format(studentBirthday));
    		int nowYear = Integer.parseInt(yearFormat.format(new Date()));
    		this.studentAge = nowYear - startYear;
    	}
    }

    相应的Mapper配置如下。

    <resultMap type="org.mybatis.entity.StudentEntity" id="studentResultMap">
    	<constructor>
    		<idArg column="STUDENT_ID" javaType="java.lang.Long" />
    		<arg column="STUDENT_BIRTHDAY" javaType="java.util.Date" />
    	</constructor>
    	<id column="STUDENT_ID" property="studentId" />
    	<result column="STUDENT_NAME" property="studentName" />
    	<result column="STUDENT_GENDER" property="studentGender" />
    </resultMap>
    <select id="selectStudentById" resultMap="studentResultMap">
    	select * from
    	tbl_student where
    	STUDENT_ID =
    	#{studentId}
    </select>

    <constructor/>元素的<idArg/><arg/>除了支持示例中的columnjavaType属性,还支持以下几个属性:jdbcTypetypeHandlerselectresultMapname,其中的name属性从3.4.3版本起开始引入,用来指定该在构造方法中形参的名字。
    注意:使用<constructor/>元素在构造方法中初始化的参数若使用resultMap的其他子元素进行映射,则构造方法为对象实例赋予的属性值将被覆盖。

    association

    <association/>元素用于处理查询结果中关联其他对象的情况,比如:一个学生属于一个班级,我们在查询一个学生的信息时,想要把他所在的班级也一并查出。

    public class StudentEntity {
    
    	private Long studentId;
    
    	private String studentName;
    
    	private ClassEntity studentClass;
    	
    	//此处省略get和set方法
    
    }

    MyBatis提供了两种不同的方式用来处理这种对象关联查询:嵌套查询和嵌套结果。

    嵌套查询

    所谓嵌套查询,指的是通过执行另外一个 SQL 映射语句来返回所关联的对象类型。

    <resultMap type="org.mybatis.entity.StudentEntity" id="studentResultMap">
    	<id column="STUDENT_ID" property="studentId" />
    	<result column="STUDENT_NAME" property="studentName" />
    	<association column="CLASS_ID" property="studentClass"
    		select="selectClassById" javaType="org.mybatis.entity.ClassEntity" />
    </resultMap>
    <select id="selectStudentById" resultMap="studentResultMap">
    	select * from
    	tbl_student where
    	STUDENT_ID =
    	#{studentId}
    </select>
    <resultMap type="org.mybatis.entity.ClassEntity" id="classResultMap">
    	<id column="CLASS_ID" property="classId" />
    	<result column="CLASS_NAME" property="className" />
    </resultMap>
    <select id="selectClassById" resultMap="classResultMap">
    	select * from
    	tbl_class
    	where
    	CLASS_ID =
    	#{classId}
    </select>

    注:<association/>元素可以通过columnPrefix属性可以祛除查询结果内列名的指定前缀。

    嵌套结果

    所谓嵌套结果,指的是通过联表查询将所需的所有字段内容先查询出来,再通过级联属性映射来创建复杂类型的结果对象。

    <resultMap type="org.mybatis.entity.StudentEntity" id="studentResultMap">
    	<id column="STUDENT_ID" property="studentId" />
    	<result column="STUDENT_NAME" property="studentName" />
    	<result column="CLASS_ID" property="studentClass.classId" />
    	<result column="CLASS_NAME" property="studentClass.className" />
    </resultMap>
    <sql id="studentAndClassFields">
    	s.STUDENT_ID AS STUDENT_ID,
    	s.STUDENT_NAME AS STUDENT_NAME,
    	c.CLASS_ID AS CLASS_ID,
    	c.CLASS_NAME AS CLASS_NAME
    </sql>
    <select id="selectStudentById" resultMap="studentResultMap">
    	SELECT
    	<include refid="studentAndClassFields"></include>
    	FROM
    	tbl_student s
    	LEFT OUTER JOIN
    	tbl_class c ON s.CLASS_ID=c.CLASS_ID
    	WHERE
    	s.STUDENT_ID=#{studentId}
    </select>

    此时的resultMap还可以写为如下两种形式。

    <resultMap type="org.mybatis.entity.StudentEntity" id="studentResultMap">
    	<id column="STUDENT_ID" property="studentId" />
    	<result column="STUDENT_NAME" property="studentName" />
    	<association property="studentClass" javaType="org.mybatis.entity.ClassEntity">
    		<id column="CLASS_ID" property="classId" />
    		<result column="CLASS_NAME" property="className" />
    	</association>
    </resultMap>
    <resultMap type="org.mybatis.entity.StudentEntity" id="studentResultMap">
    	<id column="STUDENT_ID" property="studentId" />
    	<result column="STUDENT_NAME" property="studentName" />
    	<association property="studentClass" resultMap="classResultMap">
    	</association>
    </resultMap>
    <resultMap type="org.mybatis.entity.ClassEntity" id="classResultMap">
    	<id column="CLASS_ID" property="classId" />
    	<result column="CLASS_NAME" property="className" />
    </resultMap>

    collection

    <collection/>元素用于处理查询结果中关联其他对象集合的情况,比如:一个班级包含多个学生,我们在查询一个班级的信息时,想要把这个班级里的学生集合也一并查出。

    public class ClassEntity {
    
    	private Long classId;
    
    	private String className;
    
    	private List<StudentEntity> students;
    
    	//此处省略get和set方法
    }

    嵌套查询

    <resultMap type="org.mybatis.entity.ClassEntity" id="classResultMap">
    		<id column="CLASS_ID" property="classId" />
    		<result column="CLASS_NAME" property="className" />
    		<collection column="CLASS_ID" property="students" javaType="list"
    			select="listStudentsByClass">
    		</collection>
    	</resultMap>
    
    	<resultMap type="org.mybatis.entity.StudentEntity" id="studentResultMap">
    		<id column="STUDENT_ID" property="studentId" />
    		<result column="STUDENT_NAME" property="studentName" />
    	</resultMap>
    
    	<select id="selectClassById" resultMap="classResultMap">
    		select * from
    		tbl_class
    		where
    		CLASS_ID =
    		#{classId}
    	</select>
    
    	<select id="listStudentsByClass" parameterType="long"
    		resultMap="studentResultMap">
    		select * from
    		tbl_student
    		where
    		CLASS_ID =
    		#{classId}
    	</select>

    嵌套结果

    <resultMap type="org.mybatis.entity.ClassEntity" id="classResultMap">
    	<id column="CLASS_ID" property="classId" />
    	<result column="CLASS_NAME" property="className" />
    	<collection column="CLASS_ID" property="students" javaType="list"
    		ofType="org.mybatis.entity.StudentEntity">
    		<id column="STUDENT_ID" property="studentId" />
    		<result column="STUDENT_NAME" property="studentName" />
    	</collection>
    </resultMap>
    <sql id="classAndStudentsFields">
    	c.CLASS_ID AS CLASS_ID,
    	c.CLASS_NAME AS CLASS_NAME,
    	s.STUDENT_ID AS STUDENT_ID,
    	s.STUDENT_NAME AS STUDENT_NAME
    </sql>
    <select id="selectClassById" parameterType="long" resultMap="classResultMap">
    	SELECT
    	<include refid="classAndStudentsFields"></include>
    	FROM tbl_class c
    	LEFT JOIN tbl_student s ON c.CLASS_ID=s.CLASS_ID
    	WHERE
    	c.CLASS_ID=#{classId}
    </select>

    此时的resultMap也可以写为如下形式。

    <resultMap type="org.mybatis.entity.ClassEntity" id="classResultMap">
    	<id column="CLASS_ID" property="classId" />
    	<result column="CLASS_NAME" property="className" />
    	<collection property="students" javaType="list"
    		ofType="org.mybatis.entity.StudentEntity" resultMap="studentResultMap">
    	</collection>
    	</resultMap>
    <resultMap type="org.mybatis.entity.StudentEntity" id="studentResultMap">
    	<id column="STUDENT_ID" property="studentId" />
    	<result column="STUDENT_NAME" property="studentName" />
    </resultMap>

    discriminator

    <discriminator/>元素很像Java语言中的switch 语句,允许用户根据查询结果中指定字段的不同取值来执行不同的映射规则,比如:在查询一个班级的学生信息时,如果学生是男生则将其年龄信息一并查出,如果学生是女生则不查询其年龄信息而是将班级信息一并查出。

    <resultMap type="org.mybatis.entity.StudentEntity" id="studentSResultMap">
    	<discriminator column="STUDENT_GENDER" javaType="string">
    		<case value="男" resultMap="maleResultMap"/>
    		<case value="女" resultMap="femaleResultMap"/>
    	</discriminator>
    </resultMap>
    <resultMap type="org.mybatis.entity.StudentEntity" id="maleResultMap">
    	<id column="STUDENT_ID" property="studentId" />
    	<result column="STUDENT_NAME" property="studentName" />
    	<result column="STUDENT_AGE" property="studentAge" />
    </resultMap>
    <resultMap type="org.mybatis.entity.StudentEntity" id="femaleResultMap">
    	<id column="STUDENT_ID" property="studentId" />
    	<result column="STUDENT_NAME" property="studentName" />
    	<association column="CLASS_ID" property="studentClass"
    		javaType="org.mybatis.entity.ClassEntity">
    		<id column="CLASS_ID" property="classId" />
    		<result column="CLASS_NAME" property="className" />
    	</association>
    </resultMap>

    此时的resultMap也可以写为如下形式。

    <resultMap type="org.mybatis.entity.StudentEntity" id="studentSResultMap">
    	<id column="STUDENT_ID" property="studentId" />
    	<result column="STUDENT_NAME" property="studentName" />
    	<discriminator column="STUDENT_GENDER" javaType="string">
    		<case value="男" resultType="org.mybatis.entity.StudentEntity">
    			<result column="STUDENT_AGE" property="studentAge" />
    		</case>
    		<case value="女" resultType="org.mybatis.entity.StudentEntity">
    			<association column="CLASS_ID" property="studentClass"
    				javaType="org.mybatis.entity.ClassEntity">
    				<id column="CLASS_ID" property="classId" />
    				<result column="CLASS_NAME" property="className" />
    			</association>
    		</case>
    	</discriminator>
    </resultMap>

    注:在使用<resultMap/>元素进行分步查询时,如果需要传递多个参数到关联的查询语句中,可以使用column="{classId=CLASS_ID}"将参数封装到Map进行传参,接收参数的查询语句需将parameterType设置为Map类型。

    展开全文
  • resultMap的使用以及理解

    千次阅读 2019-02-26 16:46:06
    什么时候使用resultMap 一般我们在Mybatis中使用查询语句的时候,如果查询到的结果不能使用resultType反应出来的时候,可以采用resultMap标签来解决数据查询不到的困难问题。 resultMap标签 &lt;resultMap ...

    什么时候使用resultMap

    一般我们在Mybatis中使用查询语句的时候,如果查询到的结果不能使用resultType反应出来的时候,可以采用resultMap标签来解决数据查询不到的困难问题。

    resultMap标签

    <resultMap type="" id="">
    		<id/>
    		<result/>
    		<association property="" select="" column=""></association>
    		<collection property="" select="" column=""></collection>
    	</resultMap>

    其中type指代的是我们需要映射到的类对象,id表示resultMap在select标签中用的时候的id名称

    id标签

    这是设置主键使用的,使用此标签配置映射关系(可能不止一个)

    result标签

    这是一般属性用于配置映射关系使用的(一般不止一个)

    association标签:

    property:表示pojo类集合中的属性

    select:表示所需要的那个类的查询语句

    column:从resultMap中传过去用作查询的参数

    ofType:集合属性中的对象(可以不写)

    collection标签:

    property:表示pojo类集合中的属性

    select:表示所需要的那个类的查询语句

    column:从resultMap中传过去用作查询的参数

    ofType:集合属性中的对象(可以不写)

    association和collection之间的区别就是前者是针对一个对象而言,后者是针对一个集合而言!

    整个resultMap的功能总的来说:

    当需要查询的数据用当前查询语句不能全部查询出来的时候,使用resultMap辅助查询,resultMap的作用就是在同一张表中进行我们所需要的二次查询,然后利用查询到的数据中的部分信息作为一次查询中的查询条件,从而帮助得到需要查询的数据。也可以叫做嵌套查询。

     

    展开全文
  • ResultMap详解

    万次阅读 多人点赞 2016-08-31 12:42:26
    前言MyBatis是基于“数据库结构不可控”的思想建立的,也就是我们希望数据库遵循第三范式或BCNF,但实际事与愿违,那么结果集映射就是MyBatis为我们提供这种理想与现实间转换的手段了,而resultMap就是结果集映射的...

    前言

    MyBatis是基于“数据库结构不可控”的思想建立的,也就是我们希望数据库遵循第三范式或BCNF,但实际事与愿违,那么结果集映射就是MyBatis为我们提供这种理想与现实间转换的手段了,而resultMap就是结果集映射的配置标签了。
    在深入ResultMap标签前,我们需要了解从SQL查询结果集到JavaBean或POJO实体的过程。

    从SQL查询结果到领域模型实体 

    1. 通过JDBC查询得到ResultSet对象
    2. 遍历ResultSet对象并将每行数据暂存到HashMap实例中,以结果集的字段名或字段别名为键,以字段值为值
    3. 根据ResultMap标签的type属性通过反射实例化领域模型
    4. 根据ResultMap标签的type属性和id、result等标签信息将HashMap中的键值对,填充到领域模型实例中并返回

    一、resultMap

    1、属性说明

    • id属性 ,resultMap标签的标识。
    • type属性 ,返回值的全限定类名,或类型别名。
    • autoMapping属性 ,值范围true(默认值)|false, 设置是否启动自动映射功能,自动映射功能就是自动查找与字段名小写同名的属性名,并调用setter方法。而设置为false后,则需要在resultMap内明确注明映射关系才会调用对应的setter方法。

    2、基本作用:建立SQL查询结果字段与实体属性的映射关系
    示例1:通过setter构造领域模型

    public class EStudent{
      private long id;
      private String name;
      private int age;
      // getter,setter方法
    
      /**
       * 必须提供一个无参数的构造函数
       */
      public EStudent(){}
    }
    <select id="getStudent" resultMap="getStudentRM">
      SELECT ID, Name, Age
        FROM TStudent
    </select>
    <resultMap id="getStudentRM" type="EStudnet">
      <id property="id" column="ID"/>
      <result property="studentName" column="Name"/>
      <result property="studentAge" column="Age"/>
    </resultMap>

    子元素说明:

    • id元素 ,用于设置主键字段与领域模型属性的映射关系
    • result元素 ,用于设置普通字段与领域模型属性的映射关系

    id、result语句属性配置细节:

    属性 描述
    property 需要映射到JavaBean 的属性名称。
    column 数据表的列名或者标签别名。
    javaType 一个完整的类名,或者是一个类型别名。如果你匹配的是一个JavaBean,那MyBatis 通常会自行检测到。然后,如果你是要映射到一个HashMap,那你需要指定javaType 要达到的目的。
    jdbcType 数据表支持的类型列表。这个属性只在insert,update 或delete 的时候针对允许空的列有用。JDBC 需要这项,但MyBatis 不需要。如果你是直接针对JDBC 编码,且有允许空的列,而你要指定这项。
    typeHandler 使用这个属性可以覆写类型处理器。这项值可以是一个完整的类名,也可以是一个类型别名。

    示例2:通过构造函数构造领域模型

    <select id="getStudent" resultMap="getStudentRM">
      SELECT ID, Name, Age
        FROM TStudent
    </select>
    <resultMap id="getStudentRM" type="EStudnet">
      <constructor>
        <idArg column="ID" javaType="_long"/>
        <arg column="Name" javaType="String"/>
        <arg column="Age" javaType="_int"/>
      </constructor>
    </resultMap>

    子元素说明:

    • constructor元素 ,指定使用指定参数列表的构造函数来实例化领域模型。注意:其子元素顺序必须与参数列表顺序对应
    • idArg子元素 ,标记该入参为主键
    • arg子元素 ,标记该入参为普通字段(主键使用该子元素设置也是可以的)

    3、一对一关系、一对多关系查询

     注意:在采用嵌套结果的方式查询一对一、一对多关系时,必须要通过resultMap下的id或result标签来显式设置属性/字段映射关系,否则在查询多条记录时会仅仅返回最后一条记录的情况。
    

    association联合

    联合元素用来处理“一对一”的关系。需要指定映射的Java实体类的属性,属性的javaType(通常MyBatis 自己会识别)。对应的数据库表的列名称。如果想覆写的话返回结果的值,需要指定typeHandler。
    不同情况需要告诉MyBatis 如何加载一个联合。MyBatis 可以用两种方式加载:

    • select: 执行一个其它映射的SQL 语句返回一个Java实体类型。较灵活;
    • resultsMap: 使用一个嵌套的结果映射来处理通过join查询结果集,映射成Java实体类型。

    例如,一个班级对应一个班主任。
    首先定义好班级中的班主任 private TeacherEntity teacherEntity;

    使用select实现联合
    例:班级实体类中有班主任的属性,通过联合在得到一个班级实体时,同时映射出班主任实体。
    这样可以直接复用在TeacherMapper.xml文件中定义好的查询teacher根据其ID的select语句。而且不需要修改写好的SQL语句,只需要直接修改resultMap即可。

    ClassMapper.xml文件部分内容:

    <resultMap type="ClassEntity" id="classResultMap">  
        <id property="classID" column="CLASS_ID" />  
        <result property="className" column="CLASS_NAME" />  
        <result property="classYear" column="CLASS_YEAR" />  
        <association property="teacherEntity" column="TEACHER_ID" select="getTeacher"/>  
    </resultMap>  
    
    <select id="getClassByID" parameterType="String" resultMap="classResultMap">  
        SELECT * FROM CLASS_TBL CT  
        WHERE CT.CLASS_ID = #{classID};  
    </select> 

    TeacherMapper.xml文件部分内容:

    <resultMap type="TeacherEntity" id="teacherResultMap">  
        <id property="teacherID" column="TEACHER_ID" />  
        <result property="teacherName" column="TEACHER_NAME" />  
        <result property="teacherSex" column="TEACHER_SEX" />  
        <result property="teacherBirthday" column="TEACHER_BIRTHDAY"/>  
        <result property="workDate" column="WORK_DATE"/>  
        <result property="professional" column="PROFESSIONAL"/>  
    </resultMap>  
    
    <select id="getTeacher" parameterType="String"  resultMap="teacherResultMap">  
        SELECT *  
          FROM TEACHER_TBL TT  
         WHERE TT.TEACHER_ID = #{teacherID}  
    </select> 

    使用resultMap实现联合
    与上面同样的功能,查询班级,同时查询器班主任。需在association中添加resultMap(在teacher的xml文件中定义好的),新写sql(查询班级表left join教师表),不需要teacher的select。

    修改ClassMapper.xml文件部分内容:

    <resultMap type="ClassEntity" id="classResultMap">  
        <id property="classID" column="CLASS_ID" />  
        <result property="className" column="CLASS_NAME" />  
        <result property="classYear" column="CLASS_YEAR" />  
        <association property="teacherEntity" column="TEACHER_ID"  resultMap="teacherResultMap"/>  
    </resultMap>  
    
    <select id="getClassAndTeacher" parameterType="String" resultMap="classResultMap">  
        SELECT *  
          FROM CLASS_TBL CT LEFT JOIN TEACHER_TBL TT ON CT.TEACHER_ID = TT.TEACHER_ID  
         WHERE CT.CLASS_ID = #{classID};  
    </select> 

    其中的teacherResultMap请见上面TeacherMapper.xml文件部分内容中。

    collection聚集

    聚集元素用来处理“一对多”的关系。需要指定映射的Java实体类的属性,属性的javaType(一般为ArrayList);列表中对象的类型ofType(Java实体类);对应的数据库表的列名称;
    不同情况需要告诉MyBatis 如何加载一个聚集。MyBatis 可以用两种方式加载:
    1. select: 执行一个其它映射的SQL 语句返回一个Java实体类型。较灵活;
    2. resultsMap: 使用一个嵌套的结果映射来处理通过join查询结果集,映射成Java实体类型。

    例如,一个班级有多个学生。
    首先定义班级中的学生列表属性:private List<StudentEntity> studentList;

    使用select实现聚集
    用法和联合很类似,区别在于,这是一对多,所以一般映射过来的都是列表。所以这里需要定义javaType为ArrayList,还需要定义列表中对象的类型ofType,以及必须设置的select的语句名称(需要注意的是,这里的查询student的select语句条件必须是外键classID)。

    ClassMapper.xml文件部分内容:

    <resultMap type="ClassEntity" id="classResultMap">  
        <id property="classID" column="CLASS_ID" />  
        <result property="className" column="CLASS_NAME" />  
        <result property="classYear" column="CLASS_YEAR" />  
        <association property="teacherEntity" column="TEACHER_ID"  select="getTeacher"/>  
        <collection property="studentList" column="CLASS_ID" javaType="ArrayList" ofType="StudentEntity" select="getStudentByClassID"/>  
    </resultMap>  
    
    <select id="getClassByID" parameterType="String" resultMap="classResultMap">  
        SELECT * FROM CLASS_TBL CT  
        WHERE CT.CLASS_ID = #{classID};  
    </select>  

    StudentMapper.xml文件部分内容:

    <!-- java属性,数据库表字段之间的映射定义 -->  
    <resultMap type="StudentEntity" id="studentResultMap">  
        <id property="studentID" column="STUDENT_ID" />  
        <result property="studentName" column="STUDENT_NAME" />  
        <result property="studentSex" column="STUDENT_SEX" />  
        <result property="studentBirthday" column="STUDENT_BIRTHDAY" />  
    </resultMap>  
    
    <!-- 查询学生list,根据班级id -->  
    <select id="getStudentByClassID" parameterType="String" resultMap="studentResultMap">  
        <include refid="selectStudentAll" />  
        WHERE ST.CLASS_ID = #{classID}  
    </select> 

    使用resultMap实现聚集
    使用resultMap,就需要重写一个sql,left join学生表。

    <resultMap type="ClassEntity" id="classResultMap">  
        <id property="classID" column="CLASS_ID" />  
        <result property="className" column="CLASS_NAME" />  
        <result property="classYear" column="CLASS_YEAR" />  
        <association property="teacherEntity" column="TEACHER_ID"  resultMap="teacherResultMap"/>  
        <collection property="studentList" column="CLASS_ID" javaType="ArrayList" ofType="StudentEntity" resultMap="studentResultMap"/>  
    </resultMap>  
    
    <select id="getClassAndTeacherStudent" parameterType="String" resultMap="classResultMap">  
        SELECT *  
          FROM CLASS_TBL CT  
               LEFT JOIN STUDENT_TBL ST  
                  ON CT.CLASS_ID = ST.CLASS_ID  
               LEFT JOIN TEACHER_TBL TT  
                  ON CT.TEACHER_ID = TT.TEACHER_ID  
          WHERE CT.CLASS_ID = #{classID};  
    </select>  

    其中的teacherResultMap请见上面TeacherMapper.xml文件部分内容中。studentResultMap请见上面StudentMapper.xml文件部分内容中。

    4. 动态映射关系
    通过 discriminator子元素 (鉴别器)可以实现动态映射关系信息的设置。具体示例如下:

    public class EStudent{
      private long id;
      private String name;
      private String juniorHighSchool;
      private String seniorHighSchool;
      private int during; // 在本校就读时间
      // getter,setter方法
    
      /**
       * 必须提供一个无参数的构造函数
       */
      public EStudent(){}
    }

    情景:查询学生信息的seniorHighSchool信息,若就读时间during字段值为4、5、6时,则以juniorHighSchool字段作所为seniorHighSchool信息。

    <select id="getStundent" resultMap="rm">
      SELECT ID, Name, JuniorHighSchool, SeniorHighSchool, during
        FROM TStudent
    </select>
    <resultMap id="rm" type="EStudent">
      // 若不加这句,则当将juniorHighSchool赋予给seniorHighSchool属性时,juniorHighSchool属性将为null
      <result column="juniorHighSchool" property="juniorHighSchool"/>
    
      <discriminator column="during" javaType="_int">
        // 形式1:通过resultType设置动态映射信息
        <case value="4" resultType="EStudent">
          <result column="juniorHighSchool" property="seniorHighSchool"/>
        </case>
    
       // 形式2: 通过resultMap设置动态映射信息
       <case value="5" resultMap="dynamicRM"/>
       <case value="6" resultMap="dynamicRM"/>
      </discriminator>
    </resultMap>
    <resultMap id="dynamicRM" type="EStudent">
      <result column="juniorHighSchool" property="seniorHighSchool"/>
    </resultMap>

    注意:上面关于 discriminator子元素 的 case元素 的 resultType属性 和 resultMap元素 的 type属性 ,均不是直指返回的领域模型类型,而是指定根据判断条件后得到映射关系,可通过 id子元素 和 result子元素 重写映射关系。

    5. id元素,result元素,idArg元素,arg元素,discriminator元素的共同属性

    • javaType属性 :Java类的全限定名,或别名
    • jdbcType属性 :JDBC类型, JDBC类型为CUD操作时列可能为空时进行处理
    • typeHandler属性 :指定类型处理器的全限定类名或类型别名
    • column属性 :指定SQL查询结果的字段名或字段别名。将用于JDBC的 resultSet.getString(columnName)

    转载:http://www.cnblogs.com/fsjohnhuang/p/4076592.html
    http://limingnihao.iteye.com/blog/781878

    展开全文
  • resultMap的用法以及关联结果集映射

    万次阅读 多人点赞 2018-08-05 11:05:48
    如果sql查询到的字段与pojo的属性名不一致,则需要使用resultMap将字段名和属性名对应起来,进行手动配置封装,将结果映射到pojo中 resultMap resultMap可以实现将查询结果映射为复杂类型的pojo,比如在查询结果...

    resultType

    resultType可以把查询结果封装到pojo类型中,但必须pojo类的属性名和查询到的数据库表的字段名一致。
    如果sql查询到的字段与pojo的属性名不一致,则需要使用resultMap将字段名和属性名对应起来,进行手动配置封装,将结果映射到pojo中

    resultMap

    resultMap可以实现将查询结果映射为复杂类型的pojo,比如在查询结果映射对象中包括pojo和list实现一对一查询和一对多查询。
    这里写图片描述

    先在Mapper文件中,配置基本的sql语句

    <!-- 查询所有的订单数据 -->
        <!-- resultMap:填入配置的resultMap标签的id值 -->
        <select id="queryOrderAll" resultMap="orderResultMap">
            SELECT id, user_id,
            number,
            createtime, note FROM `order`
        </select>

    配置resultMap标签,映射不同的字段和属性名

    <!-- resultMap最终还是要将结果映射到pojo上,type就是指定映射到哪一个pojo -->
        <!-- id:设置ResultMap的id -->
        <resultMap type="order" id="orderResultMap">
            <!-- 定义主键 ,非常重要。如果是多个字段,则定义多个id -->
            <!-- property:主键在pojo中的属性名 -->
            <!-- column:主键在数据库中的列名 -->
            <id property="id" column="id" />
    
            <!-- 定义普通属性 -->
            <result property="userId" column="user_id" />
            <result property="number" column="number" />
            <result property="createtime" column="createtime" />
            <result property="note" column="note" />
        </resultMap>

    结果就可以封装到pojo类型中

    使用resultMap进行关联查询

    一对一查询

    一对一数据模型:订单用户
    一个订单信息只会是一个人下的订单,所以从查询订单信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的订单信息则为一对多查询,因为一个用户可以下多个订单。
    这里写图片描述

    • 改造pojo类
      在订单类中添加User属性,User属性是一个引用类型,用于存储关联查询的用户信息,因为关联关系是一对一,所以只需要添加单个属性即可
      这里写图片描述

    • 配置Mapper.xml配置文件
      OrderMapper.xml
      先使用id和result属性,映射order类的结果集,然后在使用association映射关联对象User的结果集

    <resultMap type="order" id="orderUserResultMap">
        <id property="id" column="id" />
        <result property="userId" column="user_id" />
        <result property="number" column="number" />
        <result property="createtime" column="createtime" />
        <result property="note" column="note" />
    
        <!-- association :配置一对一属性 -->
        <!-- property:order里面的User属性名 -->
            <!-- javaType:属性类型 -->
        <association property="user" javaType="user">
            <!-- id:声明主键,表示user_id是关联查询对象的唯一标识-->
            <id property="id" column="user_id" />
            <result property="username" column="username" />
            <result property="address" column="address" />
        </association>
    
    </resultMap>
    
    <!-- 一对一关联,查询订单,订单内部包含用户属性 -->
    <select id="queryOrderUserResultMap" resultMap="orderUserResultMap">
        SELECT
        o.id,
        o.user_id,
        o.number,
        o.createtime,
        o.note,
        u.username,
        u.address
        FROM
        `order` o
        LEFT JOIN `user` u ON o.user_id = u.id
    </select>
    • 测试
    @Test
    public void testQueryOrderUserResultMap() {
        // mybatis和spring整合,整合之后,交给spring管理
        SqlSession sqlSession = this.sqlSessionFactory.openSession();
        // 创建Mapper接口的动态代理对象,整合之后,交给spring管理
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    
        // 使用userMapper执行根据条件查询用户,结果封装到Order类中
        List<Order> list = userMapper.queryOrderUserResultMap();
        for (Order o : list) {
            System.out.println(o);
        }
        // mybatis和spring整合,整合之后,交给spring管理
        sqlSession.close();
    }
    • 结果
      这里写图片描述
    一对多查询

    查询所有用户信息及相关订单。

    • 修改pojo类,在pojo类添加订单集合属性
      这里写图片描述

    • 修改UserMapper.xml配置文件
      先使用id和result配置映射User类的结果,然后使用一对多关系的collection标签配置Order结果

    <resultMap type="user" id="userOrderResultMap">
        <id property="id" column="id" />
        <result property="username" column="username" />
        <result property="birthday" column="birthday" />
        <result property="sex" column="sex" />
        <result property="address" column="address" />
    
        <!-- 配置一对多的关系
            property:填写pojo类中集合类类属性的名称
            javaType:填写集合类型的名称 
        -->
        <collection property="orders" javaType="list" ofType="order">
            <!-- 配置主键,是关联Order的唯一标识 -->
            <id property="id" column="oid" />
            <result property="number" column="number" />
            <result property="createtime" column="createtime" />
            <result property="note" column="note" />
        </collection>
    </resultMap>
    
    <!-- 一对多关联,查询订单同时查询该用户下的订单 -->
    <select id="queryUserOrder" resultMap="userOrderResultMap">
        SELECT
        u.id,
        u.username,
        u.birthday,
        u.sex,
        u.address,
        o.id oid,
        o.number,
        o.createtime,
        o.note
        FROM
        `user` u
        LEFT JOIN `order` o ON u.id = o.user_id
    </select>
    • 测试结果
      这里写图片描述
    展开全文
  • 第一种:resultMap实现一对一的查询1.1.1 使用resultMap映射的思路使用resultMap将查询结果中的订单信息映射到Orders对象中,在orders类中添加User属性,将关联查询出来的用户信息映射到orders对象中的user属性中。...
  • mybatis中resultMap配置细则

    万次阅读 多人点赞 2019-06-20 22:41:15
    resultMap算是mybatis映射器中最复杂的一个节点了,能够配置的属性较多,我们在mybatis映射器配置细则这篇博客中已经简单介绍过resultMap的配置了,当时我们介绍了resultMap中的id和result节点,那么在resultMap中...
  • 【Mybatis】ResultMap标签

    千次阅读 2019-03-17 16:07:56
    resultMap&gt;标签写在mapper.xml中,是程序员控制SQL查询结果和实体类的映射关系! 1.1 Mybatis默认使用AutoMapping属性 2.使用&lt;resultMap&gt;标签时,&lt;select&gt;标签中不写&lt;...
  • mybatis中resultMap的理解

    万次阅读 多人点赞 2018-05-04 17:55:10
    resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码中解放出来, 并在一些情形下允许你做一些 JDBC 不支持的事情。 实际上,在对复杂语句进行联合映射的时候,它...
  • resultMap的使用

    千次阅读 2018-11-02 14:43:55
    ResultMap映射 适用场景: 当查询出来的字段名和对象中的属性名不一致的情况,就没办法使用resultType来默认映射(同名规则) 解决方案: 使用resultMap来映射数据库中的字段到底注入到对象中什么属性中. 具体操作 ...
  • mybatis中的resultType和resultMap简单解释

    千次阅读 2016-11-10 19:08:22
    mybatis中的resultType和resultMap简单解释
  • resultMap

    2018-01-12 20:31:02
    resultMap mapper.xml resultMap定义 注意:定义resultMap也要指定一个映射的pojo类型。 mapper.java 经过测试,可以实现功能
  • Mybatis中的resultType和resultMap

    万次阅读 多人点赞 2014-05-29 13:13:17
    MyBatis中在查询进行select映射的时候,返回类型可以用resultType,也可以用resultMap,resultType是直接表示返回类型的,而resultMap则是对外部ResultMap的引用,但是resultType跟resultMap不能同时存在。...
  • MyBatis之resultMap的作用和xml配置折腾

    万次阅读 2019-09-18 12:38:10
    简单的搭建。 MyBatis实战——前身iBatis、基础环境搭建和如何"钓鱼"这篇写了基础的环境搭建和代码操作。 我这里是使用了xml加interface结合的方法进行操作。现有Employee类。如果是简单的select,可以看看下面...
  • ResultMap

    2017-09-13 22:41:39
    column=”表中列” property=”model中类的属性名” 注意点:select 中的resultMap=“”
  • Mybatis之ResultMap简介,关联对象

    万次阅读 2014-10-31 11:01:59
    MyBatis中在查询进行select映射的时候,返回类型可以用resultType,也可以用resultMap,resultType是直接表示返回类型的,而resultMap则是对外部ResultMap的引用,但是resultType跟resultMap
  • ResultMap collection多层嵌套使用

    千次阅读 热门讨论 2019-12-11 11:55:13
    ResultMap collection多层嵌套使用 ResultMap介绍 在Mybatis使用中,ResultMap是最复杂的一种结构,也是功能最强大的结构之一。通过ResultMap能够将复杂的1对多的结果集映射到一个实体当中去,可以借助Mybatis来将...
  • resultMap与resultType、parameterMap与 parameterType的区别

    万次阅读 多人点赞 2019-01-11 15:35:58
     resultMap 与 resultType、parameterMap 与 parameterType的区别在面试的时候被问到的几率非常高,出现的次数到了令人发指的地步,笔者认为有必要单独列一章郑重声明,共勉 resultMap &amp; resultType   ...
  • MyBatis源码分析之@ResultMap注解详解

    千次阅读 2019-01-10 08:19:22
    在前一篇文章讲**@MapKey注解时,我原想将@ResultMap注解也一起拿出来说一下,但是发现@ResultMap解析加载源码非常多,想想就不在一篇文章中讲了,分开单独来说,这一篇就来彻底探索一下@ResultMap**注解。...
  • 13.1、自定义结果集介绍 ...这个时候就需要使用resultMap自定义结果集来返回需要的数据。 13.2、创建一对一数据库表 一对一数据表 创建锁表 create table t_lock( id int primary key auto_incre...
  • Mapper配置之ResultMap详解

    千次阅读 2017-08-20 16:54:57
    MyBatis是基于“数据库结构不可控”的思想建立的,也就是我们希望数据库遵循第三范式或BCNF,但实际事与愿违,那么结果集映射就是MyBatis为我们提供这种理想与现实间转换的手段了,而resultMap就是结果集映射的配置...
1 2 3 4 5 ... 20
收藏数 75,462
精华内容 30,184
关键字:

resultmap