mybatis详解(全)
持久层技术解决方案有几种?
mybatis持久层框架
测试用例搭建
mybatis主配置文件
mybatis映射文件
mybatis动态SQL
mybatis分页
mybatis逆向工程
持久层技术解决方案有几种?
1.JDBC技术–>Connection、PreparedStatement、ResultSet
2.Spring的JdbcTemplate–>Spring中对Jdbc的简单封装
3.Apache的DBUtils–>它和Spring的JdbcTemplate很像，也是对Jdbc的简单封装
以上这些都不是框架(JDBC是规范、Spring的JdbcTemplate和Apache的DBUtils都只是工具类)
mybatis持久层框架
mybatis是一个用Java编写的持久层框架，它使用ORM实现了结果集的封装。
ORM是Object Relational Mapping 对象关系映射。简单来说，就是把数据库表和实体类及实体类的属性对应起来，让开发者操作实体类就实现操作数据库表。
它封装了jdbc操作的很多细节，使开发者只需要关注sql语句本身，而无需关注注册驱动，创建连接等烦杂过程
测试用例搭建
搭建环境流程如下四点：
-
创建maven工程并导入坐标
<dependencies> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.4.5</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.43</version> </dependency> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.12</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.10</version> </dependency> </dependencies> -
创建实体类和Mapper的接口
public class User implements Serializable { private int id ; private String username; ...... }public interface IUserMapper { /** * 查询所有操作 * @return */ List<User> findAll(); } -
创建mybatis的主配置文件
<configuration> <environments default="mysql"> <environment id="mysql"> <transactionManager type="JDBC">transactionManager> <dataSource type="POOLED"> <property name="driver" value="com.mysql.jdbc.Driver" /> <property name="url" value="jdbc:mysql://localhost:3306/db1" /> <property name="username" value="root" /> <property name="password" value="root" /> dataSource> environment> environments> <mappers> <mapper resource="Mybatis/IuserMapper.xml" /> mappers> configuration> -
创建映射配置文件
<mapper namespace="com.Mapper.IUserMapper" > <select id="findAll" resultType="com.Pojo.User" > select * from usr select> mapper>测试方法
...... InputStream in = Resources.getResourceAsStream("mybatis/MapperConfig.xml"); //创建SqlSessionFactory工厂 SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); SqlSessionFactory factory = builder.build(in); //使用工厂生产SqlSession对象 SqlSession session = factory.openSession(); //使用SqlSession创建Mapper接口的代理对象 UserMapper userMapper = session.getMapper(UserMapper.class); //使用代理对象执行方法 List<mybatis_user> users = userMapper.findAll(); for (mybatis_user muser : users){ System.out.println(muser); } session.close(); in.close(); ......
mybatis主配置文件
mybatis的配置文件推荐为命名mybatis-config.xml，其内容包含了会深深影响mybatis行为的设置和属性信息。以下是全配置文件列表：
使用者掌握方面有properties、settings、typeAliases、enveronments、mappers
具体各个配置内容如下：
-
properties 标签
开发者可通过properties属性来实现引用配置文件。这些属性都是可外部配置且可动态替换的
[注]
1.如果两个配置文件有同一个字段，优先使用外部配置文件的
2.可以直接引入外部配置文件，properties子元素中可以增加一些属性配置
-
typeAliases 标签
typeAliases类型别名是为java类型设置一个短的名字，存在的意义仅在于用来减少类完全限定名的冗余。java内置内建类型别名它们都不区分大小写，注意对基本类型名称重复采用的特殊命名风格。
别名 映射的类型 _byte byte _long long _int int _integer int _double double _float float _boolean boolean string String byte Byte long Long short Short int Integer Integer Integer double Double float Float boolean Boolean date Date object Object map Map hashmap HashMap list List arraylist ArrayList 
[注]
方法二中，每一个在包中的Java bean,在没有注解的情况下，会使用bean的首字母小写的非限定类名来作为它的别名。若有注解，则别名为其注解值。(实体类上使用注解:@Alias(“user”)) -
setting 标签
setting设置标签，这是Mybatis中极为重要的调整设置，它们会改变Mybatis的运行时行为
-
dataSource 标签
我们在实际开发中都会使用连接池，因为它可以减少我们获取连接所消耗的时间，在mybatis中连接池提供了3种方式的配置
[注]主配置文件的dataSource标签，type属性就是表达采用何种连接池方式1）POOLED 方式
*采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现
[注]观察出POOLED它是从池中获取一个连接来用2）UNPOOLED 方式
*采用传统的获取连接的方式，虽然也实现javax.sql.DataSource接口，但是并没有使用连接池技术
[注]UNPOOLED每次创建一个新的连接来用
3）JNDI 方式
*采用服务器提供的JNDI技术实现，来获取DataSource对象，不同的服务器所能拿到DataSource是不一样的
[注]如果不是web或者maven的war工程，是不能使用的
-
mappers 属性
mappers映射器属性，MapperRegistry:注册绑定我们的Mapper文件。有三种方式如下：
<mappers> <mapper resource="com/ferao/mapper/UserMapper.xml"/> mappers>或
<mappers> <mapper class="com.ferao.mapper.UserMapper" /> mappers>[注]
使用class文件绑定注册,接口和它的Mapper配置文件必须同名且接口且它的Mapper配置文件必须在同一个包下或
<mappers> <package name="com.ferao.mapper">package> mappers>[注]
扫描包进行注入绑定方式,接口和它的Mapper配置文件必须同名且接口和它的Mapper配置文件必须在同一个包下
mybatis映射文件
传递多个参数的方式
parameterType（输入类型）
resultType（输出类型）
resultMap（映射实体类）
传递参数的方式
在mapper中传递多个参数的方式有四种：顺序传递法、@Param注解传参法、Map传参法、Java Bean传参法；
方法1：顺序传参法
xxMapper.java
public User selectUser(String name, int deptId);
xxMapper.xml
<select id="selectUser" resultMap="UserResultMap">
select * from user
where user_name = #{0} and dept_id = #{1}
select>
#{}里面的数字代表传入参数的顺序。这种方法不建议使用，sql层表达不直观，且一旦顺序调整容易出错。
方法2：@Param注解传参法
xxMapper.java
public User selectUser(@Param("userName") String name, int @Param("deptId") deptId);
xxMapper.xml
<select id="selectUser" resultMap="UserResultMap">
select * from user
where user_name = #{userName} and dept_id = #{deptId}
select>
#{}里面的名称对应的是注解@Param括号里面修饰的名称。这种方法在参数不多的情况还是比较直观的，（推荐使用）。
方法3：Map传参法
xxMapper.java
public User selectUser(Map<String, Object> params);
xxMapper.xml
<select id="selectUser" parameterType="java.util.Map" resultMap="UserResultMap">
select * from user
where user_name = #{userName} and dept_id = #{deptId}
select>
#{}里面的名称对应的是Map里面的key名称。这种方法适合传递多个参数，且参数易变能灵活传递的情况。
方法4：Java Bean传参法
xxMapper.java
public User selectUser(User user);
xxMapper.xml
<select id="selectUser" parameterType="com.jourwon.pojo.User" resultMap="UserResultMap">
select * from user
where user_name = #{userName} and dept_id = #{deptId}
select>
#{}里面的名称对应的是User类里面的成员属性。这种方法直观，需要建一个实体类，扩展不容易，需要加属性，但代码可读性强，业务逻辑处理方便，推荐使用。（推荐使用）。
parameterType（输入类型）
**Mapper.java 可向 **Mapper.xml中输入三种类型：
① 简单类型
② pojo对象类型
mybaits使用OGNL表达式解析对象字段的值，#{}或者${}括号中的值为pojo属性名称
[注]OGNL表达式：object Graphic Navigation Language (对象图导航语言)，它是通过对象的取值方法来获取数据。在写法上把gat给省略了。比如：我们获取用户的名称类中的写法：user.getUsername();
OGNL表达式写法：user.username
那么，mybatis中为什么能直接写username,而不用user呢？因为在parameterType中已经提供了属性所属的类，所以此时不需要写对象名
③ pojo包装对象
开发中通过pojo传递查询条件，查询条件是综合的查询条件，不仅包括用户查询条件还包括其他的查询条件（比如将用户购买商品消息也作为查询条件），这时可以使用包装对象传递输入pojo类参数中包含pojo
resultType（输出类型）
可输出的类型有四种：返回一般数据类型(单条)、JavaBean 类型(单条)、List类型(多条)、Map类型
① 一般数据类型(单条)
比如要根据Id属性获得数据库中的某个字段值，示例：
//**Mapper.java
String getStuNameById(Integer id);
<select id="getStuNameById" resultType="string">
select username from t_student where id = #{id}
select>
② JavaBean 类型(单条)
比如根据某个字段获得数据库中的信息，把查询的结果信息封装成某个javaBean类型的数据，示例：
//**Mapper.java
Student getStuById(Integer id);
<select id="getStuById" resultType="student">
select * from t_student where id = #{id}
select>
③ List类型(多条)
有时候开发者查询的数据不止一条，比如，模糊查询，全表查询等，这时候返回的数据可能不止一条数据，对于多数据的处理可以存放在List集合中，示例：
//**Mapper.java
List<Student> getAllStus();
<select id="getAllStus" resultType="student">
select * from t_student
select>
④ Map类型
mybatis支持将查询的数据封装成Map，如果查询的结果是一条，开发者可以把查询的数据以(表字段名，对应的值)方式存入到map中，示例：
//**Mapper.java
Map<String, Object> getStuAsMapById(Integer id);
<select id="getStuAsMapById" resultType="map">
select * from t_student where id = #{id}
select>
如果查询的结果是多条数据，我们也可以把查询的数据以{表中某一字段名, JavaBean}方式来封装成Map
①mapper(dao)接口
// 查询所有学生的信息，把数据库中的 'id' 字段作为 key,对应的 value 封装成 Student 对象
// @MapKey 中的值表示用数据库中的哪个字段名作 key
@MapKey("id")
Map<Integer, Student> getAllStusAsMap();
②Mapper.xml 映射文件
<select id="getAllStusAsMap" resultType="student">
select * from t_student
select>
返回map集合时返回的类型是List
①mapper(dao)接口
List<Map<String, Object>> getAllStuAsMapById(Integer id);
②Mapper.xml 映射文件
<select id="getAllStuAsMapById" parameterType="int" resultType="map">
select * from usr
select>
resultMap（映射实体类）
实体类属性名和表中字段名不一样时，无法映射到值，输出为Null。
这是因为mybatis会根据这些从数据库中查询到的列名，将列名转化为小写(数据库不区分大小写)去对应实体类中查询相应列名的set方法设值，由于找不到setUserName()，所以会返回Null值。
解决方案有两种：
第1种：通过在查询的SQL语句中定义字段名的别名，让字段名的别名和实体类的属性名一致。
<select id="getOrder" parameterType="int" resultType="com.jourwon.pojo.Order">
select order_id id, order_no orderno ,order_price price form orders where order_id=#{id};
select>
第2种：通过resultMap 中的
<select id="getOrder" parameterType="int" resultMap="orderResultMap">
select * from orders where order_id=#{id}
select>
<resultMap type="com.jourwon.pojo.Order" id="orderResultMap">
<!–用id属性来映射主键字段–>
<id property="id" column="order_id">
<!–用result属性来映射非主键字段，property为实体类属性名，column为数据库表中的属性–>
<result property ="orderno" column ="order_no"/>
<result property="price" column="order_price" />
reslutMap>
resultMap 属性全内容如下：
<resultMap id="" type="">
<id column="" jdbcType="" property="" />
<result column="" jdbcType="" property=""/>
<association property="" javaType="">
<id column="" jdbcType="" property=""/>
<result column="" jdbcType="" property=""/>
association>
<collection property="pojo的集合属性" ofType="集合中的pojo对象">
<id column="集合中pojo对象对应的表的主键字段" jdbcType="字段类型" property="集合中pojo对象的主键属性" />
<result column="可以为任意表的字段" jdbcType="字段类型" property="集合中的pojo对象的属性" />
collection>
resultMap>
接下来对各标签属性进行简单介绍：
1）resultMap 标签
type属性：指开发者需要映射到的类对象
id属性：表示reslutMap在select标签中使用时，id的名称
2）id标签
方案一 -->为列名指定别名，别名和Java实体类的属性名一致
<select id="findAll" resultType="user">
select id,username as usernames from usr ;
</select>
方案二 --> 使用结果集映射ResultMap [推荐]
<resultMap id="UserMap" type="User">
<!--id为主键-->
<id column="id" property="id" />
<!--column 是数据库表的名称，property是对应实体类的属性名-->
<result column="username" property="usernames" />
</resultMap>
<!--查询所有-->
<select id="findAll" resultMap="UserMap">
select id,username from usr ;
</select>
===========================标签描述====================================
-->
column --> 表的主键字段,或者可以为查询语句中的别名字段
jdbcType --> 字段类型
property --> 映射pojo对象的主键属性
result标签 --> 属性用于配置映射关系时使用
column --> 表的一个字段（可以为任意表的一个字段）
jdbcType --> 字段类型
property --> 映射到pojo对象的一个属性（须为type定义的pojo对象中的一个属性）
association标签 -->
property --> pojo的一个对象属性
javaType --> pojo关联的pojo对象
id标签-->
column --> 关联pojo对象对应表的主键字段
jdbcType --> 字段类型
property --> 关联pojo对象的主席属性
result标签 -->
column --> 任意表的字段
jdbcType --> 字段类型
property --> 关联pojo对象的属性
select -->表示所需要的哪个类的查询语句
column -->从resultMap中传过去用作查询参数
ofType -->集合属性中的对象(可以不写)
collection标签 -->
property --> 表示pojo类集合中的属性
select -->表示所需要的哪个类的查询语句
column -->从resultMap中传过去用作查询的参数
ofType -->集合属性中的对象(可以不写)
===========================标签细节====================================
id & result
示例
<id property="id" column="post_id"/>
<result property="subject" column="post_subject"/>
含义
这些是结果映射最基本的内容，id和result都将一个列的值映射到一个简单的数据类型
的属性或字段。这两者之间的唯一不同是，id表示的结果将是对象的标识属性，这些在
比较对象实例时用到，这样可以提高整体的性能，尤其是缓存和嵌套结果映射的时候
```
><font color=black size=3 face =宋体><span id = "dongtaisql" >mybatis动态SQL</span>
<font face = "宋体" size =2>动态sql根据不同的条件生成不同的sql语句.所谓的动态sql，本质还是sql语句，只是开发者可以在sql层面，去执行一个逻辑代码，现在编写一个mapper接口用于测试：
```java
List<User> queryUser(Map map);
mybatis动态SQL
-
if标签语句示例：
if标签会执行所有的if标签，并进行条件判断，满足的部分进行sql拼接
<select id="queryUser" parameterType="map" resultType="user"> select * from usr where 1=1 <if test="id != null" > and id =#{id} if> <if test="username != null" > and username = #{username} if> select> -
where标签语句示例：
动态拼接where(并且会智能的去掉第一个语句的and或者or)
<select id="queryUser" parameterType="map" resultType="user"> select * from usr <where> <if test="id != null" > id =#{id} if> <if test="username != null" > and username = #{username} if> where> select> -
choose,when,otherwise标签语句示例：
不会执行所有的when语句，遇到满足的条件，后面的when语句不会执行,otherwise可以不写
<select id="queryUser" parameterType="map" resultType="user"> select * from usr <where> <choose> <when test="id != null" > id =#{id} when> <when test="username != null" > and username = #{username} when> <otherwise> and id= 4 otherwise> choose> where> select> -
set 标签语句示例：
用于更新操作(并且会智能的去掉最后一个语句后面的逗号)
<update id="updatePwd"> update public."user" <set> <if test="name !=null">name=#{name},if> <if test="pwd !=null">pwd=#{pwd},if> set> <where> <choose> <when test="id!=null">id=#{id}when> <when test="name!=null">name=#{name}when> choose> where> update> -
foreach 标签语句示例：
collection 表示迭代集合的名称，可以使用@Param注解指定，如下所示 该参数为必选
item 表示本次迭代获取的元素，若collection为List、Set或者数组，则表示其中的元素； 若collection为map，则代表key-value的value，该参数为必选
open 表示该语句以什么开始，最常用的是左括弧’(’，注意:mybatis会将该字符拼接到整体的sql语句之前，并且只拼接一次，该参数为可选项
close 表示该语句以什么结束，最常用的是右括弧’)’，注意:mybatis会将该字符拼接到整体的sql语句之后，该参数为可选项
separator mybatis会在每次迭代后给sql语句append上separator属性指定的字符，该参数为可选项
index 在list、Set和数组中,index表示当前迭代的位置，在map中，index代指是元素的key，该参数是可选项。
<foreach collection="list" item="item" separator=","> （#{item}） foreach> <foreach collection="list" item="item" open="(" separator="," close=")"> #{item} foreach> -
sql片段标签语句示例：
在mapper.xml中有些sql片段，在多个sql语句中都有用，每个都写的话显得代码冗余，可以用到代码片段，将公共部分抽取出来
注意点：最好基于单表定义sql片段，并且sql片段中不要存在where标签，因为where标签会自动优化sql中的and和or<sql id="choose-when-id-name"> <choose> <when test="id!=null">id=#{id}when> <when test="name!=null">name=#{name}when> choose> sql> <update id="updatePwd"> update public."user" <set> <if test="name !=null">name=#{name},if> <if test="pwd !=null">pwd=#{pwd},if> set> <where> <include refid="choose-when-id-name">include> where> update> -
trim标签语句示例：
trim标记是一个格式化的标记，可以完成set或者是where标记的功能
①用 trim 改写上面的 if+where 语句
prefix：前缀
prefixoverride：去掉第一个and或者是or<select id="selectUserByUsernameAndSex" resultType="user" parameterType="com.harvey.java01.entity.User"> select * from user <trim prefix="where" prefixOverrides="and | or"> <if test="username != null"> and username=#{username} if> <if test="sex != null"> and sex=#{sex} if> trim> select>②用 trim 改写上面的 if+set 语句
suffix：后缀
suffixoverride：去掉最后一个逗号（也可以是其他的标记，就像是上面前缀中的and一样）<update id="updateUserById" parameterType="com.ys.po.User"> update user u <trim prefix="set" suffixOverrides=","> <if test="username != null and username != ''"> u.username = #{username}, if> <if test="sex != null and sex != ''"> u.sex = #{sex}, if> trim> where id=#{id} update>
mybatis分页
mybatis分页可以减少数据的处理量，分页的方式有两种：limit分页、PageHelper分页插件
limit分页方式
首先知道以下SQL语法：
#select * from user limit startIndex,pageSize;
select * from user limit 3; #[0,n]
开始编写Mapper.java:
List<User> getUserByLimit(Map<String,Integer> map);
编写Mapper.xml:
<select id="getUserByLimit" parameterType="map" resultType="user">
select * from usr limit #{startIndex},#{pageSize}
select>
编写测试Test:
Map<String,Integer> map = new HashMap();
map.put("startIndex",0);
map.put("pageSize",3);
List<User> userList = mapper.getUserByLimit(map);
PageHelper分页插件
引入依赖
<dependency>
<groupId>com.github.pagehelpergroupId>
<artifactId>pagehelperartifactId>
<version>4.0.0version>
dependency>
[注]由于使用了sql 解析工具，所以maven也引入了 jsqlparser.jar
mybatis-config.xml配置拦截器插件
<plugins>
<plugin interceptor="com.github.pagehelper.PageHelper">
<property name="dialect" value="mysql"/>
plugin>
plugins>
[注]配置拦截器时要知道新版拦截器是 com.github.pagehelper.PageInterceptor，而com.github.pagehelper.PageHelper 现在是一个特殊的 dialect 实现类，是分页插件的默认实现类，提供了和以前相同的用法。
设置数据库类型时有 Oracle,Mysql,MariaDB,SQLite,Hsqldb,PostgreSQL 六种数据库。
dialect默认情况下会使用 PageHelper 方式进行分页
-
PageHelper分页插件
测试方法
[注]
a.只有紧跟在PageHelper.startPage方法后的第一个Mybatis的查询（Select）方法会被分页
b.对于带有for update的sql，会抛出运行时异常，对于这样的sql建议手动分页，毕 竟这样的sql需要重视
c.分页插件不支持嵌套结果映射，由于嵌套结果方式会导致结果集被折叠，因此分页查询 的结果在折叠后总数会减少，所以无法保证分页结果数量正确。
mybatis逆向工程
MyBatis Generator(简称MBG)，如果实际开发中数据库的表特别多，那么我们需要手动去写每一张表的po类，xxxMapper.xml，xxxMapper.java文件，这显然需要花费巨大的精力，而且可能由于表字段太多，写错了而不知道也是可能的。
所以我们在实际开发中，一般使用逆向工程方式来自动生成所需的文件。
mybatis是目前很流行的持久层框架，其逆向工程更是大大缩减了我们的开发时间。所谓mybatis逆向工程，就是mybatis通过相应插件，根据我们设计好的数据表，针对单表自动生成pojo、mapper以及mapper.xml。
插件名称是mybatis-generator-core，获取可直接在https://mvnrepository.com/搜索 mybatis ,找到 MyBatis Generator Core
插件的使用流程如下：
-
添加maven依赖
<dependency> <groupId>org.mybatis.generatorgroupId> <artifactId>mybatis-generator-coreartifactId> <version>1.3.7version> dependency> -
新增generatorConfig.xml文件
a.连接数据库的配置，包括数据名称，数据库用户名密码等配置
b.指定要生成代码的包名，包括实体类po的包名，mapper的包名等
c.指定数据库中哪些表需要生成文件
DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd"> <generatorConfiguration> <context id="msqlTables" targetRuntime="MyBatis3"> <property name="javaFileEncoding" value="UTF-8"/> <property name="javaFormatter" value="org.mybatis.generator.api.dom.DefaultJavaFormatter"/> <property name="xmlFormatter" value="org.mybatis.generator.api.dom.DefaultXmlFormatter"/> <plugin type="org.mybatis.generator.plugins.SerializablePlugin">plugin> <plugin type="org.mybatis.generator.plugins.RenameExampleClassPlugin"> <property name="searchString" value="Example$"/> <property name="replaceString" value="Criteria"/> plugin> <commentGenerator> <property name="suppressAllComments" value="true"/> <property name="suppressDate" value="true"/> commentGenerator> <jdbcConnection connectionURL="jdbc:mysql://localhost:3306/db1?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true" driverClass="com.mysql.jdbc.Driver" password="root" userId="root" > <property name="nullCatalogMeansCurrent" value="true"/> <property name="useInformationSchema" value="true"/> <property name="remarks" value="true"/> jdbcConnection> <javaTypeResolver type="org.mybatis.generator.internal.types.JavaTypeResolverDefaultImpl"> <property name="forceBigDecimals" value="true" /> javaTypeResolver> <javaModelGenerator targetPackage="com.unfair.db.model" targetProject="src/main/java"> <property name="constructorBased" value="false"/> <property name="enableSubPackages" value="false"/> <property name="trimStrings" value="true" /> javaModelGenerator> <sqlMapGenerator targetPackage="com.unfair.db.mapper" targetProject="src/main/java"> <property name="enableSubPackages" value="false"/> sqlMapGenerator> <javaClientGenerator type="XMLMAPPER" targetPackage="com.unfair.db.dao" targetProject="src/main/java"> <property name="enableSubPackages" value="false"/> javaClientGenerator> <table tableName="usr" domainObjectName="User" enableCountByExample="true" enableUpdateByExample="true" enableDeleteByExample="true" enableSelectByExample="true" selectByExampleQueryId="true" > <property name="useActualColumnNames" value="false"/> table> context> generatorConfiguration>-
自定义生成的文件名字
含义 把 MyBatisGenerator 生成的 dao、model、mapper的文件 的后缀名进行更改 比如 ， dao文件 “BrandMapper.java” 改成 “BrandDao.java” 配置内容 <!-- 此处是将Example改名为Criteria 当然 想改成什么都行~ --> <plugin type="org.mybatis.generator.plugins.RenameExampleClassPlugin"> <property name="searchString" value="Example$" /> <!-- 替换后<property name="replaceString" value="Criteria" />--> <property name="replaceString" value="Query" /> </plugin> <!-- 此处是将UserMapper.xml改名为UserDao.xml 当然 想改成什么都行~ --> <plugin type="org.mybatis.generator.plugins.rename.RenameSqlMapperPlugin"> <property name="searchString" value="Mapper" /> <property name="replaceString" value="Dao" /> </plugin> <!-- 此处是将UserMapper改名为UserDao 接口 当然 想改成什么都行~ --> <plugin type="org.mybatis.generator.plugins.rename.RenameJavaMapperPlugin"> <property name="searchString" value="Mapper$" /> <property name="replaceString" value="Dao" /> </plugin> 注意点 RenameExampleClassPlugin、RenameSqlMapperPlugin、RenameJavaMapperPlugin 这三个插件中 RenameExampleClassPlugin这个插件是 org.mybatis.generator 自带的 ， 其他两个（RenameSqlMapperPlugin、RenameJavaMapperPlugin） 得根据 “RenameExampleClassPlugin” 这个例子自己写一下 ， 放到“src\main\java” 目录下。 -
执行generatorConfig.xml文件，生成代码
方式 【方式一】java代码 【方式二】安装插件 注意点 使用逆向工程时，最好新建一个工程，如果你在原来的工程中使用，那也可以， 但是有一定的风险，因为mybatis是根据配置文件中配置的路径来生成的文件的， 如果你工程中有相同名字的文件，那么就会被新生成的文件所覆盖。所以实际开发中， 我们一般新建一个工程，将生成的文件复制到自己的所需的工程中。-
【方式一】java代码
package com.etc.test; import org.mybatis.generator.api.MyBatisGenerator; import org.mybatis.generator.config.Configuration; import org.mybatis.generator.config.xml.ConfigurationParser; import org.mybatis.generator.internal.DefaultShellCallback; import java.io.File; import java.util.ArrayList; import java.util.List; public class GeneratorTest { public void testGenerator() throws Exception { List<String> warnings = new ArrayList<>(); boolean overwrite = true; //指定逆向工程配置文件 File configFile = new File(GeneratorTest.class.getResource("/generatorConfig.xml").getFile()); ConfigurationParser cp = new ConfigurationParser(warnings); Configuration config = cp.parseConfiguration(configFile); DefaultShellCallback callback = new DefaultShellCallback(overwrite); MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config,callback,warnings); myBatisGenerator.generate(null); } public static void main(String[] args) throws Exception { GeneratorTest generator = new GeneratorTest(); generator.testGenerator(); } }
-
【方式二】安装插件
<build> <plugins> <!-- 自动生成mybatis配置文件 --> <plugin> <groupId>org.mybatis.generator</groupId> <artifactId>mybatis-generator-maven-plugin</artifactId> <version>1.3.2</version> <dependencies> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>${mysql.version}</version> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>log4j-over-slf4j</artifactId> <version>1.7.25</version> <exclusions> <exclusion> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> </exclusion> </exclusions> </dependency> </dependencies> <configuration> <configurationFile>${basedir}/src/generate/generatorConfig.xml</configurationFile> <verbose>true</verbose> <overwrite>true</overwrite> </configuration> </plugin> </plugins> </build>点击菜单run中Configurations(图) 点击加号，并选择maven(图) 在name和Commond line分别填上如上图所示，apply和ok(图) 点击如下运行(图) 生成示例(图)
-
-
-
XxxExample类的使用
-
含义
mybatis的逆向工程中会生成实例及实例对应的example， 这个类是专门用来对单表查询的类，即该类相当where后面的部分 对该单表的CURD操作是脱离sql性质的 (已经通过逆向工程生成相应的sql)，直接在service层就可以完成相应操作。 逆向工程生成的文件XxxExample.java中包含一个static 的内部类 Criteria ， 在Criteria中有很多方法，主要是定义SQL 语句where后的查询条件。
注意 : 图片中userCriteria未进行自定义名称前，名称是userExample -
三个成员变量
(打开一个Example类我们会看到该类的三个成员变量) orderByClause 字段用于指定ORDER BY条件,这个条件没有构造方法,直接通过传递字符串值指定。 distinct 字段用于指定DISTINCT查询。 oredCriteria 字段用于自定义查询条件。 赋值======= new xxxExample().setOrderByClause(“字段名 ASC”); 添加升序排列条件，DESC为降序 new xxxExample().setDistinct(false); 去除重复，boolean型，true为选择不重复的记录。 -
内部类Criteria
含义 在mybatis逆向工程生成的XxxExample中，包含一个static的内部类Criteria，， Criteria中的方法是定义SQL 语句where后的查询条件。 创建 Criteria criteria = new xxxExample().createCriteria(); 方法 criteria.andXxxIsNull 添加字段xxx为null的条件 criteria.andXxxIsNotNull 添加字段xxx不为null的条件 criteria.andXxxEqualTo(value) 添加xxx字段等于value条件 criteria.andXxxNotEqualTo(value) 添加xxx字段不等于value条件 criteria.andXxxGreaterThan(value) 添加xxx字段大于value条件 criteria.andXxxGreaterThanOrEqualTo(value) 添加xxx字段大于等于value条件 criteria.andXxxLessThan(value) 添加xxx字段小于value条件 criteria.andXxxLessThanOrEqualTo(value) 添加xxx字段小于等于value条件 criteria.andXxxIn(List<？>) 添加xxx字段值在List<？>条件 criteria.andXxxNotIn(List<？>) 添加xxx字段值不在List<？>条件 criteria.andXxxLike(“%”+value+”%”) 添加xxx字段值为value的模糊查询条件 criteria.andXxxNotLike(“%”+value+”%”) 添加xxx字段值不为value的模糊查询条件 criteria.andXxxBetween(value1,value2) 添加xxx字段值在value1和value2之间条件 criteria.andXxxNotBetween(value1,value2) 添加xxx字段值不在value1和value2之间条件 -
mapper接口方法
int countByExample(UserExample example) 按条件计数 int deleteByPrimaryKey(Integer id) 按主键删除 int deleteByExample(UserExample example) 按条件查询 String/Integer insert(User record) 插入数据（返回值为ID） User selectByPrimaryKey(Integer id) 按主键查询 List selectByExample(UserExample example) 按条件查询 List selectByExampleWithBLOGs(UserExample example) 按条件查询（包括BLOB字段）。只有当数据表中的字段类型有为二进制的才会产生。 int updateByPrimaryKey(User record) 按主键更新 int updateByPrimaryKeySelective(User record) 按主键更新值不为null的字段 int updateByExample(User record, UserExample example) 按条件更新 int updateByExampleSelective(User record, UserExample example) 按条件更新值不为null的字段 -
应用示例
根据主键查询: selectByPrimaryKey() 示例 XxxMapper.selectByPrimaryKey(100); //相当于select * from user where id = 100根据where后条件查询 selectByExample() 示例 UserCriteria criteria = new UserCriteria(); criteria.createCriteria().andUsernameEqualTo("wyw")..andUsernameIsNull(); criteria.setOrderByClause("username asc,email desc"); List<?>list = XxxMapper.selectByExample(criteria); //相当于：select * from user where username = 'wyw' and username is null order by username asc,email desccreateCriteria()，创建查询条件
插入 insert() 示例 User user = new User(); user.setId("dsfgsdfgdsfgds"); user.setUsername("admin"); user.setPassword("admin") user.setEmail("[email protected]"); XxxMapper.insert(user); //相当于：insert into user(ID,username,password,email) values ('dsfgsdfgdsfgds','admin','admin','[email protected]');更新数据 updateByPrimaryKey() 示例1 User user =new User(); user.setId("dsfgsdfgdsfgds"); user.setUsername("wyw"); user.setPassword("wyw"); user.setEmail("[email protected]"); XxxMapper.updateByPrimaryKey(user); //相当于：update user set username='wyw', password='wyw', email='[email protected]' where id='dsfgsdfgdsfgds' 示例2 User user = new User(); user.setId("dsfgsdfgdsfgds"); user.setPassword("wyw"); XxxMapper.updateByPrimaryKey(user); //相当于：update user set password='wyw' where id='dsfgsdfgdsfgds'复杂更新 updateByPrimaryKeySelective() 示例 UserCriteria criteria = new UserCriteria(); criteria .createCriteria().andUsernameEqualTo("admin")； User user = new User(); user.setPassword("wyw"); XxxMapper.updateByPrimaryKeySelective(user,example); //相当于：update user set password='wyw' where username='admin'
-
-
总结
mybatis的逆向工程实现起来其实是非常简单的，但是在不同情况下，要特别注意文件路径的问题。 其中，XxxExample.java只能实现简单条件增删改查，复杂的功能还需要自己编写sql代码来实现。 注意，在配置文件中配置对应生成文件的所在目录时，最好使用绝对路径 （若不是用maven聚合搭建的项目则不用修改） -
完整配置
<?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> <!-- 可以用于加载配置项或者配置文件，在整个配置文件中就可以使用${propertyKey}的方式来引用配置项 resource：配置资源加载地址，使用resource，MBG从classpath开始找，比如com/myproject/generatorConfig.properties url：配置资源加载地质，使用URL的方式，比如file:///C:/myfolder/generatorConfig.properties. 注意，两个属性只能选址一个; 另外，如果使用了mybatis-generator-maven-plugin，那么在pom.xml中定义的properties都可以直接在generatorConfig.xml中使用 <properties resource="" url="" /> --> <!-- 在MBG工作的时候，需要额外加载的依赖包 location属性指明加载jar/zip包的全路径 <classPathEntry location="/Program Files/IBM/SQLLIB/java/db2java.zip" /> --> <!-- 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="mysql" defaultModelType="hierarchical" targetRuntime="MyBatis3Simple" > <!-- 自动识别数据库关键字，默认false，如果设置为true，根据SqlReservedWords中定义的关键字列表； 一般保留默认值，遇到数据库关键字（Java关键字），使用columnOverride覆盖 --> <property name="autoDelimitKeywords" value="false"/> <!-- 生成的Java文件的编码 --> <property name="javaFileEncoding" value="UTF-8"/> <!-- 格式化java代码 --> <property name="javaFormatter" value="org.mybatis.generator.api.dom.DefaultJavaFormatter"/> <!-- 格式化XML代码 --> <property name="xmlFormatter" value="org.mybatis.generator.api.dom.DefaultXmlFormatter"/> <!-- beginningDelimiter和endingDelimiter：指明数据库的用于标记数据库对象名的符号，比如ORACLE就是双引号，MYSQL默认是`反引号； --> <property name="beginningDelimiter" value="`"/> <property name="endingDelimiter" value="`"/> <!-- 必须要有的，使用这个配置链接数据库 @TODO:是否可以扩展 --> <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql:///pss" userId="root" password="admin"> <!-- 这里面可以设置property属性，每一个property属性都设置到配置的Driver上 --> </jdbcConnection> <!-- java类型处理器 用于处理DB中的类型到Java中的类型，默认使用JavaTypeResolverDefaultImpl； 注意一点，默认会先尝试使用Integer，Long，Short等来对应DECIMAL和 NUMERIC数据类型； --> <javaTypeResolver type="org.mybatis.generator.internal.types.JavaTypeResolverDefaultImpl"> <!-- true：使用BigDecimal对应DECIMAL和 NUMERIC数据类型 false：默认, scale>0;length>18：使用BigDecimal; scale=0;length[10,18]：使用Long； scale=0;length[5,9]：使用Integer； scale=0;length<5：使用Short； --> <property name="forceBigDecimals" value="false"/> </javaTypeResolver> <!-- java模型创建器，是必须要的元素 负责：1，key类（见context的defaultModelType）；2，java类；3，查询类 targetPackage：生成的类要放的包，真实的包受enableSubPackages属性控制； targetProject：目标项目，指定一个存在的目录下，生成的内容会放到指定目录中，如果目录不存在，MBG不会自动建目录 --> <javaModelGenerator targetPackage="com._520it.mybatis.domain" targetProject="src/main/java"> <!-- for MyBatis3/MyBatis3Simple 自动为每一个生成的类创建一个构造方法，构造方法包含了所有的field；而不是使用setter； --> <property name="constructorBased" value="false"/> <!-- 在targetPackage的基础上，根据数据库的schema再生成一层package，最终生成的类放在这个package下，默认为false --> <property name="enableSubPackages" value="true"/> <!-- for MyBatis3 / MyBatis3Simple 是否创建一个不可变的类，如果为true， 那么MBG会创建一个没有setter方法的类，取而代之的是类似constructorBased的类 --> <property name="immutable" value="false"/> <!-- 设置一个根对象， 如果设置了这个根对象，那么生成的keyClass或者recordClass会继承这个类；在Table的rootClass属性中可以覆盖该选项 注意：如果在key class或者record class中有root class相同的属性，MBG就不会重新生成这些属性了，包括： 1，属性名相同，类型相同，有相同的getter/setter方法； --> <property name="rootClass" value="com._520it.mybatis.domain.BaseDomain"/> <!-- 设置是否在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="com._520it.mybatis.mapper" targetProject="src/main/resources"> <!-- 在targetPackage的基础上，根据数据库的schema再生成一层package，最终生成的类放在这个package下，默认为false --> <property name="enableSubPackages" value="true"/> </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 --> <javaClientGenerator targetPackage="com._520it.mybatis.mapper" type="ANNOTATEDMAPPER" targetProject="src/main/java"> <!-- 在targetPackage的基础上，根据数据库的schema再生成一层package，最终生成的类放在这个package下，默认为false --> <property name="enableSubPackages" value="true"/> <!-- 可以为所有生成的接口添加一个父接口，但是MBG只负责生成，不负责检查 <property name="rootInterface" value=""/> --> </javaClientGenerator> <!-- 选择一个table来生成相关文件，可以有一个或多个table，必须要有table元素 选择的table会生成一下文件： 1，SQL map文件 2，生成一个主键类； 3，除了BLOB和主键的其他字段的类； 4，包含BLOB的类； 5，一个用户生成动态查询的条件类（selectByExample, deleteByExample），可选； 6，Mapper接口（可选） tableName（必要）：要生成对象的表名； 注意：大小写敏感问题。正常情况下，MBG会自动的去识别数据库标识符的大小写敏感度，在一般情况下，MBG会 根据设置的schema，catalog或tablename去查询数据表，按照下面的流程： 1，如果schema，catalog或tablename中有空格，那么设置的是什么格式，就精确的使用指定的大小写格式去查询； 2，否则，如果数据库的标识符使用大写的，那么MBG自动把表名变成大写再查找； 3，否则，如果数据库的标识符使用小写的，那么MBG自动把表名变成小写再查找； 4，否则，使用指定的大小写格式查询； 另外的，如果在创建表的时候，使用的""把数据库对象规定大小写，就算数据库标识符是使用的大写，在这种情况下也会使用给定的大小写来创建表名； 这个时候，请设置delimitIdentifiers="true"即可保留大小写格式； 可选： 1，schema：数据库的schema； 2，catalog：数据库的catalog； 3，alias：为数据表设置的别名，如果设置了alias，那么生成的所有的SELECT SQL语句中，列名会变成：alias_actualColumnName 4，domainObjectName：生成的domain类的名字，如果不设置，直接使用表名作为domain类的名字；可以设置为somepck.domainName，那么会自动把domainName类再放到somepck包里面； 5，enableInsert（默认true）：指定是否生成insert语句； 6，enableSelectByPrimaryKey（默认true）：指定是否生成按照主键查询对象的语句（就是getById或get）； 7，enableSelectByExample（默认true）：MyBatis3Simple为false，指定是否生成动态查询语句； 8，enableUpdateByPrimaryKey（默认true）：指定是否生成按照主键修改对象的语句（即update)； 9，enableDeleteByPrimaryKey（默认true）：指定是否生成按照主键删除对象的语句（即delete）； 10，enableDeleteByExample（默认true）：MyBatis3Simple为false，指定是否生成动态删除语句； 11，enableCountByExample（默认true）：MyBatis3Simple为false，指定是否生成动态查询总条数语句（用于分页的总条数查询）； 12，enableUpdateByExample（默认true）：MyBatis3Simple为false，指定是否生成动态修改语句（只修改对象中不为空的属性）； 13，modelType：参考context元素的defaultModelType，相当于覆盖； 14，delimitIdentifiers：参考tableName的解释，注意，默认的delimitIdentifiers是双引号，如果类似MYSQL这样的数据库，使用的是`（反引号，那么还需要设置context的beginningDelimiter和endingDelimiter属性） 15，delimitAllColumns：设置是否所有生成的SQL中的列名都使用标识符引起来。默认为false，delimitIdentifiers参考context的属性 注意，table里面很多参数都是对javaModelGenerator，context等元素的默认属性的一个复写； --> <table tableName="userinfo" > <!-- 参考 javaModelGenerator 的 constructorBased属性--> <property name="constructorBased" value="false"/> <!-- 默认为false，如果设置为true，在生成的SQL中，table名字不会加上catalog或schema； --> <property name="ignoreQualifiersAtRuntime" value="false"/> <!-- 参考 javaModelGenerator 的 immutable 属性 --> <property name="immutable" value="false"/> <!-- 指定是否只生成domain类，如果设置为true，只生成domain类，如果还配置了sqlMapGenerator，那么在mapper XML文件中，只生成resultMap元素 --> <property name="modelOnly" value="false"/> <!-- 参考 javaModelGenerator 的 rootClass 属性 <property name="rootClass" value=""/> --> <!-- 参考javaClientGenerator 的 rootInterface 属性 <property name="rootInterface" value=""/> --> <!-- 如果设置了runtimeCatalog，那么在生成的SQL中，使用该指定的catalog，而不是table元素上的catalog <property name="runtimeCatalog" value=""/> --> <!-- 如果设置了runtimeSchema，那么在生成的SQL中，使用该指定的schema，而不是table元素上的schema <property name="runtimeSchema" value=""/> --> <!-- 如果设置了runtimeTableName，那么在生成的SQL中，使用该指定的tablename，而不是table元素上的tablename <property name="runtimeTableName" value=""/> --> <!-- 注意，该属性只针对MyBatis3Simple有用； 如果选择的runtime是MyBatis3Simple，那么会生成一个SelectAll方法，如果指定了selectAllOrderByClause，那么会在该SQL中添加指定的这个order条件； --> <property name="selectAllOrderByClause" value="age desc,username asc"/> <!-- 如果设置为true，生成的model类会直接使用column本身的名字，而不会再使用驼峰命名方法，比如BORN_DATE，生成的属性名字就是BORN_DATE,而不会是bornDate --> <property name="useActualColumnNames" value="false"/> <!-- generatedKey用于生成生成主键的方法， 如果设置了该元素，MBG会在生成的<insert>元素中生成一条正确的<selectKey>元素，该元素可选 column:主键的列名； sqlStatement：要生成的selectKey语句，有以下可选项： Cloudscape:相当于selectKey的SQL为： VALUES IDENTITY_VAL_LOCAL() DB2 :相当于selectKey的SQL为： VALUES IDENTITY_VAL_LOCAL() DB2_MF :相当于selectKey的SQL为：SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1 Derby :相当于selectKey的SQL为：VALUES IDENTITY_VAL_LOCAL() HSQLDB :相当于selectKey的SQL为：CALL IDENTITY() Informix :相当于selectKey的SQL为：select dbinfo('sqlca.sqlerrd1') from systables where tabid=1 MySql :相当于selectKey的SQL为：SELECT LAST_INSERT_ID() SqlServer :相当于selectKey的SQL为：SELECT SCOPE_IDENTITY() SYBASE :相当于selectKey的SQL为：SELECT @@IDENTITY JDBC :相当于在生成的insert元素上添加useGeneratedKeys="true"和keyProperty属性 <generatedKey column="" sqlStatement=""/> --> <!-- 该元素会在根据表中列名计算对象属性名之前先重命名列名，非常适合用于表中的列都有公用的前缀字符串的时候， 比如列名为：CUST_ID,CUST_NAME,CUST_EMAIL,CUST_ADDRESS等； 那么就可以设置searchString为"^CUST_"，并使用空白替换，那么生成的Customer对象中的属性名称就不是 custId,custName等，而是先被替换为ID,NAME,EMAIL,然后变成属性：id，name，email； 注意，MBG是使用java.util.regex.Matcher.replaceAll来替换searchString和replaceString的， 如果使用了columnOverride元素，该属性无效； <columnRenamingRule searchString="" replaceString=""/> --> <!-- 用来修改表中某个列的属性，MBG会使用修改后的列来生成domain的属性； column:要重新设置的列名； 注意，一个table元素中可以有多个columnOverride元素哈~ --> <columnOverride column="username"> <!-- 使用property属性来指定列要生成的属性名称 --> <property name="property" value="userName"/> <!-- javaType用于指定生成的domain的属性类型，使用类型的全限定名 <property name="javaType" value=""/> --> <!-- jdbcType用于指定该列的JDBC类型 <property name="jdbcType" value=""/> --> <!-- typeHandler 用于指定该列使用到的TypeHandler，如果要指定，配置类型处理器的全限定名 注意，mybatis中，不会生成到mybatis-config.xml中的typeHandler 只会生成类似：where id = #{id,jdbcType=BIGINT,typeHandler=com._520it.mybatis.MyTypeHandler}的参数描述 <property name="jdbcType" value=""/> --> <!-- 参考table元素的delimitAllColumns配置，默认为false <property name="delimitedColumnName" value=""/> --> </columnOverride> <!-- ignoreColumn设置一个MGB忽略的列，如果设置了改列，那么在生成的domain中，生成的SQL中，都不会有该列出现 column:指定要忽略的列的名字； delimitedColumnName：参考table元素的delimitAllColumns配置，默认为false 注意，一个table元素中可以有多个ignoreColumn元素 <ignoreColumn column="deptId" delimitedColumnName=""/> --> </table> </context> </generatorConfiguration>
mybatis缓存
须知
缓存
1.存在内存中的临时数据
2.将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)
查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题
优点
减少和数据库的交互次数，减少系统开销，提高系统效率
使用前提
经常查询并且不经常改变的数据
mybatis缓存
mybatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升
查询效率。
mybatis系统中默认定义了两级缓存：一级缓存和二级缓存。
-默认情况下，只有一级缓存开启(sqlSession级别的缓存，也称为本地缓存)
-二级缓存需要手动开启和配置，它是基于namespace级别的缓存。
-为了提高扩展性，Mybatis定义了缓存接口Cache。操作者可以通过实现Cache接口来自定义二级缓存
一级缓存
含义
一级缓存也叫本地缓存:
内容
与数据库同一次会话期间查询到的数据会放在本地缓存中
以后如果需要获取相同的数据，直接从换缓存中拿，没必须再去查询数据库