• Mybatis开发要点：resultType和resultMap的区别？

    Mybatis返回Xml返回值有resultType和resultMap，我们一般都该如何选择呢？

    一、resultType

    1.1 resultType介绍

    当使用resultType做SQL语句返回结果类型处理时，对于SQL语句查询出的字段在相应的pojo中必须有和它相同的字段对应，而resultType中的内容就是pojo在本项目中的位置。

    1.2 映射规则

    • 基本类型 ：resultType=基本类型
    • List类型： resultType=List中元素的类型
    • Map类型 单条记录：resultType =map 多条记录：resultType =Map中value的类型

    1.3 自动映射注意事项

    • 前提：SQL列名和JavaBean的属性是一致的；
    • 使用resultType，如用简写需要配置typeAliases （别名）；
    • 如果列名和JavaBean不一致，但列名符合单词下划线分割，Java是驼峰命名法，则mapUnderscoreToCamelCase可设置为true；

    1.4 代码演示

    （1）t_user_test.sql准备

    1. CREATE TABLE `t_user_test` (
    2.   `id` int(20) NOT NULL AUTO_INCREMENT,
    3.   `user_name` varchar(60) DEFAULT NULL COMMENT '用户名称',
    4.   `real_name` varchar(60) DEFAULT NULL COMMENT '真实名称',
    5.   `sex` tinyint(3) DEFAULT NULL COMMENT '姓名',
    6.   `mobile` varchar(20) DEFAULT NULL COMMENT '电话',
    7.   `email` varchar(60) DEFAULT NULL COMMENT '邮箱',
    8.   `note` varchar(200) DEFAULT NULL COMMENT '备注',
    9.   PRIMARY KEY (`id`)
    10. ) ENGINE=InnoDB AUTO_INCREMENT=142 DEFAULT CHARSET=utf8;

    （2）实体类

    1. package com.enjoylearning.mybatis.entity;
    2.  
    3. import java.io.Serializable;
    4. import java.util.List;
    5.  
    6. import org.apache.ibatis.annotations.Param;
    7.  
    8. import com.mysql.jdbc.Blob;
    9.  
    10. public class TUser implements Serializable{
    11. 	
    12.     private Integer id;
    13.  
    14.     private String userName;
    15.  
    16.     private String realName;
    17.  
    18.     private Byte sex;
    19.  
    20.     private String mobile;
    21.  
    22.     private String email;
    23.  
    24.     private String note;
    25.  
    26.     private TPosition position;
    27.     
    28.     private List<TJobHistory> jobs ;
    29.     
    30.     private List<HealthReport> healthReports;
    31.  
    32.     
    33.     private List<TRole> roles;
    34.  
    35.  
    36.   
    37. 	@Override
    38. 	public String toString() {
    39. 		String positionId=  (position == null ? "" : String.valueOf(position.getId()));
    40. 		return "TUser [id=" + id + ", userName=" + userName + ", realName="
    41. 				+ realName + ", sex=" + sex + ", mobile=" + mobile + ", email="
    42. 				+ email + ", note=" + note + ", positionId=" + positionId + "]";
    43. 	}
    44.  
    45.  
    46. 	public Integer getId() {
    47. 		return id;
    48. 	}
    49. 	public void setId(Integer id) {
    50. 		this.id = id;
    51. 	}
    52. 	public String getUserName() {
    53. 		return userName;
    54. 	}
    55. 	public void setUserName(String userName) {
    56. 		this.userName = userName;
    57. 	}
    58. 	public String getRealName() {
    59. 		return realName;
    60. 	}
    61. 	public void setRealName(String realName) {
    62. 		this.realName = realName;
    63. 	}
    64. 	
    65. 	public Byte getSex() {
    66. 		return sex;
    67. 	}
    68.  
    69. 	public void setSex(Byte sex) {
    70. 		this.sex = sex;
    71. 	}
    72.  
    73.  
    74. 	public String getMobile() {
    75. 		return mobile;
    76. 	}
    77.  
    78.  
    79. 	public void setMobile(String mobile) {
    80. 		this.mobile = mobile;
    81. 	}
    82.  
    83.  
    84. 	public String getEmail() {
    85. 		return email;
    86. 	}
    87.  
    88.  
    89. 	public void setEmail(String email) {
    90. 		this.email = email;
    91. 	}
    92.  
    93.  
    94. 	public String getNote() {
    95. 		return note;
    96. 	}
    97.  
    98. 	public void setNote(String note) {
    99. 		this.note = note;
    100. 	}
    101.  
    102.  
    103. 	public TPosition getPosition() {
    104. 		return position;
    105. 	}
    106.  
    107.  
    108. 	public void setPosition(TPosition position) {
    109. 		this.position = position;
    110. 	}
    111.  
    112. 	public List<TJobHistory> getJobs() {
    113. 		return jobs;
    114. 	}
    115.  
    116.  
    117. 	public void setJobs(List<TJobHistory> jobs) {
    118. 		this.jobs = jobs;
    119. 	}
    120.  
    121. 	public List<HealthReport> getHealthReports() {
    122. 		return healthReports;
    123. 	}
    124.  
    125. 	public void setHealthReports(List<HealthReport> healthReports) {
    126. 		this.healthReports = healthReports;
    127. 	}
    128.  
    129. 	public List<TRole> getRoles() {
    130. 		return roles;
    131. 	}
    132.  
    133. 	public void setRoles(List<TRole> roles) {
    134. 		this.roles = roles;
    135. 	}
    136.  
    137. }

    （3）Mapper接口类

    1. public interface TUserTestMapper {
    2. 	
    3. 	TUser selectByPrimaryKey(Integer id);
    4. 	List<TUser> selectAll();
    5.  
    6. }

    （4）Mapper xml

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    3. <mapper namespace="com.mybatis.mapper.TUserTestMapper">
    4.  
    5.  
    6. 	<select id="selectByPrimaryKey" resultType="TUser">
    7. 		select
    8. 		id, user_name, real_name, sex, mobile, email, note
    9. 		from t_user_test
    10. 		where id = #{id,jdbcType=INTEGER}
    11. 	</select>
    12. 	
    13. 	
    14. 	<select id="selectAll" resultType="TUser">
    15. 		select
    16. 		id, user_name, real_name, sex, mobile, email, note
    17. 		from t_user_test
    18. 	</select>
    19.  
    20.  
    21. </mapper>

    （5）配置文件

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
    3. <configuration>
    4.  
    5. 	<properties resource="db.properties"/>
    6. 	
    7.  	<settings>
    8. 		<!-- 设置自动驼峰转换		 -->
    9. 		<setting name="mapUnderscoreToCamelCase" value="true" />
    10.  
    11. 		<!-- 开启懒加载 -->		
    12. 		 <!-- 当启用时，有延迟加载属性的对象在被调用时将会完全加载任意属性。否则，每种属性将会按需要加载。默认：true -->
    13. 	  <setting name="aggressiveLazyLoading" value="false" />
    14.  
    15. 	</settings>
    16. 	<!-- 别名定义 -->
    17. 	<typeAliases>
    18. 		<package name="com.enjoylearning.mybatis.entity" />
    19. 	</typeAliases>
    20. 	
    21.  	<plugins>
    22. 		<plugin interceptor="com.enjoylearning.mybatis.Interceptors.ThresholdInterceptor"> 
    23. 			<property name="threshold" value="10"/>
    24. 		</plugin>
    25. 			
    26.   		 <plugin interceptor="com.github.pagehelper.PageInterceptor">
    27. 			<property name="pageSizeZero" value="true" />
    28. 		</plugin>
    29. 	</plugins>
    30.  
    31.  
    32. 	<!--配置environment环境 -->
    33. 	<environments default="development">
    34. 		<!-- 环境配置1，每个SqlSessionFactory对应一个环境 -->
    35. 		<environment id="development">
    36. 			<transactionManager type="JDBC" />
    37. 			<dataSource type="POOLED">
    38. 				<property name="driver" value="com.mysql.jdbc.Driver" />
    39. 				<property name="url" value="jdbc:mysql://ip：port/test?useUnicode=true" />
    40. 				<property name="username" value="root" />
    41. 				<property name="password" value="123456" />
    42. 			</dataSource>
    43. 		</environment>
    44. 	</environments>
    45.  
    46. 	<!-- 映射文件，mapper的配置文件 -->
    47. 	<mappers>
    48. 		<!--直接映射到相应的mapper文件 -->
    49. 		<mapper resource="sqlmapper/TUserTestMapper.xml" />
    50. 	</mappers>
    51.  
    52. </configuration>

    （6）启动测试类

    1. public class MybatisDemo2 {
    2. 	
    3. 	private SqlSessionFactory sqlSessionFactory;
    4. 	
    5. 	@Before
    6. 	public void init() throws IOException {
    7. 		//--------------------第一阶段---------------------------
    8. 	    // 1.读取mybatis配置文件创SqlSessionFactory
    9. 		String resource = "mybatis-config.xml";
    10. 		InputStream inputStream = Resources.getResourceAsStream(resource);
    11. 		// 1.读取mybatis配置文件创SqlSessionFactory
    12. 		sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    13. 		inputStream.close();
    14. 	}
    15.  
    16. 	@Test
    17. 	//知识点：resultType
    18. 	public void testAutoMapping() throws IOException {
    19. 		// 2.获取sqlSession	
    20. 		SqlSession sqlSession = sqlSessionFactory.openSession();
    21. 		// 3.获取对应mapper
    22. 		TUserTestMapper mapper = sqlSession.getMapper(TUserTestMapper.class);
    23. 		// 4.执行查询语句并返回多条数据
    24. 		
    25. 		List<TUser> users = mapper.selectAll();
    26. 		for (TUser tUser : users) {
    27. 			System.out.println(tUser);
    28. 		}
    29. 		
    30. 	}
    31. 	
    32. }

    （7）执行结果

    1. sql语句：“com.mysql.jdbc.JDBC4PreparedStatement@654f0d9c: select
    2. 		id, user_name, real_name, sex, mobile, email, note
    3. 		from t_user_test”执行时间为：35毫秒，已经超过阈值！
    4. TUser [id=1, userName=zhangsan, realName=张三, sex=1, mobile=186995587411, email=zhangsan@qq.com, note=zhangsan的备注, positionId=]
    5. TUser [id=2, userName=lisi, realName=李四, sex=1, mobile=18677885200, email=lisi@qq.com, note=lisi的备注, positionId=]
    6. TUser [id=3, userName=wangwu, realName=王五, sex=2, mobile=18695988747, email=xxoo@163.com, note=wangwu's note, positionId=]

    resultType当返基本类型的时候建议选择，当返回POJO类的时候由于需要完全和数据库字段进行对应，存在不灵活、问题排查难等问题。

    二、resultMap

    2.1 resultMap 介绍

    resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码中解放出来,在对复杂语句进行联合映射的时候，它很可能可以代替数千行的同等功能的代码。ResultMap 的设计思想是，简单的语句不需要明确的结果映射，而复杂一点的语句只需要描述它们的关系就行了。

    2.2 resultMap属性

    2.3 使用场景

    • 字段有自定义的转化规则
    • 复杂的多表查询

    2.4 resultMap子元素属性

    • id –一个 ID 结果;标记出作为 ID 的结果可以帮助提高整体性能,一对多的查询中用于结果集合并；
    • result – 注入到字段或 JavaBean 属性的普通结果
    • association – 一个复杂类型的关联;许多结果将包装成这种类型。关联可以指定为一个 resultMap 元素，或者引用一个
    • collection – 一个复杂类型的集合

    2.5 代码演示

    实体类，配置文件同上

    （1）mapper接口

    1.   public interface TUserMapper {
    2.  
    3. 	List<TUser> selectTestResultMap();
    4.     
    5. }

    （2）Mapper.xml

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    3. <mapper namespace="com.mybatis.mapper.TUserMapper">
    4.  
    5. 	<resultMap id="UserResultMap" type="TUser" autoMapping="true">
    6. 		<id column="id" property="id" />
    7.         <result column="userName" property="userName"/>
    8. 		<result column="realName" property="realName" />
    9. 		<result column="sex" property="sex" />
    10. 		<result column="mobile" property="mobile" />
    11. 		<result column="email" property="email" />
    12. 		<result column="note" property="note" />
    13. 		<association property="position" javaType="TPosition" columnPrefix="post_">
    14. 			<id column="id" property="id"/>
    15. 			<result column="name" property="postName"/>
    16. 			<result column="note" property="note"/>
    17. 		</association>
    18. 	</resultMap>
    19.  
    20. 	<select  id="selectTestResultMap" resultMap="UserResultMap" >
    21. 		select
    22. 		    a.id,
    23. 		    userName,
    24. 			realName,
    25. 			sex,
    26. 			mobile,
    27. 			email,
    28. 			a.note,
    29. 			b.id  post_id,
    30. 			b.post_name,
    31. 			b.note post_note
    32. 		from t_user a,
    33. 			t_position b
    34. 		where a.position_id = b.id
    35.  
    36. 	</select>
    37.  
    38. </mapper>

    （3）启动测试

    1.  
    2. public class MybatisDemo2 {
    3. 	
    4.  
    5. 	private SqlSessionFactory sqlSessionFactory;
    6. 	
    7. 	@Before
    8. 	public void init() throws IOException {
    9. 		//--------------------第一阶段---------------------------
    10. 	    // 1.读取mybatis配置文件创SqlSessionFactory
    11. 		String resource = "mybatis-config.xml";
    12. 		InputStream inputStream = Resources.getResourceAsStream(resource);
    13. 		// 1.读取mybatis配置文件创SqlSessionFactory
    14. 		sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    15. 		inputStream.close();
    16. 	}
    17.  
    18.  
    19. 	
    20. 	@Test
    21. 	public void testResultMap() throws IOException {
    22. 		//--------------------第二阶段---------------------------
    23. 		// 2.获取sqlSession	
    24. 		SqlSession sqlSession = sqlSessionFactory.openSession();
    25. 		// 3.获取对应mapper
    26. 		TUserMapper mapper = sqlSession.getMapper(TUserMapper.class);
    27. 		
    28. 		//--------------------第三阶段---------------------------
    29.  
    30. 		// 4.执行查询语句并返回单条数据
    31. 		List<TUser> users = mapper.selectTestResultMap();
    32. 		for (TUser tUser : users) {
    33. 			System.out.println(tUser.getUserName());
    34. 			System.out.println(tUser.getPosition().getPostName());
    35. 		}
    36. 	}
    37. }

    （4）执行结果

    1. sql语句：“com.mysql.jdbc.JDBC4PreparedStatement@19bb07ed: select
    2. 		    a.id,
    3. 		    userName,
    4. 			realName,
    5. 			sex,
    6. 			mobile,
    7. 			email,
    8. 			a.note,
    9. 			b.id  post_id,
    10. 			b.post_name,
    11. 			b.note post_note
    12. 		from t_user a,
    13. 			t_position b
    14. 		where a.position_id = b.id”执行时间为：52毫秒，已经超过阈值！
    15. zhangsan
    16. 总经理
    17. lisi
    18. 零时工
    19. wangwu
    20. 总经理

    三、结论

    当返回对象为基础类型时建议走resultType，当返回对象为POJO时，强制走resultMap。同时可以参考阿里巴巴JAVA开发手册中的5.4.3节，返回要解耦，不讷讷更直接使用resultClass。

    作者：Dark_King_

    原文链接：
    https://blog.csdn.net/b379685397/article/details/114265301

  • 相关阅读:
    macOS 查验国家税务总局发票
    Maven在IDEA中的使用，＜buid＞、＜properties＞标签
    【PyTorch】2-主要组成模块（数据读入、模型构建、损失函数、评价指标、训练和测试、优化器）
    计算机网络的性能指标
    【无标题】
    [excel与dict] python 读取excel内容并放入字典、将字典内容写入 excel文件
    【c++】——类和对象(中)——实现完整的日期类(优化）万字详细解疑答惑
    从实例来看DAO：权力分散的伟大尝试
    Socket编程基础（1）
    市场逆风中，海尔智家如何续写增长故事
  • 原文地址：https://blog.csdn.net/m0_67645544/article/details/124804183