MyBatis知识点汇总

框：具有约束性\t\t定义标准（多人开发，最终整合）

架：能够支撑某些东西\t\tSpring对java底层的封装

持久层框架

spring

整合型框架/设计型框架

框架：具有约束性的去支持我们完成各种功能的半成品项目（框架+业务逻辑 = 完整项目）

支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架

几乎所有的 JDBC 代码（对JDBC进行封装）

不需要设置通配符，用${value}、#{}

手动设置参数

获取结果集

避免了

推荐

SQL语句写在XML中，方便更改业务需求

XML

上线部署过程对java进行打包，如果也业务需求变更，不易更改

SQL语句需要放在类中

注解方式

以使用简单的 XML 或 注解 用于配置和原始映射

Object：Java对象

Mysql为关系型数据库

Relation：关系型数据库中的一条记录

Plain Old Java Objects，普通的Java对象

将接口和POJO映射成数据库中的记录

两者创建映射关系

半自动的ORM（Object Relation Mapping）框架

处理结果

赋值后执行SQL语句

为通配符赋值

创建预编译对象

创建连接

加载驱动

手动完成过程：

开发效率最低

MyBatis需要对其封装，使用过程需要解析

执行效率最高

JDBC

长难复杂SQL，处理不易

对自动生成的SQL语句不易优化

开发效率最快，执行效率最低

Hibernate

开发容易

SQL语句手动优化

一个专注业务，一个专注数据

功能分界清晰

SQL和java编码分离

解耦

MyBatis

为什么要使用MyBatis – 现有持久化技术的对比

简介

mysql-connector-java建议与mysql版本一致，不一致可能无法连接

log4j（log4j配置文件定义日志输出格式）、mybatis、mysql-connector-java

①导入jar

将下划线转换成驼峰命名法

例如：数据库字段user_name，实体类字段userName

配置之前

配置之后

<select id=\"getUserByUid\" resultType=\"org.xinzhang.mybatistest.bean.User\

<setting name=\"mapUnderscoreToCamelCase\" value=\"true\"/>

<settings>（常用）

<typeAliases>    <typeAlias alias=\"Page\" type=\"cn.ac.sict.common.persistence.Page\" /><!--分页 -->\t</typeAliases>

需要写满全称

只需填写类名

<select id=\"getUserByUid\" resultType=\"User\

<typeAliases>  <package name=\"org.xinzhang.mybatistest.bean\"/> </typeAliases>

为类型设置类型别名

<typeAliases>

设置默认数据库

default

设置某个具体的数据库的环境

数据库环境的唯一标示

id

可以多个<environment>

SqlSession sqlSession1 = sqlSessionFactory.openSession()

手动处理事务

SqlSession sqlSession = sqlSessionFactory.openSession(true);

自动处理事务

使用JDBC原生的事务管理方式，即提交和回滚都需要手动处理

操作数据库，增加一次，自增id无论成功与否都会自增

type=\"JDBC|MANAGED\"

<transactionManager type=\"JDBC\" />

数据源、声明事务均在Spring中配置

<environments>

引入映射文件

<mappers>

核心配置：如何连接数据库

②创建mybatis的核心（全局）配置文件mybatis-config.xml，并配置

定义查询语句

设置SQL语句的唯一标示

结果类型，即实体类的全限定名

resultType=\"Emp\"

查询所有数据，返回实体类类型，MyBatis自动选择容器

将返回结果自动放入相应容器中

resultType=\"Integer\"

resultType=\"java.util.HashMap\"

resultType

<select>标签

<mapper namespace=\"org.xinzhang.mybatistest.mapper.UserMapper\">

namespace指向java的DAO层的接口

<mapper>标签

映射文件：操作数据库

SQL语句写在映射文件中

③创建映射文件XxxMapper.xml，并配置

接口全限定名要和XML映射文件的namespace保持一致

返回结果是否成功

Boolean

返回操作影响了几行（常用）

Integer

增删改返回结果

CRUD增删改查接口

设置map的键，因为在查询时传出所有的员工信息，可以把员工信息作为值，但是必须设置键

结果

@MapKey(\"eid\

接口中方法名和SQL语句的id保持一致

④创建mapper接口（面向接口编程），实现两个绑定（调用接口中的方法执行SQL语句）

⑤获取mybatis操作数据库的会话对象SqlSession，通过getMapper()获取接口的动态代理实现类

⑥测试

MyBatis搭建过程

<delete id=\"deleteMoreEmp\">\t\tdelete from emp where eid in (${value})\t</delete>

批量删除

模糊查询

使用场景

只能用字符串拼接（注意要加单引号问题）

可以使用自动生成的主键

useGeneratedKeys

将自动生成的主键赋值给传递过来的参数的哪一个属性

keyProperty

<insert id=\"insertEmp\" useGeneratedKeys=\"true\" keyProperty=\"eid\

适用于一对多，多对一等场景

需求：主键自增，添加数据的同时获取数据的id

Statement对象来处理SQL语句，拼接，控制台直接显示输入的值

${value}

可以防止SQL注入

自动加入单引号

创建Preparestatement预编译对象，显示通配符？问号

#{}

单引号问题

大括号内只能写value或_parameter获取

大括号内可以写任意值

传输参数为单个String或基本数据类型和其包装类

'${ename}'

#{ename}

都可以通过属性名直接获取值

当传输参数为javaBean时

param1、param2……

键

0、1、2……

获取参数异常

BindingException

当传输多个参数时，MyBatis默认将这些参数放入Map集合中

注意${}的单引号问题

两种都可以通过键的名字直接获取值

当传输Map参数时

<select id=\"getEmpByEidAndEnameByParam\" resultType=\"Emp\

Emp getEmpByEidAndEnameByParam(@Param(\"eid\

List<Integer> eids = new ArrayList<>();\t\teids.add(7);\t\teids.add(8);\t\teids.add(10);\t\tmapper.deleteMoreByList(eids);

测试

<delete id=\"deleteMoreByList\">\t\tdelete from emp where eid in \t\t<foreach collection=\"font color=\

void deleteMoreByList(font color=\

（建议）命名参数：自定义键值

<delete id=\"deleteMoreByList\">\t\tdelete from emp where eid in \t\t<foreach collection=\"list\" item=\"eid\" separator=\

void deleteMoreByList(List<Integer> eids);

List以list为键

Array以array为键

当传输参数为List或Array，MyBatis会将List或Array放到map中（动态SQL语句）

不同参数类型，两者不同的取值方式

区别

MyBatis获取参数的两种方式

条件不匹配（有空值）造成数据丢失

以左张表为标准

左外连接

select * from emp e left join dept d on e.did = d.did;

SQL语句实现（两表联查）

column对应数据库字段

property对应实体类属性

设置主键的映射关系

设置其他映射，不能省略

result

返回类型，实体类型

type

<resultMap>

resultMap属性填<resultMap>中的id

select

<mapper namespace=\"org.xinzhang.mybatistest.mapper.EmpDeptMapper\"> <resultMap type=\"Emp\" id=\"empMap\"> <id column=\"eid\" property=\"eid\"/> <result column=\"ename\" property=\"ename\"/> <result column=\"age\" property=\"age\"/> <result column=\"sex\" property=\"sex\"/> <result column=\"did\" property=\"dept.did\"/> <result column=\"dname\" property=\"dept.dname\"/>（方案二代码替换此处） </resultMap> <select id=\"getAllEmp\" resultMap=\"empMap\

方案一（很少使用）

不能确定property中具体是什么属性

需要使用javaType属性

解决多对一的表对应关系

帮忙创建对象，javaType所写类型对象，底层：大量反射（无反射无框架）

创建对象后再赋值给dept属性

把查询出来的结果赋值给Dept中did和dname

did，dname均为Dept中属性

<association>

<association property=\"dept\" javaType=\"Dept\"> <id column=\"did\" property=\"did\"/> <result column=\"dname\" property=\"dname\"/> </association>

方案二

<mapper namespace=\"org.xinzhang.mybatistest.mapper.DeptMapper\"> <select id=\"getDeptByDid\" resultType=\"Dept\

通过查询语句得到结果为property的dept赋值

接口需要加入全限定命名（namespace）确定为唯一标识

此条件必须为数据库查询而得

要把哪个字段作为分步查询的条件

column

<resultMap id=\"EmpMapStep\" type=\"Emp\"> <id column=\"eid\" property=\"eid\"/> <result column=\"ename\" property=\"ename\"/> <result column=\"age\" property=\"age\"/> <result column=\"sex\" property=\"sex\"/> <association property=\"dept\" select=\"org.xinzhang.mybatistest.mapper.DeptMapper.getDeptByDid\" column=\"did\"/> </resultMap> <select id=\"getEmpStep\" resultMap=\"EmpMapStep\

查询员工所有信息，包括员工的部门id通过部门id查询部门名称，而非一步查询出所有信息

方案三：常用分步查询（避免两表联查）

映射关系不匹配，解决：自定义映射关系

实现：查询员工的信息（包含部门信息）多个员工对应一个部门，多对一关系

因为返回结果是多个员工，多条数据

不能使用resultType=\"Dept\"

不会关注返回的是否是集合类型即，不适用javaType

标记集合中一条数据的类型

使用ofType

使用collection标签(处理一对多，多对一)

<resultMap id=\"deptMap\" type=\"Dept\"> <id column=\"did\" property=\"did\"/> <result column=\"dname\" property=\"dname\"/> <collection property=\"emps\" ofType=\"Emp\"> <id column=\"eid\" property=\"eid\"/> <result column=\"ename\" property=\"ename\"/> <result column=\"age\" property=\"age\"/> <result column=\"sex\" property=\"sex\"/> </collection> </resultMap>

java接口：Dept getDeptEmpsByDid(String did);xml配置映射文件：<select id=\"getDeptEmpsByDid\" resultMap=\"deptMap\

全局配置为延迟加载，某一个部分SQL设置全局加载（渴望）

fetchType=\"eager\"

id为键，要与#{id}中名字对应

可以设置map键值对

column=\"{id=did}}\"

查询结果返回多个用collection

emps为Dept实体类中的属性

<select id=\"getEmpsListByDid\" resultType=\"Emp\

java接口文件//根据did 查部门信息 Dept getOnlyDeptByDid(String did); //根据did 查所有员工信息 List<Emp> getEmpsListByDid(String did);

分步实现方式

实现：查询某个部门中包含所有的员工的信息一个部门可以有多个员工，一对多的关系

Emp多、Dept一两张表（多对一，一对多）

只对分步查询有效

分步查询均加载（控制台可看日志）

是否开启延迟加载，默认为false

之后的分表查询不加载

Emp empStep = mapper.getEmpStep(\"13\"); System.out.println(empStep.getEname());

侵入式延迟加载

之后的分表查询会加载

开启：true

<setting name=\"aggressiveLazyLoading\" value=\"true\"/>

<setting name=\"lazyLoadingEnabled\" value=\"true\"/>

说说MyBatis的延迟加载

服务器默认值会影响查询结果

没有设置条件一定不能加

页面中设置条件，才需要加入SQL语句中

没有空字符串的情况

要么有值，要么null

单选框复选框

多条件查询

通过test表达式，拼接SQL

<if test=\"\"></if>

地址栏输入未给某个属性赋值

null

空字符串，在表单中未添加信息

“”

输入框

<if test=\"taskModel != null and taskModel != ''\">\t\t\t\tAND a.task_model = #{taskModel}\t\t\t</if>

<if>

添加where关键字，同时去掉多余的and

<where>

截取并拼接

在操作的SQL语句前加入某些内容

prefix

在操作的SQL语句后加入某些内容

suffix

把操作的SQL语句前的某些内容去掉

prefixOverrides

把操作的SQL语句后的某些内容去掉

suffixOverrides

<trim prefix=\"\" suffix=\"\" prefixOverrides=\"\" suffixOverrides=\"\">

类似if/if/else

<choose>：选择某一个when或otherwise拼接SQL\t\t\t<when test=\"\"></when>：通过test表达式拼接SQL\t\t\t<otherwise></otherwise>：当when都不符合条件，就会选择otherwise拼接SQL\t\t</choose>

指定要遍历的集合或数组

collection

设置别名

item

设置循环体的开始内容

open

设置循环体的结束内容

close

设置每一次循环之间的分隔符

separator

若遍历的是list，index代表下标

若遍历的是map，index代表键

index

对一个数组或集合进行遍历

<foreach collection=\"\" item=\"\" close=\"\" open=\"\" separator=\"\" index=\"\"></foreach>

delete from emp where eid in ();

delete from emp where eid = 1 or eid = 2 or eid = 3

delete

select * from emp where eid in ();

select * from emp where eid = 1 or eid = 2 or eid = 3

单条数据

update emp  set ... where eid in ();

update emp set ... where eid = 1 or eid = 2 or eid = 3

把每条数据修改为相同内容

必须在配置文件的连接地址（url）后添加参数&allowMultiQueries=true

预编译过程只允许一条SQL语句

update emp set ... where eid = 1;\t\t\tupdate emp set ... where eid = 2;\t\t\tupdate emp set ... where eid = 3;

把每条数据修改为对应内容

update

insert

批量操作

设置一段SQL片段，即公共SQL，可以被当前映射文件中所有的SQL语句所访问

<sql id=\"\"></sql>

访问某个SQL片段

<include refid=\"empColumns\"></include>

sql

动态SQL语句(更好拼接SQL语句)

缓存服务器

Redis缓存

相对：存储在内存读取速度更快

MySQL数据存储在硬盘

同一个SqlSession，对于一个sql语句，执行之后就会存储在缓存中，下次执行相同的sql，直接从缓存中取

SqlSession级别

key: hashCode+查询的SqlId+编写的sql查询语句+参数

同一次会话期间（SqlSession）只要查询过的数据都会保存在当前SqlSession的一个Map中

一级缓存工作机制

System.out.println(\"----------不同sqlSession的情况-----------\"); SqlSession sqlSession2 = sqlSessionFactory.openSession(true); EmpMapper mapper2 = sqlSession2.getMapper(EmpMapper.class); Emp emp2 = mapper2.getEmpByEid(\"13\"); System.out.println(emp2);

SqlSessionFactory sqlSessionFactory = getSqlSessionFactory(); SqlSession sqlSession = sqlSessionFactory.openSession(true); SelectByConditions mapper = sqlSession.getMapper(SelectByConditions.class);Emp emp = mapper.selectTestCache(\"13\"); System.out.println(emp);

不同的SQLSession执行相同的查询语句

System.out.println(\"---------查询条件不同时------------\"); Emp emp2 = mapper.selectTestCache(\"14\"); System.out.println(emp2);

同一个SqlSession但是查询条件不同

同一个SqlSession两次查询期间执行了任何一次增删改操作，会自动将缓存清空

只用来清除一级缓存

sqlSession1.clearCache();

同时清空一级缓存和二级缓存

增删改默认flushCache=\"true\"

查询flushCache默认false

在XML某个<select>标签中配置flushCache=\"true\"

同一个SqlSession两次查询期间手动清空了缓存

一级缓存失效情况

默认开启

一级缓存

二级缓存存在于 SqlSessionFactory 生命周期中

一级缓存一直是打开的

<settings> <!--全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存。 --> <setting name=\"cacheEnabled\" value=\"true\"/></settings>

在核心配置文件myBatis-config.xml中开启二级缓存总开关

默认不开启

最近最少使用的：移除最长时间不被使用的对象

LRU(默认)

先进先出：按对象进入缓存的顺序来移除它们

FIFO

软引用：移除基于垃圾回收器状态和软引用规则的对象

SOFT

弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象

WEAK

缓存回收策略

eviction

默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新

刷新间隔，单位毫秒

flushInterval

代表缓存最多可以存储多少个对象，太大容易导致内存溢出

引用数目，正整数

size

只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势

true

读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是 false

false

readOnly

<cache />

配置这个select是否使用二级缓存。一级缓存一直是使用的

二级缓存开启的情况下，控制当前某一个select不开启二级缓存

select标签的useCache属性

在Mapper.xml映射文件中，开启二级缓存分开关

二级缓存的数据不一定都存储到内存，它的存储介质多种多样，所以需要给缓存的对象执行序列化缓存默认是存入内存中，但是如果需要把缓存对象存入硬盘需要序列化(实体类要实现)

POJO需要实现Serializable接口

使用步骤

二级缓存

EhCache 是纯Java的进程内缓存框架，具有快速、精干特点

提高扩展性，定义缓存接口Cache，通过实现Cache接口来自定义二级缓存

通过序列化接口实现

内存中放不下，放入到磁盘中

ehcache-core-2.6.8.jar

mybatis-ehcache-1.0.3.jar

slf4j-api-1.6.1.jar、slf4j-log4j12-1.6.2.jar

①导入ehcache包

②ehcache.xml配置文件

<cache type=\"org.mybatis.caches.ehcache.EhcacheCache\"></cache>

③配置cache标签

整合EhCache缓存的步骤

常用第三方缓存（EhCache、Redis）

说说MyBatis的缓存机制

可以快速的根据表生成对应的映射文件，接口，以及bean类

支持基本的增删改查，以及QBC风格的条件查询

表连接、存储过程等复杂sql的定义需要手工编写

代码生成器

类似MongoDB非关系型数据库（QBC风格）

Criteria c1 = example.createCriteria();

条件语句

案例：WMS如何自动生成七个文件

MyBatis逆向工程（MyBatis Generator，MBG）

<plugins>\t\t<plugin interceptor=\"cn.ac.sict.common.persistence.interceptor.PaginationInterceptor\" /> </plugins>

mybatis-config.xml中插件配置

分页类@author ThinkGem@version 2013-7-2@param <T>

/wms/wms-system/src/main/java/cn/ac/sict/common/persistence/Page.java

拓展：分页插件

整合Spring与SpringMVC

利用好Spring功能

Spring功能：IOC、AOP

优势：创建对象为单例，管理对象生命周期

SqlSessionFactory

MyBatis操作数据库的数据源交给Spring

声明事务

MyBatis对象均交给Spring来管理

IOC管理对象

将MyBatis对象进行封装方便Spring来管理

MyBatis-Spring适配包

整合Spring与MyBatis

SpringMVC控制层+MyBatis持久层，两者不会相互影响

Spring

SpringMVC

log4j、pageHelper、AspectJ、jackson、jstl

第三方支持

<!-- springMVC核心控制器DispatcherServlet --> <servlet> \t<servlet-name>DispatcherServlet</servlet-name> \t<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> \t<init-param> \t\t<param-name>contextConfigLocation</param-name> \t\t<param-value>classpath:springMVC.xml</param-value> \t</init-param> \t<load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> \t<servlet-name>DispatcherServlet</servlet-name> \t<url-pattern>/</url-pattern> </servlet-mapping>

DispatcherServlet

<!-- REST请求方式处理 --> <filter> \t<filter-name>HiddenHttpMethodFilter</filter-name> \t<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class> </filter> <filter-mapping> \t<filter-name>HiddenHttpMethodFilter</filter-name> \t<url-pattern>/*</url-pattern> </filter-mapping>

HiddenHttpMethodFilter

<!-- spring编码过滤器 --> <filter> \t<filter-name>CharacterEncodingFilter</filter-name> \t<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> \t<init-param> \t\t<param-name>encoding</param-name> \t\t<param-value>UTF-8</param-value> \t</init-param> </filter> <filter-mapping> \t<filter-name>CharacterEncodingFilter</filter-name> \t<url-pattern>/*</url-pattern> </filter-mapping>

CharacterEncodingFilter

web.xml

<!-- 扫描控制层组件 -->\t<context:component-scan base-package=\"org.xinzhang.ssm.controller\"></context:component-scan>

扫描控制层组件

<!-- 配置视图解析器 -->\t<bean class=\"org.springframework.web.servlet.view.InternalResourceViewResolver\">\t\t<property name=\"prefix\" value=\"/WEB-INF/view/\"></property>\t\t<property name=\"suffix\" value=\".jsp\"></property>\t</bean>

视图解析器

<!-- 默认的servlet -->\t<mvc:default-servlet-handler/>

Default Servlet

<!-- MVC驱动 -->\t<mvc:annotation-driven />

MVC驱动

MultipartResolver

拦截器

可选

springMVC.xml

②搭建SpringMVC

 <!-- 配置spring监听器 --> <listener> \t<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener>

ContextLoaderListener

<!-- 自定义spring配置文件的位置和名称 --> <context-param> \t<param-name>contextConfigLocation</param-name> \t<param-value>classpath:spring.xml</param-value> </context-param>

context-param

<!-- 扫描组件 -->\t<context:component-scan base-package=\"org.xinzhang.ssm\" >\t\t<context:exclude-filter type=\"annotation\" expression=\"org.springframework.stereotype.Controller\"/>\t</context:component-scan>

扫描组件（排除控制层）

spring.xml

③整合SpringMVC和Spring

<settings>\t\t<!-- 将下划线映射成驼峰，user_name映射为userName -->\t\t<setting name=\"mapUnderscoreToCamelCase\" value=\"true\"/>\t\t<!-- 开启延迟加载 -->\t\t<setting name=\"lazyLoadingEnabled\" value=\"true\"/>\t\t<!-- 是否开启深度延迟加载false开启-->\t\t<setting name=\"aggressiveLazyLoading\" value=\"false\"/>\t\t<!-- 是否开启二级缓存 -->\t\t<setting name=\"cacheEnabled\" value=\"true\"/>\t</settings>

<!-- 插件配置 -->\t<plugins>\t\t<plugin interceptor=\"cn.ac.sict.common.persistence.interceptor.PaginationInterceptor\" /> </plugins>

核心配置文件

mapper接口和mapper映射文件

④搭建MyBatis

<!-- 引入资源文件 -->\t<context:property-placeholder location=\"classpath:jdbc.properties\"/>

properties文件的引入

<!-- 数据源 -->\t<bean id=\"dataSource\" class=\"com.alibaba.druid.pool.DruidDataSource\">\t\t<property name=\"driverClassName\" value=\"${jdbc.driver}\"></property>\t\t<property name=\"url\" value=\"${jdbc.url}\"></property>\t\t<property name=\"username\" value=\"${jdbc.username}\"></property>\t\t<property name=\"password\" value=\"${jdbc.password}\"></property>\t</bean>

DataSource数据源的配置

<!-- 声明事务管理器 -->\t<bean id=\"transactionManager\" class=\"org.springframework.jdbc.datasource.DataSourceTransactionManager\">\t\t<property name=\"dataSource\" ref=\"dataSource\"></property>\t</bean>

事务管理器

<!-- 开启事务注解驱动 -->\t<tx:annotation-driven transaction-manager=\"transactionManager\"/>

开启事务驱动

返回SqlSessionFactory对象来创建SqlSession

工厂模式getObject()

通过MyBatis配置文件完成

SqlSession操作数据库需要数据源

以点分割

以斜杠分割

注意package和Location

<!-- 管理mybatis操作数据库的会话对象SqlSession -->\t<bean class=\"org.mybatis.spring.SqlSessionFactoryBean\">\t\t<!-- 设置mybatis核心配置文件的路径 -->\t\t<property name=\"configLocation\" value=\"classpath:mybatis-config.xml\"></property>\t\t<!-- 设置数据源 -->\t\t<property name=\"dataSource\" ref=\"dataSource\"></property> \t\t<!-- 设置类型别名 -->\t\t<property name=\"typeAliasesPackage\" value=\"org.xinzhang.ssm.bean\"></property>\t\t<!-- 设置映射文件的路径 -->\t\t<property name=\"mapperLocations\" value=\"classpath:org/xinzhang/ssm/mapper/*.xml\"></property>\t</bean>

管理SqlSession

SqlSessionFactoryBean

@Autowired\tprivate EmpMapper empMapper;

<!-- 在所设置的包下，将所有的接口生成动态代理实现类，并由spring容器管理 -->\t<bean class=\"org.mybatis.spring.mapper.MapperScannerConfigurer\">\t\t<property name=\"basePackage\" value=\"org.xinzhang.ssm.mapper\"></property>\t</bean>

MapperScannerConfigurer

Spring.xml

⑤Spring整合Mybatis

SSM整合步骤

SSM框架整合

博客地址