mybatis一对一关系映射
mybatis选择题题库
mybatis选择题题库含解答共20道1. 问题:MyBatis是一种什么类型的持久层框架?- a. ORM框架- b. MVC框架- c. AOP框架- d. IoC容器答案:a. ORM框架2. 问题:在MyBatis中,#{param}和${param}的区别是什么?- a. #{param}用于设置预编译参数,${param}用于字符串替换- b. #{param}用于字符串替换,${param}用于设置预编译参数- c. 两者没有区别- d. #{param}和${param}不能同时使用答案:a. #{param}用于设置预编译参数,${param}用于字符串替换3. 问题:MyBatis中的动态SQL是通过哪个标签实现的?- a. \<if>- b. \<choose>- c. \<foreach>- d. \<sql>答案:b. \<choose>4. 问题:MyBatis中,一对一关联关系的映射是通过哪个元素实现的?- a. \<one-to-one>- b. \<resultMap>- c. \<association>- d. \<many-to-one>答案:c. \<association>5. 问题:MyBatis的缓存机制默认是开启的吗?- a. 是- b. 否答案:a. 是6. 问题:MyBatis中的批量插入操作通常使用哪个元素?- a. \<batch>- b. \<foreach>- c. \<insert>- d. \<update>答案:b. \<foreach>7. 问题:在MyBatis中,如果想要返回自增主键,可以使用哪个属性?- a. keyProperty- b. useGeneratedKeys- c. generatedKey- d. returnGeneratedKeys答案:b. useGeneratedKeys8. 问题:MyBatis中的逆向工程是通过哪个工具生成的?- a. MyBatis Generator- b. Hibernate Tools- c. Spring Roo- d. Apache Maven答案:a. MyBatis Generator9. 问题:MyBatis中的拦截器是通过哪个接口实现的?- a. Interceptor- b. MapperInterceptor- c. MyBatisInterceptor- d. Plugin答案:a. Interceptor10. 问题:MyBatis中的动态数据源切换是通过哪个技术实现的?- a. AOP- b. 注解- c. ThreadLocal- d. 注入答案:c. ThreadLocal11. 问题:在MyBatis中,如果需要返回多个查询结果集,可以使用哪个元素?- a. \<select>- b. \<resultMap>- c. \<association>- d. \<resultSets>答案:d. \<resultSets>12. 问题:MyBatis中的懒加载是通过什么机制实现的?- a. AOP- b. 代理模式- c. 工厂模式- d. 观察者模式答案:b. 代理模式13. 问题:在MyBatis中,#{}, ${}, <![CDATA[]]> 的作用分别是什么?- a. #{}, ${}都是用于设置预编译参数,<![CDATA[]]>用于包裹动态SQL- b. #{}, ${}都是用于字符串替换,<![CDATA[]]>用于设置预编译参数- c. #{}, ${}都是用于字符串替换,<![CDATA[]]>用于包裹动态SQL- d. #{}, ${}都是用于设置预编译参数,<![CDATA[]]>用于字符串替换答案:a. #{}, ${}都是用于设置预编译参数,<![CDATA[]]>用于包裹动态SQL14. 问题:在MyBatis中,如果使用注解方式配置SQL语句,可以使用哪个注解?- a. @Query- b. @Sql- c. @Statement- d. @Select答案:d. @Select15. 问题:MyBatis的架构中,SqlSession的作用是什么?- a. 用于执行SQL语句- b. 用于映射Java对象和数据库记录- c. 用于管理数据库连接- d. 用于配置数据源答案:a. 用于执行SQL语句16. 问题:在MyBatis中,#{}和${}的主要区别是什么?- a. #{}用于预处理参数,${}用于直接替换字符串- b. #{}用于直接替换字符串,${}用于预处理参数- c. #{}用于动态SQL,${}用于设置预处理参数- d. #{}和${}在MyBatis中没有区别答案:a. #{}用于预处理参数,${}用于直接替换字符串17. 问题:MyBatis的二级缓存是默认开启的吗?- a. 是- b. 否答案:b. 否18. 问题:在MyBatis中,如何配置全局的参数映射器(TypeHandler)?- a. 在全局配置文件中配置- b. 在Mapper接口中配置- c. 在Mapper XML 文件中配置- d. 在数据库连接配置中配置答案:a. 在全局配置文件中配置19. 问题:在MyBatis中,#{param}和${param}的作用范围是什么?- a. #{param}只能用于设置预编译参数,${param}只能用于字符串替换- b. #{param}和${param}在MyBatis中没有区别- c. #{param}和${param}都可以用于设置预编译参数和字符串替换- d. #{param}只能用于字符串替换,${param}只能用于设置预编译参数答案:c. #{param}和${param}都可以用于设置预编译参数和字符串替换20. 问题:在MyBatis中,如何配置Mapper接口的方法参数映射?- a. 在Mapper接口方法上使用@Param注解- b. 在Mapper XML 文件中使用\<parameter>元素- c. 在全局配置文件中使用\<parameterMap>元素- d. 在Mapper接口方法上直接使用参数名答案:a. 在Mapper接口方法上使用@Param注解。
07Mybatis的多表查询1----1对多和多对1---@Results注解用法总结
07Mybatis的多表查询1----1对多和多对1---@Results注解⽤法总结1.表与表之间的关系及其举例表之间的关系有4种:⼀对多、多对⼀、⼀对⼀、多对多。
举例: (1)⽤户和订单就是⼀对多 ⼀个⽤户可以下多个订单 (2)订单和⽤户就是多对⼀ 多个订单属于同⼀个⽤户 (3)⼈和⾝份证号就是⼀对⼀ ⼀个⼈只能有⼀个⾝份证号 ⼀个⾝份证号只能属于⼀个⼈ (4)⽼师和学⽣之间就是多对多 ⼀个学⽣可以被多个⽼师教过 ⼀个⽼师可以交多个学⽣2.mybatis中的多表查询⽰例:⽤户和账户 ⼀个⽤户可以有多个账户 ⼀个账户只能属于⼀个⽤户(多个账户也可以属于同⼀个⽤户)步骤: 1、建⽴两张表:⽤户表,账户表 让⽤户表和账户表之间具备⼀对多的关系:需要使⽤外键在账户表中添加 2、建⽴两个实体类:⽤户实体类和账户实体类 让⽤户和账户的实体类能体现出来⼀对多的关系 3、建⽴两个配置⽂件 ⽤户的配置⽂件 账户的配置⽂件 4、实现配置: 当我们查询⽤户时,可以同时得到⽤户下所包含的账户信息 当我们查询账户时,可以同时得到账户的所属⽤户信息3.@Results注解⽤法总结:MyBatis中使⽤@Results注解来映射查询结果集到实体类属性。
(1)@Results的基本⽤法。
当数据库字段名与实体类对应的属性名不⼀致时,可以使⽤@Results映射来将其对应起来。
column为数据库字段名,porperty为实体类属性名,jdbcType为数据库字段数据类型,id为是否为主键。
@Select({"select id, name, class_id from my_student"})@Results({@Result(column="id", property="id", jdbcType=JdbcType.INTEGER, id=true),@Result(column="name", property="name", jdbcType=JdbcType.VARCHAR),@Result(column="class_id", property="classId", jdbcType=JdbcType.INTEGER)})List<Student> selectAll();如上所⽰的数据库字段名class_id与实体类属性名classId,就通过这种⽅式建⽴了映射关系。
mybatis中association用法 -回复
mybatis中association用法-回复Mybatis 中的association 用法详解在Mybatis 中,association 是一种用于处理复杂对象关联关系的属性映射方式。
它可以在结果映射中将多个关联的数据查询结果映射到一个对象上,从而避免了繁琐的手动数据组装,使得开发者能够更加专注于业务逻辑的处理。
本文将深入探讨Mybatis 中association 的用法,包括其原理、配置和常见应用场景等方面,希望能够对读者有所帮助。
一、association 的原理介绍1.1 概念解析在Mybatis 中,association 是一种属性映射关系,它用于处理一对一或多对一的复杂对象关联关系。
当查询结果中包含多个表,且这些表之间存在关联关系时,association 可以帮助我们将这些关联关系的数据映射到一个对象上,使得查询结果更加直观、易于使用。
1.2 工作原理在Mybatis 中,association 通常与select 一起使用,通过嵌套查询来获取关联表的数据。
当Mybatis 执行association 映射时,它会在查询主表数据之后,对关联表进行嵌套查询,并将嵌套查询的结果映射到主表对象的属性中。
这样,我们就可以通过主表对象直接访问关联表对象的数据,而不需要手动进行关联关系的组装。
二、association 的配置方式2.1 resultMap 方式配置association在Mybatis 中,我们可以通过resultMap 来配置association 的映射关系。
下面是一个示例:xml<resultMap id="UserResultMap" type="User"><id property="id" column="id"/><result property="name" column="name"/><association property="role" javaType="Role" resultMap="RoleResultMap"/></resultMap>在这个示例中,我们定义了一个UserResultMap,它包含了对User 对象的id、name 属性的映射配置,以及对关联对象Role 的映射配置。
【MyBatis系列3】最全MyBatis中XML映射文件(Mapper)标签分析及示例
【MyBatis系列3】最全MyBatis中XML映射⽂件(Mapper)标签分析及⽰例前⾔MyBatis的强⼤之处就在于它的映射器⽂件,⽽这也正是MyBatis的魔⼒所在,对于任何MyBatis的使⽤者来说,MyBatis的映射⽂件是必须要掌握的。
Mapper⽂件标签Mapper中⼀个提供了9个顶层标签,除了1个已经过期的我们不需要去了解,另外8个都是必须要掌握的,只要熟练掌握了标签的使⽤,使⽤MyBatis才能如鱼得⽔。
接下来我们就⼀个个来分析⼀下这些标签的使⽤。
<cache> – 该命名空间的缓存配置。
<cache-ref> – 引⽤其它命名空间的缓存配置。
<resultMap> – 描述如何从数据库结果集中加载对象,是最复杂也是最强⼤的元素。
<parameterMap> – ⽼式风格的参数映射。
此元素已被废弃,并可能在将来被移除!请使⽤⾏内参数映射。
⽂档中不会介绍此元素。
<sql> – 可被其它语句引⽤的可重⽤语句块。
<insert> – 映射插⼊语句。
<update> – 映射更新语句。
<delete> – 映射删除语句。
<select> – 映射查询语句。
selectselect⽤来映射查询语句,是我们使⽤最多的⼀种标签,也是最复杂的⼀种标签。
⽐如下⾯就是⼀个简单的select标签的使⽤<select id="listUserByUserName" parameterType="String" resultType="lwUser">select user_id,user_name from lw_user where user_name=#{userName}</select>select标签内,提供了⼀些⼆级标签,下⾯就列举出了全部的⼆级标签:<selectid="selectPerson"parameterType="int"parameterMap="deprecated"resultType="hashmap"resultMap="personResultMap"flushCache="false"useCache="true"timeout="10000"fetchSize="256"statementType="PREPARED"resultSetType="FORWARD_ONLY"databaseId="mysql"resultOrdered="false"resultSets="xxx,xxx"lang=""></select>id必选标签。
mysql 当个表中两个字段的映射关系
MySQL是一个开源的关系型数据库管理系统,被广泛应用于Web应用程序的开发中。
在MySQL中,数据以表的形式进行存储,而字段则用于表示表中的数据项。
在一个表中,不同字段之间可能存在着映射关系,而本文将着重探讨在MySQL中如何处理单个表中两个字段的映射关系。
一、字段映射关系的定义和概念1. 字段映射关系的定义在数据库中,字段映射关系是指表中两个字段之间的相互关联和对应关系。
这种关系可以是一对一、一对多、多对一或多对多的关系,用来描述数据之间的关系和通联。
2. 字段映射关系的概念在MySQL的数据库设计中,字段映射关系是非常重要的概念。
通过字段映射关系,可以帮助我们更好地组织和管理数据库中的数据,实现数据的高效访问和查询。
二、一对一映射关系在MySQL中,一对一映射关系指的是一个表中的两个字段之间存在着唯一的对应关系。
这种关系通常用于描述两个实体之间的严格对应关系,例如唯一识别信息和尊称之间的关系。
三、一对多映射关系与一对一映射关系不同,一对多映射关系指的是一个表中的一个字段可以对应多个另一个表中的字段。
这种关系常用于描述父子关系或主从关系,例如一个用户可以有多个订单的关系。
四、多对一映射关系多对一映射关系与一对多映射关系相反,它指的是一个表中的多个字段可以对应另一个表中的一个字段。
这种关系在数据库设计中也是比较常见的,例如多个订单对应于同一个用户的关系。
五、多对多映射关系除了上述三种基本的映射关系外,还存在着一种更为复杂的映射关系,即多对多映射关系。
在这种关系中,一个表中的多个字段可以对应另一个表中的多个字段,常用于描述复杂的多对多关系,例如学生和课程之间的关系。
六、个人观点和理解在实际的数据库设计和应用中,合理地处理好字段映射关系对于数据库的性能和稳定性至关重要。
通过合理的映射关系设计,可以提高数据库的查询效率,减少数据冗余,同时也更好地保持数据的一致性和完整性。
总结通过对MySQL中单个表中两个字段的映射关系进行探讨,我们可以更深入地理解数据库设计中的关键概念,以及如何合理地处理和应用这些映射关系。
mybatis 映射原理
mybatis 映射原理
Mybatis映射原理指的是Mybatis框架是如何将数据库中的数据映射到Java对象中的。
这个过程是Mybatis框架的核心部分,也是使用Mybatis框架的开发者需要理解的重要知识点。
在Mybatis框架中,映射关系是通过XML文件来定义的,这个XML文件中包含了数据库表结构和Java对象之间的映射关系。
Mybatis框架会根据这个XML文件来生成对应的Java代码,从而实现数据库表和Java对象之间的转换。
Mybatis映射原理的实现过程主要包括以下几个步骤:
1. 配置文件加载:Mybatis框架会通过读取配置文件来初始化数据库连接等相关信息。
2. SQL解析:Mybatis框架会将SQL语句解析成为可执行的Java 代码。
3. 参数绑定:Mybatis框架会将Java对象和SQL语句中的参数进行绑定,并生成可以执行的SQL语句。
4. SQL执行:Mybatis框架会将生成的SQL语句发送给数据库,并执行对应的操作。
5. 结果映射:Mybatis框架会将查询结果转换成为Java对象,并返回给调用方。
Mybatis框架的映射原理非常灵活,可以根据实际的业务需求进行定制化开发。
同时,Mybatis框架也提供了丰富的API和插件机制,方便开发者对框架进行二次开发和扩展。
Mybatis中实体类属性和数据列之间映射的四种办法
Mybatis中实体类属性和数据列之间映射的四种办法Mybatis不像Hibernate中那么⾃动化,通过@Column注解或者直接使⽤实体类的属性名作为数据列名,⽽是需要⾃⼰指定实体类属性和数据表中列名之间的映射关系,这⼀点让⽤惯了Hibernate的⼈很不习惯,所幸经过探索找到了建⽴映射关系的三种办法,其中总也有⽐较简单的。
⾸先先定义⼀个实体类,如下:public class User implements Serializable {private Integer userId;private String userName;......}1. 通过XML映射⽂件中的resultMap这种⽅式是最常见的,类似如下:<mapper namespace="erMapper"><resultMap type="er" id="userResultMap"><!-- ⽤id属性来映射主键字段 --><id property="id" column="user_id"/><!-- ⽤result属性来映射⾮主键字段 --><result property="userName" column="user_name"/></resultMap></mapper>通过⾥⾯的id标签和result标签来建⽴映射关系,由property和column分别指定实体类属性和数据表的列名。
2. 通过注解@Results和@Result这两个注解是与XML⽂件中的标签相对应的:@Results对应resultMap@Result对应result这两个注解是应⽤在⽅法的级别上的,也就是在mapper⽅法上,如下:@Select("select * from t_user where user_name = #{userName}")@Results(@Result(property = "userId", column = "user_id"),@Result(property = "userName", column = "user_name"))User getUserByName(@Param("userName") String userName);缺点:由于注解是针对⽅法的,对于Mapper中的每个操作数据库的⽅法都必须有相同的注解完成映射关系的建⽴,导致很多的配置是重复的;如果要避免配置重复的问题,可以采⽤在XML配置⽂件中配置这个resultMap,然后再@Result中通过id属性引⽤这个resultMap,但是这样感觉很⿇烦(由于使⽤了两种配置⽅式),不如直接使⽤基于XML的resultMap配置⽅式;3. 通过属性配置完成映射使⽤者最陌⽣的是通过配置属性来完成映射,Mybatis给我们提供了⼀种映射⽅式,如果属性的命名是遵从驼峰命名法的,数据列名遵从下划线命名,那么可以使⽤这种⽅式,类似如下:userName对应user_name;userId对应user_id;配置代码如下:SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();Configuration configuration = new Configuration();configuration.setMapUnderscoreToCamelCase(true);sqlSessionFactoryBean.setConfiguration(configuration);4. 通过使⽤在SQL语句中定义别名完成映射这种⽅式最直接,直接在SQL语句中建⽴别名来完成映射,如下:@Select("select user_name as userName, user_id as userId from t_user where user_name = #{userName}")User getUserByName(@Param("userName") String userName);Restful 接⼝调⽤Json接收相关问题1、背景:在项⽬上使⽤SpringBoot为框架,调⽤第三⽅接⼝时,返回的参数类型,不符合标准的命名规则,需要进⾏处理,接受数据2、现象:调⽤第三⽅接⼝返回数据格式为⽅式均为⼩写,如下:{"rowid": "111111","created": "2018-12-27 16:15:25","createdby": "1111111","lastupd": "2018-12-27 08:25:48","lastupdby": "111111","modificationnum": 1}返回Json参数字段均为⼩写,在接收时,需要按照标准的命名规则进⾏映射3、解决办法:创建接收数据对象,⽣成Get\Set⽅法:,在Set⽅法上,加上@JsonProperty注解,@JsonProperty 此注解⽤于属性上,作⽤是把该属性的名称序列化为另外⼀个名称,如把rowId属性序列化为rowid,@JsonProperty("rowid")。
Mybatis中collection和association的使用区别详解
Mybatis中collection和association的使⽤区别详解最近⼀直把collection和association弄混,所以为了增强⾃⼰的记忆,就撸⼀个关系出来算是总结罢了1. 关联-association2. 集合-collection⽐如同时有User.java和Card.java两个类User.java如下:public class User{private Card card_one;private List<Card> card_many;}在映射card_one属性时⽤association标签, 映射card_many时⽤collection标签.所以association是⽤于⼀对⼀和多对⼀,⽽collection是⽤于⼀对多的关系下⾯就⽤⼀些例⼦解释下吧association-⼀对⼀⼈和⾝份证的关系下⾯是pojopublic class Card implements Serializable{private Integer id;private String code;//省略set和get⽅法.}public class Person implements Serializable{private Integer id;private String name;private String sex;private Integer age;//⼈和⾝份证是⼀对⼀的关系private Card card;//省略set/get⽅法.}下⾯是mapper和实现的接⼝package com.glj.mapper;import com.glj.poji.Card;public interface CardMapper {Card selectCardById(Integer id);}<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapperPUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.glj.mapper.CardMapper"><select id="selectCardById" parameterType="int" resultType="com.glj.poji.Card">select * from tb_card where id = #{id}</select></mapper>package com.glj.mapper;import com.glj.poji.Person;public interface PersonMapper {Person selectPersonById(Integer id);}<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapperPUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.glj.mapper.PersonMapper"><resultMap type="com.glj.poji.Person" id="personMapper"><id property="id" column="id"/><result property="name" column="name"/><result property="sex" column="sex"/><result property="age" column="age"/><association property="card" column="card_id"select="com.glj.mapper.CardMapper.selectCardById"javaType="com.glj.poji.Card"></association></resultMap><select id="selectPersonById" parameterType="int" resultMap="personMapper"> select * from tb_person where id = #{id}</select></mapper>PersonMapper.xml 还使⽤association的分步查询。
mybatis语法和介绍详细
mybatis语法和介绍详细MyBatis是一个开源的持久层框架,它简化了数据库访问的操作。
它与传统的ORM框架相比,更加灵活和强大,能够提供更高效的数据库访问性能。
本文将对MyBatis的语法和特点进行详细介绍。
一、MyBatis语法1. SQL映射文件:MyBatis使用XML文件来配置SQL语句和映射关系。
SQL映射文件中包含了SQL语句以及与数据库表字段的映射关系。
2. SQL语句:MyBatis支持标准的SQL语句,可以直接在SQL映射文件中编写SQL语句。
可以使用动态SQL来实现灵活的条件查询和动态更新。
3. 参数映射:MyBatis支持将Java对象与SQL语句中的参数进行映射。
可以使用#{param}语法来引用参数,也可以使用${param}语法来引用参数。
4. 结果映射:MyBatis支持将SQL查询结果映射到Java对象或集合中。
可以通过配置来实现一对一、一对多、多对一、多对多等复杂的关联关系。
6. 缓存:MyBatis支持缓存,可以将查询结果缓存到内存中,提高查询性能。
可以使用一级缓存和二级缓存来实现不同级别的缓存。
7. 插件:MyBatis支持插件,可以通过插件来扩展MyBatis的功能。
可以自定义插件来实现自定义的功能,如日志记录、性能监控等。
二、MyBatis特点1. 简单易用:MyBatis的语法简单明了,易于上手。
通过XML配置即可完成数据库的访问操作,无需编写繁琐的SQL语句。
2. 灵活性高:MyBatis支持动态SQL,可以根据不同的条件生成不同的SQL语句。
可以灵活地处理复杂的查询需求。
3. 性能优越:MyBatis使用了预编译的SQL语句和缓存机制,可以提高查询性能。
通过合理地配置缓存可以减少数据库的访问次数,进一步提升性能。
4. 易于集成:MyBatis可以与各种主流的Java框架集成,如Spring、Spring Boot等。
可以通过注解方式来简化配置,提高开发效率。
mybatis映射规则
mybatis映射规则MyBatis映射规则提供了一种将数据库表映射到Java对象的方法,简化了在Java代码中操作数据库的过程。
下面将介绍一些常见的MyBatis映射规则。
1. 表名映射:MyBatis默认将驼峰式命名的Java对象映射到下划线分隔的数据库表名。
例如,Java对象名为UserInfo,对应的数据库表名为user_info。
2. 字段映射:MyBatis通过在Java对象的属性上使用注解或XML配置将字段与数据库表中的列进行映射。
常用的映射注解有@Id、@Column、@Transient等。
3. 主键映射:使用注解@Id或XML配置指定Java对象的属性作为主键。
MyBatis支持自增和非自增的主键,并可自定义生成主键的策略。
4. 关联关系映射:MyBatis支持一对一、一对多和多对多等关联关系的映射。
通过使用@One、@Many和@ManyToMany注解或XML配置,可以将关联关系映射到数据库表中。
5. 延迟加载与一次性加载:MyBatis支持延迟加载,即只有在实际使用关联对象时才从数据库加载数据。
一次性加载是指在查询主对象的同时,将关联对象一起加载。
6. 动态SQL:MyBatis提供了强大的动态SQL功能,可以根据不同的条件动态生成SQL语句。
通过使用<if>、<choose>、<when>和<otherwise>等标签,可以实现灵活的查询条件拼接。
总之,MyBatis映射规则允许开发者通过简单的配置和注解,实现Java对象与数据库表之间的映射关系,提高了数据库操作的效率和开发效率。
熟悉并合理运用这些映射规则,能够更好地利用MyBatis进行数据库操作。
mybatis association 用法
mybatis association 用法Mybatis关联查询的用法一、关联查询1.一对一关联查询mybatis中一对一关联查询指的是,是查询两个表之间的一对一关系。
Mybatis支持两种方式的一对一关联查询,一种是嵌套查询,另一种是嵌套结果。
1.1 嵌套查询嵌套查询是把一张表的查询得到的结果作为另一张表的查询条件,从而实现一对一关联查询的技术。
在Mybatis中实现嵌套查询,需要使用Mybatis关联标签<association>。
实例:查询订单和订单详情首先,我们创建两张表:订单表order表和订单详情表order_item。
在Mybatis中的Mapper文件中,我们可以使用<association>标签实现一对一关联查询,如下所示:<resultMap id='OrderMap' type='sys.Order'>t<id property='id' column='id'/>t<result property='orderNo' column='order_no'/>t<result property='totalMoney' column='total_money'/>t<association property='orderItem'javaType='sys.OrderItem'>tt<id property='id' column='id'/>tt<result property='orderId' column='order_id'/>tt<result property='prodId' column='prod_id'/>tt<result property='prodPrice' column='prod_price'/>tt<result property='prodNum' column='prod_num'/>t</association></resultMap>1.2 嵌套结果嵌套结果是把一种表的所有记录都查询出来,然后把另一种表的记录按照一定的方式封装到查询出的记录中,从而实现一对一关联查询的技术。
MyBatis一对一映射初识教程
MyBatis⼀对⼀映射初识教程MyBatis是⼀个⽀持普通SQL查询,存储过程和⾼级映射的优秀持久层框架。
MyBatis消除了⼏乎所有的JDBC代码和参数的⼿⼯设置以及对结果集的检索封装。
MyBatis可以使⽤简单的XML或注解⽤于配置和原始映射,将接⼝和Java的POJO(Plain Old Java Objects,普通的Java对象)映射成数据库中的记录。
⼀对⼀映射在⽣活中,⼀对⼀的例⼦还是有的,⽐如啦,学⽣和⾝份证哦,或者在我国,实⾏的是⼀夫⼀妻制度哦。
那么我们以学⽣和⾝份证每个学⽣只有⼀张⾝份证,⽽每张⾝份证的主⼈当然只有⼀个啦。
数据库脚本:-- 删除数据库drop database if exists mybaits;-- 创建数据库create database if not exists mybatis default character set utf8;-- 选择数据库use mybatis;-- 删除数据表drop table if exists student ;drop table if exists card;-- 创建数据表create table card(cid int(255),num varchar(18),constraint pk_cid primary key (cid));create table student(sid int(255),sname varchar(32),scid int(255),constraint pk_sid primary key (sid),constraint fk_scid foreign key (scid) references card(cid));-- 增加测试数据insert into card (cid,num) values(1,'123456789012345678');insert into student (sid,sname,scid) values(1,'哈哈',1);新建⼀个one2one.Card.java类package one2one;import java.io.Serializable;/*** ⾝份证* @author Administrator**/@SuppressWarnings("serial")public class Card implements Serializable{private Integer cid;private String num;public Integer getCid() {return cid;}public void setCid(Integer cid) {this.cid = cid;}public String getNum() {return num;}public void setNum(String num) {this.num = num;}}新建one2one.Student.java类package one2one;import java.io.Serializable;/*** 学⽣* @author Administrator**/@SuppressWarnings("serial")public class Student implements Serializable{private Integer sid;private String sname;private Card card;public Integer getSid() {return sid;}public void setSid(Integer sid) {this.sid = sid;}public String getSname() {return sname;}public void setSname(String sname) {this.sname = sname;}public Card getCard() {return card;}public void setCard(Card card) {this.card = card;}}在one2one包下新建CardMapper.xml⽂件<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="cardNameSpace"><resultMap type="one2one.Card" id="cardMap"><id column="cid" property="cid"/><result column="num" property="num"/></resultMap></mapper>同理,在one2one包下新建StudentMapper.xml⽂件<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="studentNameSpace"><resultMap type="one2one.Student" id="studentMap"><id column="sid" property="sid"/><result column="sname" property="sname"/><!-- 关联字段不要写 --></resultMap><select id="findById" parameterType="integer" resultMap="studentMap">select s.sid,s.sname,c.cid,c.numfrom student s,card cwhere s.scid = c.cid and s.sid = #{sid}</select></mapper>在src下新建⼀个mybatis.cfg.xml⽂件,并包含StudentMapper.xml和CardMapper.xml⽂件<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE configuration PUBLIC "-////DTD Config 3.0//EN""/dtd/mybatis-3-config.dtd"><configuration><!-- 设置⼀个默认的环境信息 --><environments default="mysql_developer"><!-- 连接MySQL环境信息 --><environment id="mysql_developer"><!-- MyBatis使⽤jdbc事务管理器 --><transactionManager type="jdbc"/><!-- MyBatis使⽤连接池⽅式来获取连接对象 --><dataSource type="pooled"><!-- 配置与数据库交互的4个必要属性 --><property name="driver" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis"/><property name="username" value="root"/><property name="password" value="mysqladmin"/></dataSource></environment><!-- 连接Oracle环境信息 --><environment id="oracle_developer"><!-- MyBatis使⽤jdbc事务管理器 --><transactionManager type="jdbc"/><!-- MyBatis使⽤连接池⽅式来获取连接对象 --><dataSource type="pooled"><!-- 配置与数据库交互的4个必要属性 --><property name="driver" value="oracle.jdbc.driver.OracleDriver"/><property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:orcl"/><property name="username" value="scott"/><property name="password" value="tiger"/></dataSource></environment></environments><!-- 加载映射⽂件 --><mappers><mapper resource="one2one/CardMapper.xml"/><mapper resource="one2one/StudentMapper.xml"/></mappers></configuration>在util包下新建⼀个⼯具类MyBatisUtil.java类package util;import java.io.IOException;import java.io.Reader;import java.sql.Connection;import org.apache.ibatis.io.Resources;import org.apache.ibatis.session.SqlSession;import org.apache.ibatis.session.SqlSessionFactory;import org.apache.ibatis.session.SqlSessionFactoryBuilder;public class MyBatisUtil {private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<SqlSession>(); public static SqlSessionFactory sqlSessionFactory ;//私有化构造⽅法private MyBatisUtil(){}//加载位于src/Mybatis.cfg.xmlstatic{try {Reader reader = Resources.getResourceAsReader("mybatis.cfg.xml"); sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);} catch (IOException e) {e.printStackTrace();}}/*** 获取SQLSession* @return*/public static SqlSession getSqlSession(){//从当前线程中获取SqlSession对象SqlSession sqlSession = threadLocal.get();if(sqlSession == null){if(sqlSessionFactory != null){sqlSession = sqlSessionFactory.openSession();//讲sqlSession与当前线程绑定在⼀起threadLocal.set(sqlSession);}}return sqlSession;}/*** 关闭SqlSession 并与当前线程分开*/public static void closeSqlSession(){//从当前线程中获取SqlSession对象SqlSession sqlSession = threadLocal.get();//如果SqlSession对象⾮空if(sqlSession != null){//关闭SqlSession对象sqlSession.close();//分离当前线程与SqlSession的关系threadLocal.remove();}}//测试public static void main(String[] args) {SqlSession sqlSession = MyBatisUtil.getSqlSession();Connection conn= sqlSession.getConnection();System.out.println(conn != null ?"连接成功":"连接失败");}}新建持久层类StuentCardDAO.java类package one2one;import org.apache.ibatis.session.SqlSession;import org.junit.Test;import util.MyBatisUtil;/*** 持久层* @author Administrator**/public class StudentCardDAO {/*** 查询1号学⽣的信息与⾝份证信息* @param id* @return* @throws Exception*/public Student findById(Integer id) throws Exception{SqlSession sqlSession = null;try {sqlSession = MyBatisUtil.getSqlSession();return sqlSession.selectOne("studentNameSpace.findById", id);} catch (Exception e) {e.printStackTrace();throw e;}finally{MyBatisUtil.closeSqlSession();}}//测试查询1号学⽣的信息与⾝份证信息@Testpublic void testFindById() throws Exception{StudentCardDAO dao = new StudentCardDAO();Student student = dao.findById(1);System.out.println(student.getSid()+":"+student.getSname() }}这时我们只能查询1号学⽣的姓名,但是我们不能去查询它的⾝份号号,因为此时的card属性的值为null,从StudentMapper.xml中可以看出<select id="findById" parameterType="integer" resultMap="studentMap">MyBatis在解析这⼀句的时候只能将查询的数据封装到sid,sname中,所以怎么办?在StudentMapper.xml中的<resultMap type="one2one.Card" id="cardMap"><id column="cid" property="cid"/><result column="num" property="num"/></resultMap>增加<!--引⼊CardMapper.xml⽂件中的映射信息property表⽰Student的关联属性--><association property="card" resultMap="cardNameSpace.cardMap"/>那么此时的StudentMapper.xml的完整内容如下:<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="studentNameSpace"><resultMap type="one2one.Student" id="studentMap"><id column="sid" property="sid"/><result column="sname" property="sname"/><!--引⼊CardMapper.xml⽂件中的映射信息property表⽰Student的关联属性--><association property="card" resultMap="cardNameSpace.cardMap"/></resultMap><select id="findById" parameterType="integer" resultMap="studentMap">select s.sid,s.sname,c.cid,c.numfrom student s,card cwhere s.scid = c.cid and s.sid = #{sid}</select></mapper>现在可以测试学⽣的⾝份证号码了将持久层类StuentCardDAO.java类的测试⽅法改为//测试查询1号学⽣的信息与⾝份证信息@Testpublic void testFindById() throws Exception{StudentCardDAO dao = new StudentCardDAO();Student student = dao.findById(1);System.out.println(student.getSid()+":"+student.getSname()+":"+student.getCard().getNum());}同理在StudentDAO.java类中增加查询“哈哈”学⽣的信息与⾝份证信息的⽅法/*** 查询“哈哈”学⽣的信息与⾝份证信息* @param name* @return* @throws Exception*/public Student findByName(String name) throws Exception{SqlSession sqlSession = null;try {sqlSession = MyBatisUtil.getSqlSession();return sqlSession.selectOne("studentNameSpace.findByName", name);} catch (Exception e) {e.printStackTrace();throw e;}finally{MyBatisUtil.closeSqlSession();}}并增加测试⽅法哦//测试查询“哈哈”学⽣的信息与⾝份证信息@Testpublic void testFindByName() throws Exception{StudentCardDAO dao = new StudentCardDAO();Student student = dao.findByName("哈哈");System.out.println(student.getSid()+":"+student.getSname()+":"+student.getCard().getNum());}当然如果你现在就测试,你会死的很惨,因为你没有在StudentMapper.xml⽂件中配置<select>哦,所以在StudentMapper.xml ⽂件中增加<select>配置信息<select id="findByName" parameterType="string" resultMap="studentMap">select s.sid,s.sname,c.cid,c.numfrom student s,card cwhere s.scid = c.cid and s.sname = #{sname}</select>这样就可以测试成功了。
Mybatis实体类和数据库表之间的映射关系:
Mybatis实体类和数据库表之间的映射关系:关于Mybatis实体类和数据库表之间的映射关系:1、使⽤原⽣⽅式,即不使⽤⼯具和插件的⽅法: 例如:最简单的springboot的demo; 1.1、实体类的类名及属性要和数据库表名和字段名遵循下划线转驼峰命名格式; 1.2、因为Mapper接⼝没有实现类,所以需要⽤代理⽅式动态⽣成其对应的实现类,实现的⽅式有两种: (1)在Mapper接⼝上⽤@Mapper注解,⽣成该类的实现类,@Mapper的包是 org.apache.ibatis.annotations.Mapper; (2)如果有很多Mapper接⼝,在接⼝上⽤注解太⿇烦,就需要在springBoot的启动类上⽤@MapperScan注解,括号中是包名路径,表⽰⽣成该包下所有接⼝的实现类;1import org.mybatis.spring.annotation.MapperScan;2import org.springframework.boot.SpringApplication;3import org.springframework.boot.autoconfigure.SpringBootApplication;4//import tk.mybatis.spring.annotation.MapperScan; //⼀个是org,⼀个是tk56/**7 * @author TT8*/9 @SpringBootApplication10 @MapperScan("com.thl.mapper") //扫描mapper包下所有的mapper接⼝,如果还有其他包也需要⽣成实现类,括号中可以⽤数组⽅式配置多个包路径11public class SpringBootTkMapperApplication {1213public static void main(String[] args) {14 SpringApplication.run(SpringBootTkMapperApplication.class, args);15 }1617 } 1.3、如果还有对应的*mapper.xml⽂件(⽤tk.mapper,单表的CRUD可以不⽤*mapper.xml),需要配置扫描resources下的mapper的xml⽂件;我是在application.properties⽂件中配置的; 1.4、如果没有⽤resultMap标签配置映射关系,⼊参⽤的是实体类,即⽤的resultType标签,则还需要配置下划线转驼峰的规则,不然字段映射不上。
springboot整合mybatis-plus基于注解实现一对一(一对多)查询功能
springboot整合mybatis-plus基于注解实现⼀对⼀(⼀对多)查询功能因为⽬前所⽤mybatis-plus版本为3.1.1,感觉是个半成品,所有在实体类上的注解只能⽀持单表,没有⼀对⼀和⼀对多关系映射,且该功能还在开发中,相信mybatis-plus开发团队在不久的将来应该会实现此功能。
由于本⼈开发习惯的原因,实在是太讨厌⼤量的xml充斥在整个项⽬中,尤其是表的mapper.xml,虽然有代码⽣成器可以⽣成,但是有些复杂的查询还是需要⼿写配置⽂件⾥的动态sql,这点⽐较反感(⾄于为什么反感,也是有多⽅⾯原因的)。
不过可能是⼤量的java开发⼈员已经被虐惯了,已经习惯各种配置⽂件,虽然有代码⽣成器,但是本⼈觉得,这种不是真正的路⼦,按理说开源出去的东西让别⼈⽤的越简单越爽越好,⽽不是还需要依赖⼤量的⼯具配合才能使⽤(这个观点仁者见仁智者见智吧)。
因为本⼈采⽤的是spring-boot进⾏开发,本⾝springboot就提倡采⽤不⽤配置⾃动配置的⽅式,所以真⼼希望mybatis(不是mybatis-plus)这点需要继续努⼒。
基于这点,采⽤了mybatis-plus⾥的已经实现好的⽅法来进⾏了取巧的操作,废话不多说,直接上代码。
数据库是mysql。
demo的思路是这样的:学⽣表(Student),学⽣班级表(StudentClass),在学⽣的实体类⾥通过班级Id和班级进⾏⼀对⼀关联,主要通过mapper接⼝来实现,基于@Results、@Result、@One(或@Many)、@ResultMap这⼏个mybatis⾥的注解加上mybatis-plus⾥的BaseMapper、QueryWrapper<ChannelEntity>结合起来实现,所以还得写⼀些代码。
如果mybatis-plus团队把关系映射⼀并实现注解到实体对象上就能省⼤量代码了,期待他们早⽇实现。
pom⽂件<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.1.4.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.lyb</groupId><artifactId>spring-mybatis-demo</artifactId><version>0.0.1-SNAPSHOT</version><packaging>jar</packaging><name>spring-mybatis-demo</name><description>Demo project for Spring Boot</description><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><java.version>1.8</java.version></properties><dependencies><!--<dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.0.0</version></dependency>--><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId><version>3.1.1</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.8</version><scope>provided</scope></dependency><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus</artifactId><version>3.1.1</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-generator</artifactId><version>3.1.1</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>可以看到数据库操作只需依赖mybatis-plus-boot-starterapplication.yml⽂件spring:datasource:url: jdbc:mysql://127.0.0.1:3306/demo?useUnicode=true&characterEncoding=utf8&serverTimezone=UTCusername: rootpassword: liuyabindriver-class-name: com.mysql.jdbc.Drivermybatis-plus:type-aliases-package: com.lyb.springmybatisdemo.entitytype-aliases-super-type: ng.ObjectStudent实体类代码,可以看到实体类上加上了mybatis-plus的注解,这⾥也加了@Data lombok的注解为了节省多敲代码:package com.lyb.springmybatisdemo.entity;import com.baomidou.mybatisplus.annotation.IdType;import com.baomidou.mybatisplus.annotation.TableField;import com.baomidou.mybatisplus.annotation.TableId;import com.baomidou.mybatisplus.annotation.TableName;import lombok.*;@Data@Builder@ToString@EqualsAndHashCode@NoArgsConstructor@AllArgsConstructor@TableName(value = "student")public class Student {@TableId(value = "Id",type = IdType.AUTO)private int id;@TableField(value = "SName",exist = true,select = true)private String name;@TableField(value = "Age")private int age;@TableField(value = "ClassId")private int classId;@TableField(exist = false)private StudentClass studentClass;}StudentClass类代码:package com.lyb.springmybatisdemo.entity;import com.baomidou.mybatisplus.annotation.IdType;import com.baomidou.mybatisplus.annotation.TableField;import com.baomidou.mybatisplus.annotation.TableId;import com.baomidou.mybatisplus.annotation.TableName;import lombok.*;@Data@Builder@ToString@EqualsAndHashCode@NoArgsConstructor@AllArgsConstructor@TableName(value = "stuClass")public class StudentClass {@TableId(value = "ClassId",type = IdType.AUTO)private int classId;@TableField(value = "ClassName")private String className;}具体的数据库结构就不放了,参照实体类上注解就很能轻松构建出来,因为就两个表。
mybatis的三种数据库映射实体类的方法
mybatis的三种数据库映射实体类的⽅法1.实体类中变量完全和数据库中的字段名对应例如:DB:user_id, 则实体类中成员变量也是user_id托管给mybatis,mybatis会把变量和字段名⼀⼀映射2.在mybatis-congfig.xml⾥配置settings<settings><setting name="mapUnderscoreToCamelCase" value="true"/></settings>加上这个配置后,mybatis帮我们把数据库字段按驼峰命名传给对应实体类字段db:user_id => 实体类userId这个配置要加在的最前⾯3.在Mapper的配置⽂件⾥配置映射关系(字段多后,不建议⽤)例如:我的Mapper配置⽂件是,TbUserMapper.xml,在select前加上resultMap<resultMap id="tb_user" type="com.besttest.mybatis.entity.TbUser"><id column="id" property="id"/><result column="user_id" property="userID"/><result column="user_name" property="userName"/></resultMap>其中:resultMap中 id="tb_user" 表⽰对应的表type="com.besttest.mybatis.entity.TbUser"表⽰对应的实体类id column="id" property="id" 第⼀个id表⽰主键,column="id" 表⽰表中id字段,property="id表⽰对应实体类的id变量result column="user_id" property="userID" result表⽰映射,column表的,property实体类的注意:使⽤这种⽅式,Mapper配置⽂件中,select的配置,resultType要改成resultMapresultType=实体类的相对路径,resultMap=配置项resultMap⾥的id的值上⾯的例⼦就是resultMap="tb_user"。
mybatis 中 association 使用方法
MyBatis 是一个优秀的持久层框架,它支持定制化SQL、存储过程以及高级映射。
在MyBatis 中,association 用于实现一对一(1:1)的关系映射。
以下是一个简单的例子,演示如何在MyBatis 中使用association:假设我们有两个实体类:User 和Profile,它们之间是一对一的关系。
User 类:javapublic class User {private int id;private String name;private Profile profile;// 省略getter 和setter 方法}Profile 类:javapublic class Profile {private int id;private String address;private User user;// 省略getter 和setter 方法}在MyBatis 的映射文件中,我们可以通过association 元素来实现一对一的关系映射:xml<resultMap id="userResult" type="User"><id property="id" column="user_id"/><result property="name" column="user_name"/> <association property="profile" javaType="Profile"><id property="id" column="profile_id"/><result property="address" column="profile_address"/></association></resultMap>在这个例子中,userResult 是User 类型的结果映射。
mybatis中字段与实体匹配规则
mybatis中字段与实体匹配规则MyBatis是一个持久层框架,可以将数据库表中的数据映射到Java对象上,并提供了丰富的SQL操作方法,使得开发者能够更简便地进行数据库操作。
在MyBatis中,字段与实体的匹配规则是很重要的,它影响着数据的映射、查询、更新等操作。
下面将详细介绍MyBatis中字段与实体的匹配规则。
1. 实体类的命名规范:在MyBatis中,实体类一般与数据库表进行一对一的映射。
为了方便理解和维护,实体类的命名应该与数据库表的命名保持一致。
一般情况下,实体类名采用驼峰命名法,而数据库表名采用下划线命名法。
例如,数据库表名为"user_info",则对应的实体类名为"UserInfo"。
2. 字段与属性的映射规则:MyBatis中的字段与实体类中的属性进行映射。
一般情况下,字段名采用下划线命名法,而属性名采用驼峰命名法。
例如,数据库表的字段名为"user_name",则对应的实体类的属性名为"userName"。
如果字段名与属性名不一致,可以通过在属性上使用@Results注解进行映射。
3. 数据类型的转换规则:MyBatis会根据实体类中属性的类型自动进行数据类型的转换。
MyBatis支持的数据类型包括基本数据类型、包装类、String、Date等。
在映射过程中,如果数据库表中的数据类型与实体类中属性的类型不匹配,MyBatis会自动进行类型转换。
4. 实体类中的关联关系:当数据库中存在表之间的关联关系时,实体类之间也应该有对应的关联关系。
MyBatis提供了@One和@Many注解来表示一对一和一对多的关系。
通过关联关系,可以在查询时级联查询相关联的实体类。
5. 配置文件中的映射规则:除了上述的映射规则之外,MyBatis还提供了配置文件mybatis-config.xml和映射文件Mapper.xml来进一步规定字段与实体的映射规则。
mybatis中association和collection的作用
mybatis中association和collection的作用在 MyBatis 中,association 和 collection 是用于处理关联关系和集合的两个关键概念。
1. association(关联):- 作用:用于表示一对一或一对多的关联关系。
它允许你通过一个对象访问与其关联的另一个对象或对象集合。
- 使用方法:在映射文件中使用 `<association>` 元素来定义关联。
你可以指定关联的类型(one-to-one 或 one-to-many)、关联的字段以及外键约束等。
- 示例:假设有一个`User` 表和一个`Address` 表,`User` 表有一个`address_id` 字段与 `Address` 表的 `id` 字段关联。
你可以使用 association 来定义这种关联关系。
2. collection(集合):- 作用:用于表示一对多的关联关系,即一个对象可以关联多个其他对象的集合。
- 使用方法:在映射文件中使用 `<collection>` 元素来定义集合。
你可以指定集合的类型(list 或 map)、关联的字段以及集合的元素等。
- 示例:假设有一个 `Order` 表和一个 `OrderItem` 表,一个订单可以有多个订单项。
你可以使用 collection 来定义这种一对多的关联关系。
通过使用 association 和 collection,MyBatis 可以在查询数据时自动处理关联关系和集合,使你能够方便地获取相关联的对象或对象集合,无需手动进行复杂的关联操作。
这有助于提高开发效率和代码的可维护性。
mybatis返回HashMap结果类型与映射
mybatis返回HashMap结果类型与映射Xhtml代码1. <!-- 返回HashMap结果类型-->2. <!-- 如果想返回JavaBean,只需将resultType设置为JavaBean的别名或全限定名 -->3. <!-- TypeAliasRegistry类初始化时注册了⼀些常⽤的别名,如果忘记了别名可以在这⾥⾯查看 -->4. <select id="selectBlogRetHashMap" parameterType="int" resultType="map">5. SELECT id AS "id", title AS "title", content AS "content" FROM Blog WHERE id = #{id}6. </select>测试代码:Java代码1. /**2. * 测试返回HashMap3. */4. @SuppressWarnings("unchecked")5. @Test6. public void testSelectBlogRetHashMap() {7. SqlSession session = sqlSessionFactory.openSession();8. HashMap<String,Object> blog = (HashMap<String,Object>) session.selectOne(9. "cn.enjoylife.BlogMapper.selectBlogRetHashMap", 15);10. session.close();11. System.out.println(blog.get("title"));12. }ibatis⾼级映射:表结构:Java代码1. create table BLOG2. (3. ID NUMBER(20),4. TITLE VARCHAR2(50),5. CONTENT VARCHAR2(4000),6. BLOG_AUTHOR_ID NUMBER(20)7. )8. create table AUTHOR9. (10. ID NUMBER(20),11. AUTHOR_NAME VARCHAR2(50)12. );13. create table POSTS14. (15. ID NUMBER(20),16. SUBJECT VARCHAR2(50),17. BODY VARCHAR2(4000),18. BLOG_ID NUMBER(20)19. )bean信息:Java代码1. package cn.enjoylife.domain;2. import java.util.List;3. public class Blog {4. private Integer id;5. private String title;6. private String content;7. private Author author;8.9. private List<Post> posts/*=new ArrayList<Post>()*/;10.11. public List<Post> getPosts() {12. return posts;13. }14. public void setPosts(List<Post> posts) {15. this.posts = posts;16. }17. public Integer getId() {18. return id;19. }20. public void setId(Integer id) {21. this.id = id;22. }23. public String getTitle() {24. return title;25. }26. public void setTitle(String title) {27. this.title = title;28. }29. public String getContent() {30. return content;31. }32. public void setContent(String content) {33. this.content = content;34. }35. public Author getAuthor() {36. return author;37. }38. public void setAuthor(Author author) {39. this.author = author;40. }41. @Override42. public String toString() {43. return "Blog [content=" + content + ", id=" + id + ", title=" + title44. + "]";45. }46. }Java代码1. package cn.enjoylife.domain;2. public class Author {3. private Integer id;4. private String name;5. public Integer getId() {6. return id;7. }8. public void setId(Integer id) {9. this.id = id;10. }11. public String getName() {12. return name;13. }14. public void setName(String name) {15. = name;16. }17. @Override18. public String toString() {19. // System.out.println("Author[id="+id+",name="+name+"]");20. return "Author[id="+id+",name="+name+"]";21. }22.23. }Java代码1. package cn.enjoylife.domain;2. public class Post {3. private Integer id;4. private String subject;5. private String postContent;6. public Integer getId() {7. return id;8. }9. public void setId(Integer id) {10. this.id = id;11. }12. public String getSubject() {13. return subject;14. }15. public void setSubject(String subject) {16. this.subject = subject;17. }18. public String getPostContent() {19. return postContent;20. }21. public void setPostContent(String postContent) {22. this.postContent = postContent;23. }24. @Override25. public String toString() {26. return "Post [postContent=" + postContent + ", id=" + id + ", subject=" + subject27. + "]";28. }29.30.31. }Blog.xmll配置:Xhtml代码1. <!-- ⾼级结果映射 -->2. <!--3. ⼀对⼀关联嵌套查询应⽤select属性4. 1)id="selectBlogAndRelatedAuthor" 中的 blog_author_id 对应到5. <association property="author" column="blog_author_id"/>中的column="blog_author_id"6. 2)我们执⾏selectBlogAndRelatedAuthor 1次之后,所产⽣的每条记录都要再进⾏⼀个查询来获取author信息(N),7. 这就是N+1问题,应该使⽤延迟加载的⽅式,否则这有可能产⽣致命的后果。
简述Mybatis关联映射有两种处理方式
简述Mybatis关联映射有两种处理方式
Mybatis关联映射有两种处理方式:
1. 嵌套查询
嵌套查询是指在查询一个对象时通过另一个查询语句来获取关联对象的信息。
首先查询主对象,然后通过主对象的id 属性作为参数查询关联对象,最后将查询结果设置到主对象中。
优点:可以大大简化数据结构,减少数据库冗余。
缺点:会产生大量查询语句,会影响系统性能。
2. 嵌套结果
嵌套结果是指在查询一个对象时通过关联查询语句来同时获取主对象和关联对象的信息,并将查询结果封装为一个对象。
优点:只需一次查询就可以获取主对象和关联对象的所有信息。
缺点:数据结构过于复杂,且查询速度较慢。
注:以上答案是人工智能生成,仅供参考。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
@select("select * from user where id=#{id}")
public User selectUser();
@selct("select * form user")
public List<User> getAll();
mapper的namespace 就是接口的完整路径
select|insert|update|delete id 就是接口中的方法名称
关于在CRUD的时候的语句中:
eg:
<insert id = "insert" parameterType="User">
insert into user (userName,password) values (#{userName},#{password})
mybatis核心文件:
configuratinMapping.xml:
解释每一层目录:
environments:开发环境,id可以有development和work开发和工作当项目发布后,改为work.
environments下面可以集成多个enviroment,id和上面environments对应
2.mybatis提供的resutlMap="mapId"
定义一个map处理
<resultMap type="user" id=”mapid“>
<id property="属性" column="字段">主键用id
<result property="属性" column="字段"/>其他用result
select * form classes c,where c.c_id=#{id}
</selct>
<select id="getTseacher" papramtype="int" resultType="teacher">没有用resultMap就必须用别名进行
字段列和实体属性的映射
在
<delete id=”delete“ parameterType="int">
delete from user where id="#{idd}"
</delete>
参数idd可以使随便的名字,应为他参数的类型不是从实体类进来的,是整形。
所以可以随便去取。
在findAll()的时候,
</association>
</resultMap>
2.嵌套查询:(两次查询)
第一次查询classes所有信息,第二次根据第一次查询结果中的teacher信息在teacher 表中查找
<select id="classesFind" papramtype="int" resultMap="resultMap">
select t_id id ,t_name name form teacher t,where t_id=#{tid}参数由上一次查询字段的结果传入teacher_id
</selct>
<resultMap id="resultMap" type="classes">
<id....>classes自己的属性id和name
UserMapper mapper=session.getMap(T.class),参数传入接口的类型就ok,直接动态产生了接口的实现类
调用接口里的方法
mapper.findAll();
******************字段名和属性名不同的冲突****************8
当字段名和实体属性名不同的时候:
<resultMap id="resultMap" type="classes">
<id....>classes自己的属性id和name
<.>
<==关键的标签association实现关联classes对象里的teacher对象==>
<association property="teacher" javaTppe="Teacher"> javaTppe作用是告诉框架映射的类型
</map>
1:1关联映射:
1.连表查询
2.嵌套查询
专门做一对一的标签:<association property= javaTppe=>
例如:有个教师表和教室表,是一对一的关系,在教室表中有外键教师I来自,现在查询教室id为?的教师
Teacher类和Classes类
在映射文件中,
1.写一个接口,没有映射文件了,定义sql映射的接口,把所有的SQL语句都写在接口里面
eg:
public interface UserMap(){
@insert("insert into user (username,password)values(#{name},#(password))")
在查询的时候,select * 的时候,从数据库里查询出来的字段和实体属性名字不一样,mybatis就
无法直接映射到对应的属性去赋值,所以,出错。
可以通过:
1.select id userId name UserName from user;
起别名的形式吧数据库里的id name 值转换为userid username 来处理去映射到实体属性中。
事务管理:jdbc
数据源 type=pooled连接池的形式
建立和库字段对应的实体类:
因为mybatis通过java反射来工作,所以,必须有一个无惨的构造方法。
**********************映射文件xml中的目录:***********************8
mapper对应一个接口
property是classes类中的属性名:teacher,类型是
Teacher类型,进行链接
teacher 里面的id <id property="teacherId" column="t_id">
<result property="teacherName" column="t_name">
<select id="select" resultType="resultMapid"
***在增删改的时候注意提交事物
自动提交的时候在openSession(true) 添加true参数
**********************************基于注解的****************************************
teacher 里面的id
<id property="teacherId" column="t_id">
<result property="teacherName" column="t_name">
</association>
</resultMap>
<.>
<association property="teacher" select="getTseacher" column="teacher_id" >
teacher_id是取到该字段所对应的值传给select
select引用了第二个查询teacher
property是classes类中的属性名teacher,类型是Teacher类型,进行链接
}
接口写完后必须要在mybatis的主配置文件中进行映射,
<mapper class="erMapper"/>
2.接口的实现不需要我们写,是动态实现的
在session中有个方法getmapper(userMapper.class)
sqlSession session=factory.openSession();
<select id="" papramtype="int" resultType="resultMap">
(基本的复合语句):
select * form classes c,teachers t where c.teacher_id=t.teacher_id and c.c_id=1
</selct>
</insert>
第一个userName和password是和数据库中字段的对应的名字
第二个#{userName},#{password}的参数名字必须和User实体类的属性对应
因为mybatis通过java反射来工作,在根据参数类型进行解析的时候,通过
getXxx来获取参数值的,所以必须对应。