一,概念
MyBatis是一个对象关系映射框架,简称ORM框架。RM框架提供了持久化类与表的映射关系,在运行时参照映射文件的信息,把对象持久化到数据库中。
目前常见的ORM框架有mybatis和hibernate,两者的区别主要是:
1,sql方面
Hibernate 自动生成sql,部分语句较为繁琐,会多消耗性能;适用于传统管理类项目。
Mybatis 手动编写sql,可避免不必要的查询,自主优化,提高系统性能;适用于注重性能的互联网项目。
2,开发方面
hibernate开发中,完全面向对象封装,sql语句已经被封装,直接可以使用,加快系统开发,但开发者不容易理解底层实现。
Mybatis开发中,自行管理映射关系, 属于半自动化,sql需要手工完成,稍微繁琐,但容易让开发者理解底层实现。
3,缓存方面
Hibernate的二级缓存配置在SessionFactory生成的配置文件中进行详细配置,然后再在具体的表-对象映射中配置是哪种缓存。
MyBatis的二级缓存配置都是在每个具体的表-对象映射中进行详细配置,针对不同的表可自定义不同缓存机制。并且Mybatis可以在命名空间中共享相同的缓存配置和实例,通过Cache-ref来实现。
4,数据库的移植性
MyBatis不能支持数据库无关性,即数据库发生变更,要写多套代码进行支持,移植性不好。
Hibernate具有良好的数据库无关性,即数据库发生变化的话,代码无需再次编写。以后,mysql数据迁移到oracle,只需要改方言配置
二,MyBatis的sql参数绑定
1,序号(原生)参数绑定
参数顺序对应sql语句参数顺序
//id对应arg0,pwd对应arg1
public User selectUserByIdAndPwd(Integer id , String pwd);
SELECT * FROM t_users
WHERE id = #{arg0} AND password = #{arg1}
2,注解(原生)参数绑定
注解别名对应sql参数名
public User selectUserByIdAndPwd(@Param("id")Integer aaa,
@Param("pwd")String bbb);
SELECT * FROM t_users
WHERE id = #{id} AND password = #{pwd}
3,Map参数绑定
键值对应sql参数名
Map values = new HashMap(); //测试类创建Map
values.put("myId",1); //自定义key,绑定参数
values.put("myPwd","123456");
User user = userDao.selectUserByIdAndPwd_map(values);
SELECT * FROM t_users
WHERE id = #{myId} AND password = #{myPwd}
4,对象参数绑定
对象属性名对应sql参数名
public User selectUserByUserInfo(User user);
SELECT * FROM t_users
WHERE id = #{id} AND password = #{password}
5,$符号参数绑定
${attribute} 属于字符串拼接SQL,而非预编译占位符,会有注入攻击问题,不建议在常规SQL中使用,常用于可解决动态生降序问题
User user = new User(....);
List<User> ulist1 = userDAO.selectAllUsers1(user); //调用时传入user对象
List<User> ulist2 = userDao.selectAllUsers2("desc"); //调用时传入asc | desc
<select id="selectAllUsers1" resultType="user">
SELECT * FROM t_users
WHERE name = '${name}' or id = ${id} <!-- 拼接name和id,如果是字符类型需要用单引号:'${name}' -->
</select>
<select id="selectAllUsers2" resultType="user">
SELECT * FROM t_users
ORDER BY id ${rule} <!-- 拼接 asc | desc -->
</select>
6,模糊查询
keyword是传入的关键字参数
SELECT * FROM t_users
WHERE name LIKE concat('%',#{keyword},'%')
三,主键回传两种方式
1, 通过last_insert_id()查询主键
<insert id="insertProduct" parameterType="product">
<!-- order=“after”代表插入之后 -->
<selectKey keyProperty="id" resultType="int" order="AFTER">
<!-- 适用于整数类型自增主键 -->
SELECT LAST_INSERT_ID()
</selectKey>
INSERT INTO t_product(id,name) VALUES(#{id},#{name})
</insert>
2,通过uuid()查询主键
<insert id="insertOrder" parameterType="order">
<!-- order=“before”插入之前 -->
<selectKey keyProperty="id" resultType="String" order="BEFORE">
<!-- 适用于字符类型主键 -->
SELECT REPLACE(UUID(),'-','')
</selectKey>
INSERT INTO t_order(id,name) VALUES(#{id},#{name})
</insert>
注意:两种主键的回传方式都是回传到了传递的参数——类的对象的主键属性中,可通过主键get方法得到。
三,ORM映射
1,列的别名
在SQL中使用 as 为查询字段添加列别名,以匹配属性名
SELECT mgr_id AS id , mgr_name AS username , mgr_pwd AS password
FROM t_managers
WHERE mgr_id = #{id} AND mgr_pwd = #{pwd}
2,结果映射(ResultMap - 查询结果的封装规则)
<!--定义resultMap标签-->
<resultMap id="managerResultMap" type="com.qf.mybatis.part2.orm.Manager">
<!--关联主键与列名-->
<id property="id" column="mgr_id" />
<!--关联属性与列名-->
<result property="username" column="mgr_name" />
<result property="password" column="mgr_pwd" />
</resultMap>
<!--使用resultMap作为ORM映射依据-->
<select id="selectAllManagers" resultMap="managerResultMap">
SELECT mgr_id , mgr_name , mgr_pwd
FROM t_managers
</select>
3,驼峰式映射
mybatis配置文件中添加,注意:只适用于驼峰式映射
<settings>
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
四,MyBatis处理关联关系-多表连接
1,一对一关系
典型一对一关系:一个订单详情对应一种商品
使用association 标签,javaType属性表示关联的类
<!-- 结果映射(查询结果的封装规则) -->
<resultMap id="passengerResultMap" type="com.qf.mybatis.part2.one2one.Passenger">
<id property="id" column="id"/>
<result property="name" column="name" />
<result property="sex" column="sex" />
<result property="birthday" column="birthday" />
<!-- 关系表中数据的封装规则 --> <!-- 指定关系表的实体类型 -->
<association property="passport" javaType="com.qf.mybatis.part2.one2one.Passport">
<id property="id" column="passport_id" />
<result property="nationality" column="nationality" />
<result property="expire" column="expire" />
<result property="passenger_id" column="passenger_id" />
</association>
</resultMap>
<!-- 多表连接查询 --> <!-- 结果映射(查询结果的封装规则)-->
<select id="selectPassengerById" resultMap="passengerResultMap">
<!-- 别名(避免与p1.id冲突) -->
SELECT p1.id , p1.name , p1.sex , p1.birthday , p2.id as passport_id , p2.nationality , p2.expire , p2.passenger_id
FROM t_passengers p1 LEFT JOIN t_passports p2
ON p1.id = p2.passenger_id
WHERE p1.id = #{id}
</select>
2,一对多关系
典型一对多关系: 一张订单对应多个订单详情
使用collection标签,ofType属性表示关联的类
<!-- 封装规则 -->
<resultMap id="departmentResultMap" type="com.qf.mybatis.part2.one2many.Department">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="location" column="location" />
<!-- 关系表中数据的封装规则 --> <!-- 指定关系表的实体类型 -->
<collection property="emps" ofType="com.qf.mybatis.part2.one2many.Employee">
<id property="id" column="emp_id" />
<result property="name" column="emp_name" />
<result property="salary" column="salary" />
<result property="dept_id" column="dept_id" />
</collection>
</resultMap>
<!-- 多表连接查询 --> <!-- 封装规则 -->
<select id="selectDepartmentById" resultMap="departmentResultMap" >
<!-- 别名(避免与d.id、d.name冲突)-->
SELECT d.id , d.name , d.location , e.id AS emp_id , e.name emp_name , e.salary , e.dept_id
FROM t_departments d LEFT JOIN t_employees e
ON d.id = e.dept_id
WHERE d.id = #{id}
</select>
3,多对多关系
典型多对多关系:一个学生有多种课程,一种课程有多个学生
建立第三张表存放两表外键,两个外键为联合主键
<!-- 映射查询只封装两表中的信息,可忽略关系表内容 -->
<resultMap id="allMap" type="com.qf.mybatis.part2.many2many.Student">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="sex" column="sex" />
<collection property="subjects" ofType="com.qf.mybatis.part2.many2many.Subject">
<id property="id" column="sid" />
<result property="name" column="sname" />
<result property="grade" column="grade" />
</collection>
</resultMap>
<!-- 三表连接查询 -->
<select id="selectAllStudents" resultMap="allMap">
SELECT s1.* , ss.* , s2.id as sid , s2.name as sname , s2.grade
FROM t_students s1 LEFT JOIN t_stu_sub ss
ON s1.id = ss.student_id <!-- 通过t_stu_sub表建立二者之间的关系 -->
LEFT JOIN t_subjects s2
ON ss.subject_id = s2.id
</select>
五,动态sql
1,include引用sql片段
<sql id="BOOKS_FIELD"> <!-- 定义SQL片段 -->
SELECT id,name,author,publish,sort
</sql>
<select id="selectBookByCondition" resultType="com.qf.mybatis.part2.dynamic.Book">
<!-- 通过ID引用SQL片段 -->
<include refid="BOOKS_FIELD" /> FROM t_books
</select>
2,where 和 if
<select id="selectBookByCondition" resultType="com.qf.mybatis.part2.dynamic.Book">
SELECT id , name , author , publish , sort
FROM t_books
<where> <!-- WHERE,会自动忽略前后缀(如:and | or) -->
<if test="id != null"> id = #{id}</if>
<if test="name != null">and name = #{name}</if>
<if test="author != null">and author = #{author}</if>
<if test="publish != null"> and publish = #{publish}</if>
<if test="sort != null">and sort = #{sort}</if>
</where>
</select>
3,set
<update id="updateBookByCondition">
UPDATE t_books
<set><!-- where子句中满足条件的if,会自动忽略后缀(如:,) -->
<if test="name != null">name = #{name} ,</if>
<if test="author != null">author = #{author} ,</if>
<if test="publish != null">publish = #{publish} ,</if>
<if test="sort != null">sort = #{sort} ,</if>
</set>
WHERE id = #{id}
</update>
4,trim
< trim prefix=“” suffix=“” prefixOverrides=“” suffixOverrides=“” >代替< where > 、< set >
<select id="selectBookByCondition" resultType="com.qf.mybatis.day2.dynamic.Book">
SELECT id,name,author,publish,sort
FROM t_books
<trim prefix="WHERE" prefixOverrides="AND|OR"> <!-- 增加WHERE前缀,自动忽略前缀 -->
<if test="id != null"> and id = #{id}</if>
<if test="name != null">and name = #{name}</if>
<if test="author != null">and author = #{author}</if>
<if test="publish != null">and publish = #{publish}</if>
<if test="sort != null">and sort = #{sort}</if>
</trim></select>
<update id="updateBookByCondition">
UPDATE t_books
<trim prefix="SET" suffixOverrides=","> <!-- 增加SET前缀,自动忽略后缀 -->
<if test="name != null">name = #{name} ,</if>
<if test="author != null">author = #{author} ,</if>
<if test="publish != null">publish = #{publish} </if>
<if test="sort != null">sort = #{sort}</if>
</trim>
WHERE id = #{id}
</update>
5,foreach
<delete id="deleteBookByIds">
DELETE FROM t_books
WHERE id IN
<foreach collection="list" open="(" separator="," close=")" item="id" index="i">
#{id}
</foreach>
</delete>
<insert id="insertOrdersDetail">
insert into orders_detail (pid,oid,num,money) values
<foreach collection="ordersDetails" item="ordersDetail" separator=",">
(#{ordersDetail.pId},#{ordersDetail.oId},#{ordersDetail.num},#{ordersDetail.money})
</foreach>
</insert>
六,缓存
概念
内存中的一块存储空间,服务于某个应用程序,旨在将频繁读取的数据临时保存在内存中,便于二次快速访问。
无缓存:用户在访问相同数据时,需要发起多次对数据库的直接访问,导致产生大量IO、读写硬盘的操作,效率低下
有缓存:首次访问时,查询数据库,将数据存储到缓存中;再次访问时,直接访问缓存,减少IO、硬盘读写次数、提高效率
1 ,一级缓存
SqlSession级别的缓存,同一个SqlSession的发起多次同构查询,会将数据保存在一级缓存中。
注意:无需任何配置,默认开启一级缓存。
2 ,二级缓存
SqlSessionFactory级别的缓存,同一个SqlSessionFactory构建的SqlSession发起的多次同构查询,会将数据保存在二级缓存中。
注意:在sqlSession.commit()或者sqlSession.close()之后生效。
3, 指定Mapper缓存
在指定表对应的mapper文件的sql语句前添加
<cache />
4,全局缓存
mabatis配置文件中
<configuration>
<properties .../>
<!-- 注意书写位置 -->
<settings>
<!--打印日志信息-->
<setting name="logImpl" value="org.apache.ibatis.logging.stdout.StdOutImpl"/>
<!--打印sql-->
<setting name="mapUnderscoreToCamelCase" value="true"/>
<!-- mybaits-config.xml中开启全局缓存(默认开启) -->
<setting name="cacheEnabled" value="true"/>
</settings>
<typeAliases></typeAliases>
</configuration>
七,Mybatis延迟加载的实现方式
1、概念:
MyBatis中的延迟加载,也叫懒加载,是指在进行表的关联查询时,按照设置的延迟规则推迟对关联对象的select查询。例如在进行一对多查询的时候,只查询出一方,当程序中需要多方的数据时,mybatis再发出sql语句进行查询,这样子延迟加载就可以的减少数据库压力。MyBatis 的延迟加载只是对关联对象的查询有迟延设置,对于主加载对象都是直接执行查询语句的。
2、加载时机:
直接加载:执行完对主加载对象的 select 语句,马上执行对关联对象的 select 查询。
侵入式延迟: 执行对主加载对象的查询时,不会执行对关联对象的查询。但当要访问主加载对象的详情属性时,就会马上执行关联对象的select查询。
深度延迟: 执行对主加载对象的查询时,不会执行对关联对象的查询。访问主加载对象的详情时也不会执行关联对象的select查询。只有当真正访问关联对象的详情时,才会执行对关联对象的 select 查询。
注意:延迟加载的应用要求:关联对象的查询与主加载对象的查询必须是分别进行的select语句,不能是使用多表连接所进行的select查询。因为,多表连接查询,实质是对一张表的查询,对由多个表连接后形成的一张表的查询。会一次性将多张表的所有信息查询出来。
侵入式延迟加载:
不调用主加载对象时只有一条SQL
调用主加载对象的信息时会产生两条SQL
<!--开启延迟加载-->
<setting name="lazyLoadingEnabled" value="true"/>
<!--配置侵入式延迟加载 默认为false(深度加载)
侵入式:默认只会执行主加载SQL,那么当访问主加载对象的详细信息时才会执行关联对象的SQL查询
深度延迟:默认只执行主加载SQL,那么当调用到主加载对象中关联对象的信息时才会执行关联对象的SQL查询
-->
<setting name="aggressiveLazyLoading" value="true"/>
深入式延迟加载:
调用主加载对象时不会执行第二条加载SQL
调用关联对象详细信息时会执行第二次查询
<!--开启延迟加载-->
<setting name="lazyLoadingEnabled" value="true"/>
<!--配置侵入式延迟加载 默认为false(深度加载)
侵入式:默认只会执行主加载SQL,那么当访问主加载对象的详细信息时才会执行关联对象的SQL查询
深度延迟:默认只执行主加载SQL,那么当调用到主加载对象中关联对象的信息时才会执行关联对象的SQL查询
-->
<setting name="aggressiveLazyLoading" value="false"/>