快速上手Mybatis1.什么是mybatis？ mybatis是基于sql开发的ORM,持久层框架, 其内部封装了jd
站长
· 阅读数 20
1.什么是mybatis？
mybatis是基于sql开发的ORM,持久层框架, 其内部封装了jdbc, 使开发者只 关注于sql语句本身 不用编写繁琐 创建连接 加载驱动 参数处理 结果集处理等操作 mybatis全部都处理好了 前身是ibatis (底层包名字还是它)
1.1 ORM
ORM：object Relation Mapping:对象关系映射，实现java中的对象和关系型数据库中的数据可以实现一一对应，这样就可以把对于数据库的操作转化成 对于对象的操作 比如：新增一条数据 这里表示新增一个对象
class User{
int id;
String name;
...
}
如何实现ORM: 对象关系映射
1.类名--->表名对应
2.类中属性名--->表中字段名
这个过程 以后通过mybatis映射文件来实现
| uid | uname |
|---|---|
| 1 | 张三 |
| 2 | 李四 |
1.2 持久层
持久状态(存储文件 存储数据库)和临时状态(内存...)
持久层就是为了将数据如何长久保留 他泛指的就是存储数据库(增删改查)
所以持久化操作就是增删改查操作
2.搭建mybatis环境
- 创建maven项目
- 导入相关依赖()
- 原来dao层改成mapper层 提供一个对应Mapper接口 不用实现类
- 但是每个mapper接口 需要对应一个映射文件
- 创建mybatis核心配置文件
- 通过mybatis工作流程测试
3.Mybatis工作流程 ---面试题
- 加载mybatis核心配置文件(会关联很多映射文件)
- 创建SqlSessionFactory对象 只需要创建一个
- 通过SqlSessionFactory创建SqlSession(操作mybatis核心对象 做事务也依赖于它)
- 通过SqlSession动态创建Mapper接口实现类对象(jdk动态代理)
- 通过mapper对象执行持久化操作(增删改查)
- 通过SqlSession对事务提交或者回滚(只有真正提交事务了才会发送sql语句执行)
- 关闭资源SqlSession关闭
<!--核心配置文件-->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--1.引入jdbc.properties配置 成功后${key}获取value-->
<properties resource="jdbc.properties"></properties>
<!--2.可选参数:-->
<settings>
<!--开启日志:mybatis运行任何sql语句控制台都可以看到执行过程-->
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
<!--3.插件:分页插件-->
<!--4.数据库环境: 可以配置多个环境 通过default来生效哪个环境-->
<environments default="mysql">
<environment id="mysql">
<!--事务管理: mybatis主要有两种事务管理策略
1.JDBC: 底层利用jdbc方式做事务
2.MANAGED: mybatis自身不做事务 让其他容器来实现 比如:spring容器
-->
<transactionManager type="JDBC"></transactionManager>
<!--数据源: 推荐使用连接池-->
<dataSource type="pooled">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
<!--<environment id="oracle">
<transactionManager type=""></transactionManager>
<dataSource type=""></dataSource>
</environment>-->
</environments>
<!--5.关联映射文件-->
<mappers>
<!--class:通过注解实现映射文件功能
resource: 资源 在项目中资源
url: 网络请求 访问映射文件
-->
<mapper resource="mapper/StudentMapper.xml"/>
</mappers>
</configuration>
<!--映射文件-->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--mapper接口和映射文件如何对应 通过namespace编写全类名-->
<mapper namespace="com.sc.mapper.StudentMapper">
<!--sql语句一定不要加分号:否则报错很难发现问题-->
<insert id="add">
insert into student values(null,#{sname}
,#{ssex},#{sbirthday},#{classname})
</insert>
<select id="show" resultType="com.sc.pojo.Student">
select * from student
</select>
</mapper>
//测试代码
public class TestMybatis {
@Test
public void first() throws IOException {
//1.加载核心配置文件
InputStream is=
Resources.getResourceAsStream("mybatis.xml");
//2.创建session工厂
SqlSessionFactory sf=new SqlSessionFactoryBuilder().build(is);
//3.创建session 不是HttpSession 是SqlSession
SqlSession session=sf.openSession();
//4.通过session动态创建Mapper接口实现类
StudentMapper mapper=
session.getMapper(StudentMapper.class);
//5.持久化操作
List<Student> list=mapper.show();
//System.out.println(list);
//6.session提交或回滚事务
session.commit(); //一定要提交 否则 内存完成的 不是真的执行sql语句
//session.rollback();
//7.关闭资源
session.close();
}
SqlSession session;
@Before
public void before() throws IOException {
//1.加载核心配置文件
InputStream is=
Resources.getResourceAsStream("mybatis.xml");
//2.创建session工厂
SqlSessionFactory sf=new SqlSessionFactoryBuilder().build(is);
//3.创建session 不是HttpSession 是SqlSession
session=sf.openSession();
}
@After
public void after(){
//6.session提交或回滚事务
session.commit(); //一定要提交 否则 内存完成的 不是真的执行sql语句
//session.rollback();
//7.关闭资源
session.close();
}
@Test
public void add(){
StudentMapper mapper=
session.getMapper(StudentMapper.class);
Student s=new Student();
s.setSname("王五");
s.setSbirthday(new Date());
s.setSsex("男");
s.setClassname("2406");
mapper.add(s);
}
}
4.Mybatis反向生成工具
反向生成工具 只要配置好了 可以根据数据库表，动态生成实体类(pojo)，Mapper接口(mapper)，映射文件，并且映射文件和mapper接口还可以帮你生成一些常用的增删改查语句，其他需要自定义编写
4.1 pom.xml安装一个插件(generator插件)
<!--maven的mybatis代码生成插件-->
<plugin>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.3.5</version>
<configuration>
<verbose>true</verbose>
<overwrite>true</overwrite>
</configuration>
</plugin>
4.2下载反向生成工具的配置文件generator-config.xml
4.3 配置好反向生成工具即可
- 更新里面不同的包(实体类 映射文件 mapper接口)
- 更新好数据库驱动地址
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd" >
<generatorConfiguration>
<!--加载jdbc.properties配置文件-->
<properties resource="jdbc.properties" />
<!--配置驱动jar包的位置-->
<classPathEntry location="${driverClassPath}" />
<!--
context:生成一组对象的环境
id:必选，上下文id，用于在生成错误时提示
defaultModelType:指定生成对象的样式
1，conditional：类似hierarchical；
2，flat：所有内容（主键，blob）等全部生成在一个对象中；
3，hierarchical：主键生成一个XXKey对象(key class)，Blob等单独生成一个对象，其他简单属性在一个对象中(record class)
targetRuntime:
1，MyBatis3：默认的值，生成基于MyBatis3.x以上版本的内容，包括XXXBySample；
2，MyBatis3Simple：类似MyBatis3，只是不生成XXXBySample；
introspectedColumnImpl：类全限定名，用于扩展MBG
-->
<context id="context1" targetRuntime="MyBatis3">
<!-- genenat entity时,生成toString -->
<plugin type="org.mybatis.generator.plugins.ToStringPlugin"/>
<!-- generate entity时，生成serialVersionUID -->
<plugin type="org.mybatis.generator.plugins.SerializablePlugin"/>
<!--不生成注释-->
<commentGenerator>
<property name="suppressAllComments" value="true" />
</commentGenerator>
<!--配置数据库连接信息-->
<jdbcConnection driverClass="${jdbc.driver}"
connectionURL="${jdbc.url}" userId="${jdbc.username}" password="${jdbc.password}" />
<!-- java模型创建器，是必须要的元素
负责：1，key类（见context的defaultModelType）；2，java类；3，查询类
targetPackage：生成的类要放的包，真实的包受enableSubPackages属性控制；
targetProject：目标项目，指定一个存在的目录下，生成的内容会放到指定目录中，如果目录不存在，MBG不会自动建目录
-->
<!--设置生成实体类包的位置-->
<javaModelGenerator targetPackage="com.sc.pojo"
targetProject="src/main/java">
<!-- 设置是否在getter方法中，对String类型字段调用trim()方法 -->
<property name="trimStrings" value="true" />
</javaModelGenerator>
<!-- 生成SQL map的XML文件生成器，
注意，在Mybatis3之后，我们可以使用mapper.xml文件+Mapper接口（或者不用mapper接口），
或者只使用Mapper接口+Annotation，所以，如果 javaClientGenerator配置中配置了需要生成XML的话，这个元素就必须配置
targetPackage/targetProject:同javaModelGenerator
-->
<!--设置映射文件包的位置-->
<sqlMapGenerator targetPackage="mapper"
targetProject="src/main/resources"></sqlMapGenerator>
<!-- 对于mybatis来说，即生成Mapper接口，注意，如果没有配置该元素，那么默认不会生成Mapper接口
targetPackage/targetProject:同javaModelGenerator
type：选择怎么生成mapper接口（在MyBatis3/MyBatis3Simple下）：
1，ANNOTATEDMAPPER：会生成使用Mapper接口+Annotation的方式创建（SQL生成在annotation中），不会生成对应的XML；
2，MIXEDMAPPER：使用混合配置，会生成Mapper接口，并适当添加合适的Annotation，但是XML会生成在XML中；
3，XMLMAPPER：会生成Mapper接口，接口完全依赖XML；
注意，如果context是MyBatis3Simple：只支持ANNOTATEDMAPPER和XMLMAPPER
-->
<!--设置mapper接口包的位置-->
<javaClientGenerator targetPackage="com.sc.mapper"
targetProject="src/main/java" type="XMLMAPPER" />
<!-- 需要逆向 enableCountByExample="false" enableUpdateByExample="false"
enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"
-->
<!--设置表名: 根据这个表生成 实体类 映射文件 mapper接口
bug: 如果已经生成完毕了 生成多次
实体类: 会还原 自己添加的内容就没了
mapper接口: 会还原 自定义功能没了
映射文件: 会追加 映射文件的标签会追加一遍 会报错
如何防止: 生成过的表 不要写第二次
-->
<table tableName="huser" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false"
enableSelectByExample="false" selectByExampleQueryId="false" >
<!--<columnOverride column="ID" javaType="java.lang.Integer"></columnOverride>-->
</table>
</context>
</generatorConfiguration>
5.映射文件介绍
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--根节点: namespace配置全类名 用于和Mapper接口一一对应-->
<mapper namespace="com.sc.mapper.HuserMapper">
<!--resultMap: 用于实现ORM的 也可以用于实现复杂 关联查询
属性id: map唯一标识 resultMap可以配置多个
属性type: 表示当前这个表对应的是哪个类
子标签id: 表示主键列标签 mybatis推荐每个表添加主键
子标签result: 表示其他列标签
column: 表示表中的字段(准确的说是查询语句查询字段)
property: 表示类中的属性名
jdbcType: 表示表种字段的类型 可以省略
-->
<resultMap id="BaseResultMap" type="com.sc.pojo.Huser">
<id column="id" property="id" />
<result column="username" property="username" />
<result column="password" property="password" />
<result column="createtime" jdbcType="DATE" property="createtime" />
<result column="did" jdbcType="INTEGER" property="did" />
</resultMap>
<!--用于定义sql语句 可以重用的片段 也可以配置多个
下面所有的标签都可以通过include标签来包含-->
<sql id="Base_Column_List">
id, username, password, createtime, did
</sql>
<sql id="myBaseSql">
id,username,password
</sql>
<!--增 删 改 查标签 都必须id和mapper接口方法对应-->
<!--查询语句标签 : 必须添加resultMap 或 resultType表示结果类型
parameterType="java.lang.Integer" 表示mapper接口方法参数类型 可以省略
resultType: 自动映射 只要查询字段名 和类中属性一样
就可以自动映射 就可以自动给属性赋值 反之如果不同 则是null
resultMap: 自定义表中和类中映射关系 这样查询字段 和属性
是否一样 都可以查询出来 它还可以复杂关联查询
#{id}: 通过预编译 占位符 防止sql注入
${id}: 非预编译 字符串拼接 有注入风险
-->
<select id="selectByPrimaryKey" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from huser
where id = #{id}
</select>
<delete id="deleteByPrimaryKey">
delete from huser
where id = #{id}
</delete>
<!--全列新增 所有字段都添加数据-->
<insert id="insert">
insert into huser
values (#{id}, #{username}, #{password},
#{createtime}, #{did})
</insert>
<!--动态新增: 根据传入参数属性 如果指定列有值 就插入 否则不插入 -->
<!-- Huser id un pw
insert into huser (id) values(?)
insert into huser (id,un) values(?,?)
insert into huser (id,un,pw) values(?,?,?)
insert into huser ( id,un,pw )
values( #{id},#{un},#{pw} )
-->
<insert id="insertSelective">
insert into huser
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="id != null">
id,
</if>
<if test="username != null">
username,
</if>
<if test="password != null">
password,
</if>
<if test="createtime != null">
createtime,
</if>
<if test="did != null">
did,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="id != null">
#{id,jdbcType=INTEGER},
</if>
<if test="username != null">
#{username,jdbcType=VARCHAR},
</if>
<if test="password != null">
#{password,jdbcType=VARCHAR},
</if>
<if test="createtime != null">
#{createtime,jdbcType=DATE},
</if>
<if test="did != null">
#{did,jdbcType=INTEGER},
</if>
</trim>
</insert>
<!--动态更新: 根据参数的属性 是否有值 来动态更新对应属性
update huser set 字段=?,字段2=?,... where id=?
-->
<update id="updateByPrimaryKeySelective">
update huser
<set>
<if test="username != null">
username = #{username},
</if>
<if test="password != null">
password = #{password},
</if>
<if test="createtime != null">
createtime = #{createtime},
</if>
<if test="did != null">
did = #{did},
</if>
</set>
where id = #{id}
</update>
<!--全列更新-->
<update id="updateByPrimaryKey">
update huser
set username = #{username},
password = #{password},
createtime = #{createtime},
did = #{did}
where id = #{id}
</update>
</mapper>
6. Mybatis中Mapper接口参数传递
-
传递一个参数：#{ } 因为就一个参数写什么都是它自己
select <include refid="Base_Column_List"/> from huser where username=#{usernameasdasdasdas} -
传递对象参数：#{属性名} 直接获取对象中的属性值
int add(User u); insert into user values(null,#{name},#{sex}) -
传递多个参数：必须要添加注解@Param("别名")映射文件只识别别名
Huser login(@Param("别名1")String a, @Param("别名2")String b); int addUser2( @Param("un") String username, @Param("user") Huser u, @Param("date") Date time); select * from user where un=#{a} and pw=#{b} 错误的 select * from user where un=#{别名1} and pw=#{别名2} insert into huser values(null,#{un},#{user.password},#{date},#{user.did}) -
传递集合或数组：(适用于批量删除 批量新增...)
//传递集合或者数组 int batchAdd(List<Huser> users); int batchDel(Integer[] ids); <insert id="batchAdd"> insert into huser values <foreach collection="list" item="u" separator=","> (null,#{u.username},#{u.password},#{u.createtime},#{u.did}) </foreach> </insert> <!--foreach属性介绍: collection: 指定遍历的数组或者集合 一般写 list,array,自定义 item: 就是每次遍历出来的数据 类似于临时变量 separator: 指定 每个遍历的元素直接间隔符 会自动取出最后一个 open: 指定遍历开始位置的内容 close: 指定遍历结束位置的内容 --> <delete id="batchDel"> delete from huser where id in <foreach collection="array" item="id" separator="," open="(" close=")"> #{id} </foreach> </delete> -
传递Map集合：类似于对象参数使用#{key}获取value 一般参数不相关 不适合封装到对象中 可以考虑封装到map中
比如:select * from huser where did between ? and ? limit ?,? //传递Map集合 List<Huser> selectByMap(Map m); <select id="selectByMap" resultType="com.sc.pojo.Huser"> select <include refid="Base_Column_List"/> from huser where password=#{pw} limit #{begin},#{length} </select>
6.1 mybatis的Mapper接口如何传递多个参数
- 添加@Param注解 添加别名 映射文件中#{别名}
- 添加对象参数 只要把多个参数封装到对象中 #{属性名}
- 添加map集合 只要把这些不相关的属性 添加到map中 #{key}
7. 映射文件中resultType和resultMap区别？
-
resultType：只有当查询字段和类中的属性一样时 才会自动映射(自动赋值) 如果不一样 属性就是null
-
解决方案:
- 给sql语句字段添加别名 别名和属性一致 也可以映射
- 可以使用resultMap 它可以自定义映射关系
-
-
resultMap：属于可以根据用户需要自定义查询字段和属性的关系 所以名称是否一致 都可以映射 还可以实现复杂 多表关联查询
- 开发阶段：推荐使用resultMap
8. #{}和${} 区别
- ${}: 底层Statement实现 采用字符串拼接方式 处理参数 存在sql注入的隐患 通常用于处理 表名 字段名 这些不需要预编译内容
- #{}: 底层PreparedStatement实现 采用预编译的方式 先编译sql语句 一次编译可以多次执行 参数是通过? 做占位符 可以防止sql 注入 执行效率会稍微高一些
9.动态sql语句是如何实现的
谈谈Mybatis动态sql语句
mybatis动态sql语句通过类似于c:forEach和c:if标签 根据mapper接口传递的参数不同 会动态生成不同的sql语句 面试官的问题就是问你 有哪些常用标签可以实现这种动态sql语句
9.1 常用映射文件标签：
-
resultMap标签：
-
sql：
-
delete insert update select：
-
动态sql语句标签一般用于增删改查的子标签
-
if：可以根据属性 是否满足条件 拼接sql语句 增删改查 都可以使用
username是mapper接口传递的参数:@Param("un") Stringu un String pw 参数: User对象 有一个un属性 <if test="un!=null"> #{username} ??? </if> -
set：只能用于更新语句 自动添加set关键字
update 表 <set> <if test="列!=null"> 列=?, </if> </set>
-
-
where：一般适用于删改查 用于添加where关键字 同时where还可以去除多余的and
select * from 表 <where> <if test="名称!=null"> and 名称=? </if> </where> select * from 表 where 名称=? select * from 表 where 套餐=? select * from 表 where 名称=? and 套餐=?-
trim：适用任何sql语句 功能强大 内部已经结合了set和where的功能 也可以去除多余,和and
-
forEach：用于遍历参数 是集合或者数组的
-
bind：用于对传递的参数 做二次处理(拼接%) 通常用于模糊查询
<!--mapper接口和映射文件如何对应 通过namespace编写全类名--> <mapper namespace="com.sc.mapper.StudentMapper"> <!--自定义resultMap--> <resultMap id="myMap" type="com.sc.pojo.Student"> <id column="sno" property="sno"/> <result column="sname" property="sname"/> <result column="ssex" property="ssex"/> <result column="sbirthday" property="sbirthday"/> <result column="class" property="classname"/> </resultMap> <!--sql语句一定不要加分号:否则报错很难发现问题--> <insert id="add"> insert into student values(null,#{sname} ,#{ssex},#{sbirthday},#{classname}) </insert> <insert id="addSelective"> insert into student <trim prefix="(" suffix=")" suffixOverrides=","> <!--描述 (列1,列2,...)--> <if test="sno!=null"> sno, </if> <if test="sname!=null"> sname, </if> <if test="ssex!=null"> ssex, </if> <if test="sbirthday!=null"> sbirthday, </if> <if test="classname!=null"> class, </if> </trim> <trim prefix="values(" suffix=")" suffixOverrides=","> <!--描述values(值1,值2)--> <if test="sno!=null"> #{sno}, </if> <if test="sname!=null"> #{sname}, </if> <if test="ssex!=null"> #{ssex}, </if> <if test="sbirthday!=null"> #{sbirthday}, </if> <if test="classname!=null"> #{classname}, </if> </trim> </insert> <update id="updateSelective1"> update student <set> <!--动态添加set关键字 还能去除多余,--> <if test="sname!=null"> sname=#{sname}, </if> <if test="ssex!=null"> ssex=#{ssex}, </if> <if test="sbirthday!=null"> sbirthday=#{sbirthday}, </if> <if test="classname!=null"> class=#{classname}, </if> </set> where sno=#{sno} </update> <update id="updateSelective2"> update student <trim prefix="set " suffixOverrides=","> <if test="sname!=null"> sname=#{sname}, </if> <if test="ssex!=null"> ssex=#{ssex}, </if> <if test="sbirthday!=null"> sbirthday=#{sbirthday}, </if> <if test="classname!=null"> class=#{classname}, </if> </trim> where sno=#{sno} </update> <sql id="myBase"> sno,sname,ssex,sbirthday,class </sql> <select id="show" resultMap="myMap"> select <include refid="myBase"/> from student </select> <select id="querySelective1" resultMap="myMap"> select <include refid="myBase"></include> from student <where> <!--能够实现jdbc类似于where 1=1 帮你添加where 关键字 还可以动态去除多余and--> <if test="sname!=null"> <!--可以对sname属性值 做二次处理生成新的变量--> <bind name="newName" value="'%'+sname+'%'"/> and sname like #{newName} </if> <if test="ssex!=null"> and ssex=#{ssex} </if> <if test="sbirthday!=null"> and sbirthday=#{sbirthday} </if> <if test="classname!=null"> and class=#{classname} </if> </where> </select> <select id="querySelective2" resultMap="myMap"> select <include refid="myBase"></include> from student <trim prefix="where " prefixOverrides="and"> <if test="sname!=null"> <!--可以对sname属性值 做二次处理生成新的变量--> <bind name="newName" value="'%'+sname+'%'"/> and sname like #{newName} </if> <if test="ssex!=null"> and ssex=#{ssex} </if> <if test="sbirthday!=null"> and sbirthday=#{sbirthday} </if> <if test="classname!=null"> and class=#{classname} </if> <!--<choose> <when test=""></when> <when test=""></when> <when test=""></when> <otherwise></otherwise> </choose>--> </trim> </select> </mapper>
-
10.关联映射 --- 难点
10.1 为什么需要关联映射
mybatis如果实现一张表查询 我们都可以正常实现，但是如果查询的数据涉及到多张表 就很难控制了 比如:
用户姓名 用户性别 用户年龄 用户部门
huser huserinfo hdept
10.2哪些关联映射
-
一对一关联：用户表 和 用户信息表 是一对一的
因为每个用户只能对应一个用户信息
-
一对多关联： 部门表和用户表就是一对多的
因为每个部门 可以包含多个用户
-
多对一关联：用户表 和 部门就是多对一的
因为多个用户都可以加入一个部门
-
多对多关联：学生表 和老师表 就是多对多的
因为一个学生可以被很多老师教
一个老师可以教很多学生
10.3实现关联映射的前提
-
表和表的关系维护好
- 1:1 ：一个表的主键和另一个表的主键是一一对应的（让两个id相等）
- 1:n ：两个表 必须存在 主外键关联(如果数据存储合理也可以不建)
- n:1 ： 两个表 必须存在 主外键关联(如果数据存储合理也可以不建)
- n:n ：两个表之间是通过关系表来维护的,关系表保存的两个表的外键
-
类和类的关系维护好
- 1:1 ：用户类 添加属性(关联属性) 用户信息对象
- n:1 ：用户类 添加属性 部门对象
- 1:n ：部门类 添加属性 用户集合
- n:n ：老师类 添加属性 学生集合
-
mybatis如何实现关联映射
-
第一种方式：通过多表连接一次性查完全部数据 就可以封装给多个类 保存
<!--描述对象--> <association property="关联属性名" javaType="关联属性类型"> <id column="?" property="?"/> <result column="?" property="?"/> ... 1:1:1可以继续嵌套 <association> ... </association> </association> <!--描述集合--> <collection properyty="关联属性名" ofType="集合泛型"> <id column="?" property="?"/> <result column="?" property="?"/> </collection> -
第二种方式：可以分两次查询 调用其他mapper接口写好的方法 来给关联属性赋值
<!--描述对象--> <association property="关联属性名" column="其他mapper接口需要的参数" select="其他mapper接口全类名+方法"> </association> <!--描述集合--> <collection properyty="关联属性名" ofType="集合泛型" column="其他mapper接口需要的参数" select="其他mapper接口全类名+方法名"> </collection>
-
11. Mybatis缓存
11.1 为什么需要缓存
缓存类似于系统中的内存，访问数据库mysql类似于访问本地磁盘,缓存访问速度一定是高于访问mysql的速度，mybatis提供一种缓存机制, 当第一次查询数据时，不会先查询数据库 而是先查看缓存是否存在 如果有直接返回 这样就不走数据库了， 如果缓存中没有 才会发送sql语句查询数据库 并且还会再缓存中保存一份 为了方便下一次使用 所以缓存目的是为了提高查询效率
注:如果其他人修改了数据 mybatis会清空缓存 防止脏读
11.2 mybatis两种缓存机制 ---面试题
-
一级缓存：是sqlSession范围，默认开启 无需多余配置 可以在同一个sqlsession中 有效的 对数据做增删改 会自动清空缓存 防止脏读
@Test public void testOneCache(){ HuserMapper mapper= MybatisUtil .getMapper(HuserMapper.class); //第一次查询 先访问mysql 存储到缓存中 发送一次sql语句 Huser u=mapper.selectByPrimaryKey(5); System.out.println(u); //第二次查询 缓存已经有了 不走mysql了 u=mapper.selectByPrimaryKey(5); System.out.println(u); //如果修改了数据 为了防止脏读 会清空缓存 u.setPassword("111111"); mapper.updateByPrimaryKey(u); //再次查询 发现缓存没了 只能再查mysql(存储缓存) 发送一次sql语句 u=mapper.selectByPrimaryKey(5); System.out.println(u); MybatisUtil.close(); //提交 关闭了 //获取新的sqlSession 创建mapper mapper=MybatisUtil .getMapper(HuserMapper.class); //它是新的sqlSession得到的结果 和不能之前的sqlSession的缓存 //所以查询mysql 发送一次sql语句 u=mapper.selectByPrimaryKey(5); System.out.println(u); MybatisUtil.close(); //提交 关闭了 } -
二级缓存：是Mapper级别的缓存，可以在不同的sqlSession共享 默认不开启的 需要手动配置 只有一级缓存没了才会使用二级缓存
@Test public void testTwoCache(){ //开了二级缓存 可以再不同sqlSession共享 // 只有一级没了 才会使用二级 HuserMapper mapper=MybatisUtil .getMapper(HuserMapper.class); //第一次查 会查mysql 默认存一级缓存 二级缓存只要开启也会存储 Huser u=mapper.selectByPrimaryKey(5); System.out.println(u); //一级缓存 存在 不走mysql u=mapper.selectByPrimaryKey(5); System.out.println(u); MybatisUtil.close(); //一级缓存sqlSession回收了 没了 mapper=MybatisUtil .getMapper(HuserMapper.class); //一级没了 才开始走二级缓存 这个时候也不走mysql u=mapper.selectByPrimaryKey(5); System.out.println(u); //修改数据 一级和二级都会清空缓存 u.setPassword("666666"); mapper.updateByPrimaryKey(u); MybatisUtil.close(); //再关闭一次 为了测试二级缓存是否会清除 mapper=MybatisUtil .getMapper(HuserMapper.class); //由于前面更新了 二级缓存也清空了 //再查相同的数据 只能访问mysql u=mapper.selectByPrimaryKey(5); System.out.println(u); MybatisUtil.close(); }
12.Mybatis悲观锁 和乐观锁
12.1 什么是乐观锁和悲观锁
- 乐观锁： 给表添加一个字段 版本号(int) 或者 时间戳(timestamp) 两种实现方式都差不多 就是类型不同而已 原理就是每次更新数据时 先查询一遍版本号 等到用户使用完数据了 提交事务之前 再匹配一下版本号 ， 如果两次结果时一致的说明 其他人没有改过 就可以提交事务 然后更新版本号如果两次匹配不一致 说明别人修改过 则不能提交事务
- 悲观锁：是数据库控制的 原理就是再查询时 添加for update 来锁住表中的数据 , 这样其他用户就无法操作这些加锁的数据 只有提交了事务 才会释放锁 这样其他用户可以操作这些数据 类似于同步锁
12.2 乐观锁实现
public interface TestLockMapper{
//实现乐观锁 更新
int updateLock(Testlock lock);
Testlock selectByPrimaryKey(Integer id);
}
<!--springboot有一个专门配置类 自动处理版本号的问题-->
<!--如果只是mybatis只能手动编写-->
<update id="updateLock">
update testlock set name=#{name},version=version+1
where id=#{id} and version=#{version}
</update>
@Test
public void testHappyLock1() throws InterruptedException {
TestlockMapper mapper=
MybatisUtil.getMapper(TestlockMapper.class);
//先查询一遍数据 记录版本号
Testlock lock=mapper.selectByPrimaryKey(1);
Thread.sleep(10000);
//更新时候 匹配版本号是否一致 如果一致才提交事务
lock.setName("zhangsan1111111");
mapper.updateLock(lock);
MybatisUtil.close();
}
12.3 悲观锁实现
public interface TestLockMapper{
//实现悲观锁 查询 添加for update给数据上锁
Testlock selectForUpdate(Integer id);
}
<select id="selectForUpdate" resultMap="BaseResultMap">
select
<include refid="Base_Column_List"/>
from testlock where id=#{id} for update
</select>
@Test
public void testNotHappyLock1() throws InterruptedException {
TestlockMapper mapper=
MybatisUtil.getMapper(TestlockMapper.class);
//先查询一遍数据 是为了给数据加锁
Testlock lock=mapper.selectForUpdate(1);
Thread.sleep(10000);
lock.setName("111111");
mapper.updateLock(lock); //底层id条件 version条件
MybatisUtil.close(); //提交事务 释放了数据的锁 其他用户才可以操作
}
13.Mapper接口的工作原理 --- 难点
1.mapper接口原理?
2.mapper接口能重载嘛?
3.mybatis主要使用了几种拦截器?
...
Mapper接口就是原来的dao接口，是根据映射文件中的namespace属性 对应哪个Mapper接口 Mapper接口的方法对应的是映射文件中标签id
-
工作原理：先根据Mapper接口全类名+方法名 作为key值 用于快速定位是哪个映射文件中的哪个标签， 底层通过JDK动态代理方式 运行时会为每一个Mapper接口创建一个Proxy(代理对象),会拦截Mapper接口方法,拦截之后帮你动态调用哪个映射文件的哪个标签 就可以执行sql语句, 最终执行结束后 运行结果 也会通过拦截器 按照你方法提供的返回值 进行封装
-
提供几种拦截器：实现原理都是AOP面向切面编程
- 3->执行器拦截器: 拦截器sql语句可以用于执行sql语句 可以做事务 用来实现mybatis缓存机制的
- 1->参数拦截器: 用来拦截传递的Mapper接口的方法参数 还可以用来做转换
- 4->结果集拦截器: 用来拦截查询结果 处理结果封装到返回值中
- 2->sql语句构建拦截器: 用来修改sql语句 修改参数 #{属性} 替换成? 占位符 给?占位符 赋值 ${}替换成字符串拼接
-
它的方法是否可以重载: 不能重载,因为他是通过全类名+方法名作为key来匹配的 如果重载了方法名一样了 就会生成多个一样的key mybatis就无法对应到哪个标签
转载自:https://juejin.cn/post/7412075509456912411