mybatis 映射结果集

最新推荐文章于 2024-06-16 10:23:56 发布
最新推荐文章于 2024-06-16 10:23:56 发布
阅读量272 收藏
点赞数
分类专栏： mybits 文章标签： 映射结果集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41877184/article/details/103322008
版权

映射结果集

1、全局setting设置
– autoMappingBehavior默认是PARTIAL ，开启自动映射 的功能。唯一的要求是列名和javaBean属性名一致
– 如果autoMappingBehavior设置为null则会取消自动映射
– 数据库字段命名规范，POJO属性符合驼峰命名法，如 A_COLUMN aColumn，我们可以 开启自动驼峰命名规 则映射功能， mapUnderscoreToCamelCase=true。
2、resultType用来自动映射javabean对象，往往对象中 只有基本数据类型 ，如果有引用数据类型通常使用 自定义resultMap。
3、自定义resultMap(重难点)，实现高级结果集映射，往往在javabean对象中有引用类型。
 

Select元素来定义查询操作

Id：唯一标识符。
– 用来引用这条语句，需要和接口的方法名一致

parameterType：参数类型。
– 可以不传，MyBatis会根据TypeHandler自动推断

resultType：返回值类型。
– 别名或者全类名，如果返回的是集合，定义集合中元素的类型。不能和resultMap同时使用。
– 常使用自动映射
 
resultMap：也是返回值类型与resultType相似
– 外部自定义的返回值
– 手动实现自定义结果集映射
 

以resultType举例

javabean：

public class Employee {
	
	private Integer id;
	private String lastName;
	private String email;
	private String gender;
}

数据库：

Dao层接口：

public interface EmployeeMapperSelect {
	//测试：resultType
	public Employee getEmployeeById(Integer id);	
	public List<Employee> getEmpsByLastNameLike(String lastName);	
	public Map<String, Object> getEmpByIdReturnMap(Integer id);		
	//mybatis封装这个map的时候使用哪个属性作为主键
	@MapKey("id")
	public Map<Integer, Employee> getEmpByLastNameLikeReturnMap(String lastName);
}

案例：
1）简单查询

<select id="getEmployeeById" resultType="com.bean.Employee">
 	 select * from tbl_employee where id=#{id}
 </select>
//简单查询
@Test
public void test01() throws IOException{
	SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
	SqlSession openSession=sqlSessionFactory.openSession();
	EmployeeMapperSelect mapper=openSession.getMapper(EmployeeMapperSelect.class);
	Employee employee=mapper.getEmployeeById(16);
	System.out.println(employee);	
}

2）模糊查询返回List<Employee>

<select id="getEmpsByLastNameLike"	resultType="com.bean.Employee">
 	select * from tbl_employee where last_name like #{lastName}
</select>
@Test
public void test02() throws IOException{
	SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
	SqlSession openSession=sqlSessionFactory.openSession();
	EmployeeMapperSelect mapper=openSession.getMapper(EmployeeMapperSelect.class);
	List<Employee> employee=mapper.getEmpsByLastNameLike("%a%");
	System.out.println(employee);	
}

3）Map返回单条记录->key是数据库列名，value是对应的值

<select id="getEmpByIdReturnMap"	resultType="map">
 	select * from tbl_employee where id=#{id}
</select>
@Test
public void test03() throws IOException{
	SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
	SqlSession openSession=sqlSessionFactory.openSession();
	EmployeeMapperSelect mapper=openSession.getMapper(EmployeeMapperSelect.class);
	Map<String, Object> map=mapper.getEmpByIdReturnMap(14);
	System.out.println(map);	
}

4）Map返回多条记录->key是该条记录的键(自定义)，value是封装后的javabean

如何指定key？在dao层接口上添加注解-->告诉mybatis封装这个map的时候使用哪个属性作为键。
例如：@MapKey("id") 用封装employee后中的id属性作为键。

@MapKey("id")
public Map<Integer, Employee> getEmpByLastNameLikeReturnMap(String lastName);
<select id="getEmpByLastNameLikeReturnMap"	resultType="com.bean.Employee">
    select * from tbl_employee where last_name like #{lastName}
</select>  
@Test
public void test04() throws IOException{
	SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
	SqlSession openSession=sqlSessionFactory.openSession();
	EmployeeMapperSelect mapper=openSession.getMapper(EmployeeMapperSelect.class);
	Map<Integer, Employee> map=mapper.getEmpByLastNameLikeReturnMap("%a%");
	System.out.println(map);		
}

以resultMap举例(重难点)：

加大难度后的需求1：联表查询部门信息

新的数据库字段:

新的javabean字段:

public class Employee2 {
	private Integer id;
	private String lastName;
	private String email;
	private String gender;
	private Department dept;
    ......
}
public class Department {
	
	private Integer id;
	private String departmentName;
	private List<Employee> emps;
    .......
}

Dao层接口()：

//测试：resultMap
public Employee2 getEmpAndDept(Integer id);
public Employee2 getEmpAndDeptAssociation(Integer id);
public Employee2 getEmpByIdStep(Integer id);

手动设置映射关系-->指定数据库字段名与javabean字段名 封装规则: 

<id />为主键属性
<result />为其余属性

1）嵌套结果集(级联属性封装结果集，例如dept.id)：

<!-- id  last_name gender did dept_name -->
<resultMap type="com.bean.Employee2" id="MyDifEmp">
	<id column="id" property="id"/>
	<result column="last_name" property="lastName"/>
	<result column="email" property="email"/>
	<result column="gender" property="gender"/>
	<result column="did" property="dept.id"/>	
	<result column="dept_name" property="dept.departmentName"/>
</resultMap>

<select id="getEmpAndDept" resultMap="MyDifEmp">
 	select e.id id,e.last_name last_name,e.email email,e.gender gender,e.d_id d_id
 	,d.id did,d.dept_name dept_name	
 	from tbl_employee e,tbl_dept d where e.d_id=d.id AND e.id=#{id};
</select>

id=17，sql语句执行结果： 

@Test
public void test05() throws IOException{
	SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
	SqlSession openSession=sqlSessionFactory.openSession();
	EmployeeMapperSelect mapper=openSession.getMapper(EmployeeMapperSelect.class);
	Employee2 employee2=mapper.getEmpAndDept(17);
	System.out.println(employee2);	
	System.out.println(employee2.getDept());	
}

2） 嵌套结果集(association定义单个对象封装规则）

association可以指定联合的javabean对象：
property：指定哪个属性是联合对象
javaType：指定这个属性对象的类型

<resultMap type="com.bean.Employee2" id="MyDifEmp2">
	<id column="id" property="id"/>
	<result column="last_name" property="lastName"/>
	<result column="email" property="email"/>
	<result column="gender" property="gender"/>
		
	<association property="dept" javaType="com.bean.Department">
		<id column="did" property="id"/>
		<result column="dept_name" property="departmentName"/>
	</association>
</resultMap>
<select id="getEmpAndDeptAssociation" resultMap="MyDifEmp2">
 	 select e.id id,e.last_name last_name,e.email email,e.gender gender,e.d_id d_id
 	 ,d.id did,d.dept_name dept_name	
 	from tbl_employee e,tbl_dept d where e.d_id=d.id AND e.id=#{id};
</select>
<select id="getDeptById" resultType="com.bean.Department">
	select id,dept_name departmentName from tbl_dept where id=#{id}
</select>

3）分步查询(association定义单个对象封装规则）

思路：
1、先按照员工id查询员工信息
2、根据查询员工信息中的d_id值去部门表查出部门信息
3、将部门设置到员工当中

新添加的Dao层：

package com.dao;

import com.bean.Department;

public interface DepartmentMapper {
	
	public Department getDeptById(Integer id);//此案例的方法
	
	public Department getDeptByIdPlus(Integer id);

	public Department getDeptByIdStep(Integer id);
}

新添加的DepartmentMapperMapper.xml：

<select id="getDeptById" resultType="com.bean.Department">
	select id,dept_name departmentName from tbl_dept where id=#{id}
</select>

执行流程：调用用getEmpByIdStemp方法，返回员工信息，再使用select指定的方法(传入column指定的这列参数的值)查出对象，并封装给property指定的属性。
分步的核心： property(属性值)调用select(查询方法)利用column(传递参数) 

 	 <resultMap type="com.bean.Employee2" id="MyEmpByStep">
		<id column="id" property="id"/>
		<result column="last_name" property="lastName"/>
		<result column="email" property="email"/>
		<result column="gender" property="gender"/>
		<!-- property(属性值)调用select(查询方法)利用column(传递参数) -->
		<!-- 流程：使用select指定的方法(传入column指定的这列参数的值)查出对象，并封装给property指定的属性 -->
		 <association property="dept" 
		 	select="com.dao.DepartmentMapper.getDeptById"
		 	column="d_id">
		 </association>
	 </resultMap>

    <select id="getEmpByIdStep" resultMap="MyEmpByStep">
		select * from tbl_employee where id=#{id}
    </select>
	//分步查询association
	@Test
	public void test06() throws IOException{
		SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
		SqlSession openSession=sqlSessionFactory.openSession();
		EmployeeMapperSelect mapper=openSession.getMapper(EmployeeMapperSelect.class);
		Employee2 employee2=mapper.getEmpByIdStep(17);
		System.out.println(employee2);	
		System.out.println(employee2.getDept());	
	}

可以分析得出：发送了两条sql语句，只要执行就是两条，有时候可能不需要部门信息，这样容易带来不必要的资源消耗，下面将介绍延迟加载技术！

4）分步查询的延迟加载
实质就是-按需加载，减少资源消耗。

在案例3）中稍作修改：
1、添加两个全局配置

<settings>		
	<!--显示的指定每个我们需要更改的配置的值，即使他是默认的。防止版本更新带来的问题  -->
	<setting name="lazyLoadingEnabled" value="true"/>
	<setting name="aggressiveLazyLoading" value="false"/><!-- 属性按需加载 -->		
</settings>

2、测试类少写一行：

	//分步查询(延迟加载)
	@Test
	public void test07() throws IOException{
		SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
		SqlSession openSession=sqlSessionFactory.openSession();
		EmployeeMapperSelect mapper=openSession.getMapper(EmployeeMapperSelect.class);
		Employee2 employee2=mapper.getEmpByIdStep(17);
		System.out.println(employee2.getEmail());	
		//System.out.println(employee2.getDept());	
	}

结果分析：只发送了一条sql语句！因为我们现在不需要Department相关信息，因此分步查询第二条语句不会发送。

再次加大难度需求2：查询部门对应的所有员工信息也查询出来

增加后的Dao层(DepartmentMapper)：

public interface DepartmentMapper {
	//association 演示分步查询
	public Department getDeptById(Integer id);
	//嵌套查询
	public Department getDeptByIdPlus(Integer id);
    //分步查询
	public Department getDeptByIdStep(Integer id);
}

修改后的javabean：

public class Department {
	
	private Integer id;
	private String departmentName;
	private List<Employee> emps;
}

5）嵌套的方式(collection定义关联的集合类型的属性封装规则)

collection定义关联集合类型的属性的封装规则 
ofType:指定集合里面元素的类型 

	<!--嵌套结果集的方式，使用collection标签定义关联的集合类型的属性封装规则  -->
	<resultMap type="com.bean.Department" id="MyDept">
		<id column="did" property="id"/>
		<result column="dept_name" property="departmentName"/>
		<!-- 
			collection定义关联集合类型的属性的封装规则 
			ofType:指定集合里面元素的类型
		-->
		<collection property="emps" ofType="com.bean.Employee">
			<!-- 定义这个集合中元素的封装规则 -->
			<id column="eid" property="id"/>
			<result column="last_name" property="lastName"/>
			<result column="email" property="email"/>
			<result column="gender" property="gender"/>
		</collection>
	</resultMap>
	<!-- public Department getDeptByIdPlus(Integer id); -->
	<select id="getDeptByIdPlus" resultMap="MyDept">
		SELECT d.id did,d.dept_name dept_name,
				e.id eid,e.last_name last_name,e.email email,e.gender gender
		FROM tbl_dept d
		LEFT JOIN tbl_employee e
		ON d.id=e.d_id
		WHERE d.id=#{id}
	</select>
	//分步查询返回集合(collection)
	@Test
	public void test08() throws IOException{
		SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
		SqlSession openSession=sqlSessionFactory.openSession();
		DepartmentMapper mapper=openSession.getMapper(DepartmentMapper.class);
		Department department=mapper.getDeptByIdPlus(1);
		System.out.println(department);	
		System.out.println(department.getEmps());	
	}
	//分步查询返回带有的集合(collection)
	@Test
	public void test09() throws IOException{
		SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
		SqlSession openSession=sqlSessionFactory.openSession();
		DepartmentMapper mapper=openSession.getMapper(DepartmentMapper.class);
		Department department=mapper.getDeptByIdStep(1);
		System.out.println(department);	
		System.out.println(department.getEmps());	
	}


 6）分步查询(collection)

EmployeeMapperSelect.java多添加一行(Dao层)

public Employee2 getEmpsByDeptId(Integer id);//测试collection分步查询
 	 <!-- collection分步查询 -->
	<select id="getEmpsByDeptId" resultType="com.bean.Employee2">
			select * from tbl_employee where d_id=#{deptId};
 	 </select>
	<!-- collection：分段查询 -->
	<resultMap type="com.bean.Department" id="MyDeptStep">
		<id column="id" property="id"/>
		<id column="dept_name" property="departmentName"/>
		<collection property="emps" 
			select="com.dao.EmployeeMapperSelect.getEmpsByDeptId"
			column="{deptId=id}" >
		</collection>
	</resultMap>
	<!-- public Department getDeptByIdStep(Integer id); -->
	<select id="getDeptByIdStep" resultMap="MyDeptStep">
		select id,dept_name from tbl_dept where id=#{id}
	</select>
	//分步查询返回带有的集合(collection)
	@Test
	public void test09() throws IOException{
		SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
		SqlSession openSession=sqlSessionFactory.openSession();
		DepartmentMapper mapper=openSession.getMapper(DepartmentMapper.class);
		Department department=mapper.getDeptByIdStep(1);
		System.out.println(department);	
		System.out.println(department.getEmps());	
	}

 

扩展：
1)分步查询中传递多个值得时候

<collection property=" " select=" " column="{key1=column1,key2=column2}" >

2)分步查询中局部开启延迟加载

fetchType="lazy" ：表示延迟加载
fetchType="lazy"：表示立即查询

<collection property=" " select=" " column="{key1=column1,key2=column2}" fetchType="lazy">

 

Zero-place
关注
专栏目录
MyBatis 结果映射总结
m0_67698950的博客
05-24 2954
前言 结果映射指的是将数据表中的字段与实体类中的属性关联起来，这样 MyBatis 就可以根据查询到的数据来填充实体对象的属性，帮助我们完成赋值操作。其实 MyBatis 的官方文档对映射规则的讲解还是非常清楚的，但考虑到自己马上就会成为一名 SQL Boy，以后免不了经常跟 SQL 打交道（公司使用的也是 MyBatis），所以希望用更加通俗的语言对官方文档所介绍的常用映射规则做一个总结，既为刚入门的同学提供一个参考，也方便自己以后查阅。本文会结合一些常见的应用场景，并通过简单的示例来介绍不同...
Mybatis复杂的结果集映射（多对一关系）
weixin_44976835的博客
12-21 511
多对一关系: 学生–老师： 首先搭建环境： 拷贝db.properties、log4j.properties、mybatis-config.xml文件 创建Student、Teacher实体类。 创建StudentMapper、TeacherMapper接口 创建StudentMapper.xml、TeacherMapper.xml文件 在mubatis-config.xml中注册StudentMapper、TeacherMapper映射器。 查询所有学生信息以及对应的老师的信息： 首先确定sql语句：
MyBatis结果集映射
qq_43560701的博客
08-14 912
MyBatis结果集映射 本节新建 MyBatis-03项目，研究如何解决属性名和字段名不一致的问题。 1. 正常情况 将 MyBatis-02项目的内容复制进来，并且在 UserMapper 接口和 UserMapper.xml 配置中只保留根据 ID 查询用户方法。此时 User 实体类，UserMapper 接口，UserMapper.xml 配置内容为 public class User { private int id; private String name; priva
Mybatis-ResultMap结果集映射
weixin_45445291的博客
04-06 945
Mybatis-ResultMap结果集映射 解决属性名和字段名不一致的问题 测试实体类属性名和字段名不一致的情况 字段名：id、name、password 实体类： private int id; private String name; private String pwd; 测试类： @Test public void testGetUserById() { // 第一步: 获得sqlSession对象 SqlSession sqlSession = MybatisUtils.get
05-mybatis中的结果集映射（ResultMap）
yuhuofei的草屋
11-27 929
1. 准备工作 简单新建一个maven项目，引入mybatis的依赖，配置好基本的环境，包括数据库表的创建等等。 根据数据库表，新建实体类、mapper层接口以及mapper.xml文件，还有测试类。以下是本文创建的： 实体类——UserEntity.java package com.mybatis.entity; import lombok.Data; /** * @Description 实体类 * @ClassName User * @Author yuhuofei *
MyBatis：结果集映射（狂神）
dengfengling999的博客
06-09 321
db.properties： mybatis-config.xml: User11：与数据库中的字段名字不一样时： UserDao： 当与User11类的属性名，不一样时：方法一是起别名：方法二是：ResultMap结果集映射 UserMapper.xml： UserDAOTest：
第9章Mybatis映射篇之结果映射
05-11
通过这个元素，你可以定义一个结果集与Java对象之间的映射关系。 例如，假设我们有一个`User`类，它有`id`, `username`, `password`等字段，我们可能会有如下结果映射： ```xml ``` 这里，`id`, `result`...
Mybatis结果集自动映射的实例代码
08-31
在Mybatis中，结果集映射是用于将数据库查询的结果转换为Java对象的过程。自动映射功能使得这一过程更为便捷，无需显式地编写复杂的resultMap配置。在某些情况下，我们只需要简单地指定`resultType`属性，Mybatis就...
MySQL查询结果映射到map_mybatis结果集映射
weixin_42151036的博客
02-19 2932
结果集映射指的是，将数据库表的字段映射到Java实体的属性上。mybatis支持多种结果集映射方式：1、resultType2、resultType+起别名3、resultMap4、@ResultMap注解5、mapUnderscoreToCamelCase1 resultTyperesultType适用于数据库表字段和java实体类属性是一 一对应的，如：user表CREATETABLE`u...
MyBatis 结果映射详解
最新发布
FireFox1997
06-16 1361
在 MyBatis 中，结果映射是指将 SQL 查询结果集中的列值映射到 Java 对象的属性中。通过配置结果映射，可以轻松地将复杂的查询结果转换为便于操作的 Java 对象。MyBatis 的结果映射机制极大地方便了复杂查询结果与 Java 对象之间的转换。通过合理配置结果映射，可以轻松处理嵌套对象、集合等复杂结构，提高代码的可读性和可维护性。本文介绍了 MyBatis 中基本和复杂结果映射的配置方法，希望能帮助你更好地掌握 MyBatis 的使用。MyBatis 官方文档MyBatis 用户指南。
Mybatis 结果集映射
wangbo14511的博客
11-21 922
Mybatis 是支持普通的sql查询，存储过程和高级映射的持久层框架,Mybats消除了几乎所有的jdbc 代码和参数的手动设置以及结果集的检索,mybatis使用简单的xml或注解用于配置和原始映射,将接口和java的pojo 映射为数据库中的记录。 xml 配置 <mapper namespace="mapper.UserMapper"> <select id="getU...
mybatis结果集映射
weixin_44777314的博客
06-30 136
解决的问题：属性名和字段名不一致 Java中的实体类设计 public class User { private int id; //id private String name; //姓名 private String password; //密码和数据库不一样！数据库中的属性值为:pwd //构造 //set/get //toString() } 接口 //根据id查询用户 User selectUserById(int id); mapper映射
mybatis的结果集映射
weixin_45255645的博客
05-13 346
ResultMap(结果集映射) 什么是结果集映射 resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码中解放出来，并在一些情形下允许你进行一些 JDBC 不支持的操作。实际上，在为一些比如连接的复杂语句编写映射代码的时候，一份 resultMap 能够代替实现同等功能的数千行代码。ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。 结果集解决的问题是–>
Mybatis(六)-结果集映射
lizhao007
03-19 611
ResultMap 一个最简单的ResultMap     子元素被用来将一个resultset列映射到JavaBean的一个属性中。 元素和元素功能相同，不过它被用来映射到唯一标识属性。用来区分和比较对象。 在我们的语句中，我们使用了resultMap属性，而不是resultType。在使用
MyBatis中ResultMap结果集映射
你今天真好看呀
10-17 1097
用于解决属性名和字段名不一致的情况： package com.kuang.pojo; public class User { private int id; private String username; private String password; public User(int id, String username, String password) { ...
Mybatis resultMap结果集映射
APCSZDDXM的博客
02-20 339
首先我们这里说一个问题：当我们数据库中的字段名字和我们的实体类属性名不一致的时候能够查出结果吗？ 我们来看看，首先我们有一个实体类和一个数据库 package pojo; import org.apache.ibatis.type.Alias; @Alias("User") public class User { private int id; private String name; private String pwd; public User() { }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值