MyBatis的前身是Apache的一个开源项目iBatis,2010年这个项目由apache software foundation 迁移到了google code,而且更名为MyBatis。2013年11月迁移到GitHub,所以目前MyBatis是由GitHub维护的。java
一样做为持久层框架的Hibernate在前些年很是的火,它在配置了映射文件和数据库链接文件后就能够经过Session操做,它甚至提供了HQL去操做POJO进而操做数据库的数据,几乎可使编程人员脱离sql语言。但是为何MyBatis却愈来愈受欢迎呢?咱们稍稍总结以下:mysql
Hibernate:sql
1.不方便的全表映射,好比更新时须要发送全部的字段;数据库
2.没法根据不一样的条件组装不一样sql;apache
3.对多表关联和复制sql查询支持较差;编程
4.有HQL但性能较差,作不到sql优化;数组
5.不能有效支持存储过程;缓存
在当今的大型互联网中,灵活、sql优化,减小数据的传递是最基本的优化方法,可是Hibernate却没法知足咱们的需求,而MyBatis提供了更灵活、更方便的方法。在MyBatis里,咱们须要本身编写sql,虽然比Hibernate配置要多,可是是MyBatis能够配置动态sql,也能够优化sql,且支持存储过程,MyBatis几乎能作到 JDBC 所能作到的全部事情!凭借其高度灵活、可优化、易维护等特色,成为目前大型移动互联网项目的首选框架。安全
导入mybatis的jar包,若是采用Maven进行部署,只需导入mybatis坐标。bash
导入数据库驱动jar包或坐标。
代码调试阶段可导入日志工具jar包或坐标,如log4j。
导入Junit单元测试坐标。
在resources目录下创建一个名字为mybatis-config.xml(名称随意)配置文件,编写所需配置信息。
遵循开发规范:
类属性命名尽可能和表字段保持一致。
实体类实现序列化接口。
实体类属性使用包装类型定义,如Integer。
Tips: 有时能够考虑经过定义时初始化来避免可能的空指针异常!
如:private List list = new ArrayList<>() ;
建立Mapper接口,在内定义CRUD方法。
Tips: 方法名惟一,须要在对应的mapper.xml文件中配置id。
在resources下建立sql映射文件。
Tips: 同对应的Mapper接口保持包结构及命名一致。
如:Mapper接口: cn.dintalk.dao.UserMapper
对应配置文件:cn.dintalk.dao.UserMapper.xml
将映射文件经过引入的方式加入到mybatis的主配置文件中。
Tips: 全部映射文件会随主配置文件在程序运行时加入内存,任一映射文件出 错都会致使整个环境报错!(初学者常常搞混resultType和resultMap)。
在映射文件中编写sql进行crud操做,在单元测试中,或service层中调用方法!
环境搭建好后开发基本流程为:
接口定义方法 。
Mapper.xml文件中编写sql。
单元测试或service调用。
MyBatis的核心组件:
SqlSessionFactoryBuilder(构造器):根据配置信息或代码生成SqlSessionFactory
SqlSessionFactory(工厂接口):依靠工厂来生成SqlSession(会话)。
SqlSession(会话): 既能够发生sql去执行并返回结果,也能够获取Mapper的接口
SQL Mapper:它是MyBatis新设计的组件,它是由一个java接口和xml文件(或注解)构成的,须要给出对应的sql和映射规则。它负责发送sql去执行,并返回结果。
正确理解并掌握上述核心组件的生命周期可让咱们写出高效的程序,还可避免带来严重的并发问题。
其做用就是利用xml或java编码得到资源来构建SqlSessionFactory对象,构建成功就失去了存在的意义,将其回收。因此它的生命周期只存在于方法的局部。
SqlSessionFactory的做用是建立SqlSession,而SqlSession就是一个会话,至关于JDBC中的Connection对象,每次访问数据库都须要经过SqlSessionFactory建立SqlSession,因此SqlSessionFactory应该在MyBatis应用的整个生命周期中。咱们使每个数据库只对应一个SqlSessionFactory(单例模式)。
SqlSession是一个会话,至关于JDBC的一个Connection对象,它的生命周期应该是在请求数据库处理事务的过程当中。是一个线程不安全的对象,涉及多线程时格外小心。此外,每次建立的SqlSession都必须及时关闭它。
Mapper是一个接口,没有任何实现类,其做用是发送sql,返回咱们须要的结果,或者执行sql修改数据库数据,所以它也因该在一个SqlSession事务方法以内,是一个方法级别的东西。就如同 JDBC中的一条sql语句的执行,它的最大范围和SqlSession是相同的。
public class MyBatisUtil {
private static SqlSessionFactory build =null;
static {
try { //使用MyBatis的Resources加载资源得到输入流,构建工厂
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
build = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException e) {
throw new RuntimeException("资源文件加载失败!");
}
}
//使用工厂生产sqlSession
public static SqlSession openSession(){
return build.openSession();
}
}
复制代码
SqlSession使用方法
//1.定义sqlSession
SqlSession sqlSession = null;
try {
sqlSession = openSession();
//2.获取映射器
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
//3.some code like 'User u = mapper.findById(id);'
//4.sqlSession不提交默认回滚!增删改需格外注意!
sqlSession.commit();
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
if (sqlSession != null) {
sqlSession.close();
}
}
复制代码
咱们能够在映射器中定义哪些元素,以及它们有何做用呢?
元素名称 | 做用 |
---|---|
insert | 定义插入语句 |
delete | 定义删除语句 |
update | 定义修改语句 |
select | 定义查询语句 |
parameterMap | 定义参数映射关系 |
resultMap | 提供从数据库结果集到POJO映射规则 |
cache | 配置当前命名空间的缓存配置(二级缓存) |
sql | 定义部分sql,各个地方均可引用 |
cache-ref | 引用其余命名空间的缓存配置 |
在各个元素当中又有至关多的属性配置项,这里很少赘述,经过下一节掌握经常使用的内容便可。这里特别说明sql元素的使用:
<sql id="user_columns"> <!-- 此处定义后,到处使用,尤为字段多的时候 -->
id, name, password
</sql>
<select ....>
select <include refid="user_columns"/> from users where uid=#{id}
</select>
复制代码
<!-- 1.添加用户 -->
<insert id="add" parameterType="User">
INSERT into users (name,password) VALUES (#{name},#{password});
</insert>
复制代码
<!-- 2.添加用户,获取数据库生成的主键值(需数据库具有主键自增功能) -->
<insert id="add" parameterType="User" useGeneratedKeys="true" keyProperty="uid">
insert into users (name,password) values(#{name},#{password});
</insert>
<!-- 3.添加用户,获取数据库生成的主键:数据库有无自动增加能力均可以-->
<insert id="add" parameterType="User">
<selectKey keyColumn="uid" keyProperty="uid" resultType="int" order="AFTER">
select last_insert_id();
</selectKey>
insert into users (name,password) values(#{name},#{password});
</insert>
复制代码
<!-- 4.修改/删除用户 -->
<update id="update" parameterType="User">
update users set name=#{name},password=#{password} where uid=#{uid};
</update>
<delete id="delete" >
delete from users where uid=#{uid};
</delete>
复制代码
<!-- 5.查询全部的用户 -->
<!-- 定义查询结果映射规则(结果集映射能够用别名) -->
<resultMap id="userMap" type="User">
<id column="id" property="uid"></id>
<result column="姓名" property="name"></result>
<result column="password" property="password"></result>
</resultMap>
<!-- 查询语句 -->
<select id="findAll" resultMap="userMap">
select uid as id,name as '姓名',password from users;
</select>
<!--6.根据用户id查询用户(单个参数)-->
<select id="findById" parameterType="int" resultType="User">
select uid,name,password from users where uid=#{uid};
</select>
<!-- 7.根据用户名和密码查询用户(接口定义方法参数时@Param(" ")进行指定,不然多个参数时
默认使用 arg0,arg1 或param1,param2来映射) -->
<select id="findByNamePassword" resultType="User">
select uid,name,password from users where name=#{name} and password=#{password};
</select>
<!-- 8.根据用户实体对象查询用户 -->
<select id="findByUser" parameterType="User" resultType="User">
select uid,name,password from users where name=#{name};
</select>
<!-- 9.根据用户名进行模糊查询 -->
<select id="findUsersLikeName" resultType="User">
select uid,name,password from users where name like concat("%",#{name},"%");
</select>
复制代码
MyBatis的动态sql包含这些元素:if | choose(when ohterwise) |trim(where set) | foreach ,经过这些元素来动态组装sql语句,主要是增改查操做。*(实际开发中,严禁使用select * 操做。这里为了简便使用select 演示)!
<!-- 1.使用if,实现动态sql,完成查询操做 -->
<select id="findByCondition" parameterType="user" resultType="user">
select uid,name,password,email from users where 1 = 1
<if test="name != null and name !=''">
and name like concat("%",#{name},"%")
</if>
<if test="password != null and password != '' ">
and password = #{password}
</if>
</select>
复制代码
<!-- 2.使用if,实现动态sql,完成更新操做 -->
<update id="updateUser" parameterType="user">
update users set
<if test="name != null and name != '' ">
name=#{name},
</if>
<if test="password != null and password != '' ">
password=#{password},
</if>
uid=#{uid} where uid=#{uid}; <!-- 保证任何状况下的sql完整 -->
</update>
复制代码
<!-- 3.使用if,实现动态sql,完成添加操做 -->
<insert id="addUser" parameterType="user">
insert into users (name,
<if test="password != null and password != '' ">
password,
</if>email,phoneNumber,birthday) values(#{name},
<if test="password != null and password != '' ">
#{password},
</if>#{email},#{phoneNumber},#{birthday});
</insert>
复制代码
<!-- 4.使用choose when otherwise,实现动态sql,完成查询操做 -->
<select id="findByCondition" parameterType="user" resultType="user">
select * from users where 1 = 1 <!-- 动态组装准备 -->
<choose>
<when test="name != null and name != '' ">
and name like concat("%",#{name},"%");
</when>
<otherwise>
and 1 = 2; <!-- 动态否决 -->
</otherwise>
</choose>
</select>
复制代码
<!-- 5.使用if和where,实现动态sql,完成查询操做 -->
<select id="findByCondition" resultType="user" parameterType="user">
select * from users
<where> <!-- 至少有一个if执行时才会加上where关键字并去掉紧跟后面的and|or关键字 -->
<if test="name != null and name != '' ">
and name like concat("%",#{name},"%")
</if>
<if test="password != null and password != '' ">
and password=#{password}
</if>
</where>
</select>
复制代码
<!-- 6.使用if和set,实现动态sql,完成更新操做 -->
<update id="updateUser" parameterType="user">
update users
<set> <!-- set元素会去掉最后一个,号 -->
<if test="name != null and name != '' ">
name=#{name},
</if>
<if test="password != null and password != '' ">
password=#{password},
</if>
uid=#{uid},
</set>
where uid=#{uid};
</update>
<!-- trim元素的使用 -->
<trim prefix="where" prefixOverrides="and|or"></trim> <!-- 等同与where元素 -->
<trim prefix="set" suffixOverrides=","></trim> <!-- 等同与set元素 -->
复制代码
<!-- 7.使用foreach,实现动态sql,完成根据id list列表的查询操做 -->
<select id="findByIds" resultType="user">
select * from users where uid in
<foreach collection="collection" open="(" close=")" separator="," item="uid">
#{uid}
</foreach>
</select>
<!-- foreach中的collection值取决于要遍历的对象类型(mybatis内部作判断后默认的)
List : 可取 collection或list
Set : 取 collection
Array: 取 array
Map : 取 _parameter (用map无心义,遍历的依旧是value)
上述默认引用均可以在接口方法中经过@Param(“ ”)覆盖掉!
-->
复制代码
bind元素的做用是经过OGNL表达式自定义一个上下文变量,这样更方便咱们使用。在进行模糊查询的时候,若是是MySQL数据库,咱们经常使用concat函数用“%”和参数链接。然而在Oracle数据则是用链接符号“||”。这样sql就须要提供两种形式去实现。用bind元素,咱们就没必要使用数据库语言,只要使用MyBatis的语言便可与所需参数相连。
<select id="findByCondition" parameterType="user" resultType="user">
<!-- 使用bind定义上下文变量 -->
<bind name="pattern" value="'%' + name + '%' "/>
select uid,name,password,email from users where 1 = 1
<if test="name != null and name !=''">
<!-- and name like concat("%",#{name},"%") -->
and name like #{pattern}
</if>
<if test="password != null and password != '' ">
and password = #{password}
</if>
</select>
复制代码
<!-- 1.使用多表查询,完成一对多关联查询及映射 -->
<!-- user结果集封装,能够经过继承重复使用 -->
<resultMap id="userMap" type="user">
<id column="uid" property="uid" />
<result column="name" property="name"/>
<result column="password" property="password"/>
</resultMap>
<!-- loginInfo结果集,继承user结果集完整数据 -->
<resultMap id="userLoginInfoMap" extends="userMap" type="user">
<!-- 使用collection映射多的一方,ofType指定集合中的数据类型 -->
<collection property="loginInfos" ofType="loginInfo">
<id column="lid" property="lid"/>
<result column="ip" property="ip"/>
<result column="loginTime" property="loginTime"/>
</collection>
</resultMap>
<!-- 定义查询语句 -->
<select id="findAllUsers" resultMap="userLoginInfoMap">
select * from users u left join login_infos li on u.uid = li.uid;
</select>
复制代码
<!-- 2.多对一,采用别名映射关联关系 -->
<select id="findAllLoginInfos" resultType="loginInfo">
select li.*,
u.uid "user.uid",
u.name "user.name",
u.password "user.password"
from login_infos li,users u
where li.uid = u.uid;
</select>
<!-- 3.多对一,采用resultMap进行结关联关系的映射 -->
<resultMap id="userMap" type="loginInfo">
<id column="uid" property="user.uid"/>
<result column="name" property="user.name"/>
<result column="password" property="user.password"/>
</resultMap>
<!-- 这里的resultMap继承关系最好和POJO中的关联关系保持一致,便于理解
这里不一致,但也能够运行
-->
<resultMap id="userLoginInfoMap" extends="userMap" type="loginInfo">
<id column="lid" property="lid"/>
<result column="ip" property="ip"/>
<result column="loginTime" property="loginTime"/>
</resultMap>
<select id="findAllLoginInfos1" resultMap="userLoginInfoMap">
select * from users u,login_infos li where u.uid=li.uid;
</select>
<!-- 4.多对一,使用resultMap结合association进行关联关系的映射 -->
<resultMap id="loginInfoMap" type="loginInfo">
<id column="lid" property="lid"/>
<result column="ip" property="ip"/>
<result column="loginTime" property="loginTime"/>
</resultMap>
<!-- 这里的resultMap继承关系和POJO的关联关系保持了一致,即LoginInfo下有User属性 -->
<resultMap id="loginInfoUserMap" extends="loginInfoMap" type="loginInfo">
<association property="user" javaType="user">
<id column="uid" property="uid"/>
<result column="name" property="name"/>
<result column="password" property="password"/>
</association>
</resultMap>
<select id="findAllLoginInfos2" resultMap="loginInfoUserMap">
select * from users u,login_infos li where u.uid=li.uid;
</select>
复制代码
<!-- 13.使用多表查询,完成多对多查询,查找全部的用户及其角色 -->
<!-- 注意:为了不冗余,这里继承了2.2中的resultMap -->
<resultMap id="userRoleMap" extends="userMap" type="user">
<collection property="roles" ofType="role">
<id column="rid" property="rid"/>
<result column="name" property="name"/>
<result column="description" property="description"/>
</collection>
</resultMap>
<!-- 多对多主要在sql编写上,须要借助中间表 -->
<select id="findAllUsers" resultMap="userRoleMap">
select * from users u left join users_roles ur
on u.uid=ur.uid inner join roles r on ur.rid=r.rid;
</select>
复制代码
在关联查询时,对于关联的一方是否查询出来,要根据业务需求而定。不能经过编码方式进行策略的改变,而应该经过修改配置文件改变加载策略。可使用嵌套查询(分步查询)。
<!-- 1.嵌套查询,使用reultMap结合association使用引用的mapper.xml进行查询 -->
<resultMap id="loginInfoMap" type="loginInfo">
<id column="lid" property="lid"/>
<result column="ip" property="ip"/>
<result column="loginTime" property="loginTime"/>
</resultMap>
<resultMap id="loginInfoUserMap" extends="loginInfoMap" type="loginInfo">
<!-- 解决user属性: property:属性
column:查询依据,也是当前查询表的外键
select:指向根据外键查询的xml惟一映射
-->
<association property="user" column="uid"
select="cn.dintalk.UserMapper.findById"/>
</resultMap>
<select id="findAllLoginInfos3" resultMap="loginInfoUserMap">
select * from login_infos;
</select>
<!-- 在association中,select指向的是另外一个Mapper.xml文件中的映射(根据命名空间和id) -->
<!-- UserMapper.xml中 14.嵌套查询之 根据uid查询用户 -->
<select id="findById" resultType="user">
select * from users where uid = #{uid};
</select>
复制代码
<!-- 2.使用嵌套查询,可经过懒加载优化sql,查询全部的用户及其日志信息 -->
<!-- 为了简便,这里继承了上述的id为userMap的resultMap -->
<resultMap id="userLoginInfoMap" extends="userMap" type="user">
<collection property="loginInfos" column="uid"
select="cn.dintalk.dao.LoginInfoMapper.findAllLoginInfos"/>
</resultMap>
<select id="findAllUser" resultMap="userLoginInfoMap1">
select * from users;
</select>
<!-- 同理,在collection中,select指向的是另外一个Mapper.xml文件的映射 -->
<!--LoginInfoMapper.xml中 5.根据用户id查询全部的登陆信息 -->
<select id="findAllLoginInfos" resultType="loginInfo">
select * from login_infos where uid=#{uid};
</select>
复制代码
<!-- 2.配置延迟加载,即sql优化 -->
<settings>
<!-- 启用懒加载策略 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 覆盖掉延迟加载的触发方法 -->
<setting name="lazyLoadTriggerMethods" value=""/>
</settings>
复制代码
启用延迟加载后,mybatis默认有toString、equals等4个触发加载的方法。咱们也能够将其覆盖掉。
延迟加载,即用到关联数据的时候再去查,不用就不查。(service层中会有不少方法调用dao方法,根据service层中的实际需求动态调整加载策略,高效利用资源!)
fetchType="lazy"(默认) | eager
lazy : 支持延迟加载
eager : 当即加载
经过 JDBC 能够手动控制:
Connection.setAutoCommit(false);
Connection.commit();
Connection.rollback();// 开启事务后,未提交会自动回滚!
复制代码
<transactionManager type="JDBC"></transactionManager>
复制代码
至关于使用 JDBC 进行事务控制:(增删改时不提交会自动回滚!)
获取SqlSession时:SqlSessionFactory.openSession(); // 手动控制事务 ★
SqlSessionFactory.openSession(true); //自动提交事务
mybatis内置了三种数据源:
UNPOOLED :不带有池(链接池)|学习时用
POOLED : 带有池的 | 实际生产环境使用
JNDI : mybatis提供的JndiDataSourceFactory来获取数据源
POOLED对应的是PooledDataSource数据源,PooledDataSourceFactory用来生产带有池的数据源。
UNPOOLED对应的是UnpooledDataSource数据源,UnpooledDataSourceFactory用来生产不带有池的数据源。
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.14</version>
</dependency>
复制代码
第二步:编写工厂类,用来产生Druid的数据源,通常选择继承UnpooledDataSourceFactory
public class DataSourceFactory extends UnpooledDataSourceFactory{
public DataSourceFactory(){
this.dataSource = new DruidDataSource();//建立druid数据源
}
}
复制代码
第三步:在mybatis-config.xml中进行配置
<!--1.类别名的配置 -->
<typeAliases>
<typeAlias type="cn.dintalk.dataSource.DataSourceFactory" alias="DRUID"/>
</typeAliases>
<environments default="mysql">
<environment id="mysql">
<transactionManager type="JDBC"></transactionManager>
<!-- 2.配置druid数据源 -->
<dataSource type="DRUID">
<!-- 3.配置数据库链接:name由数据源中的setXXX而定,value是外部配置的key -->
<property name="driverClassName" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</dataSource>
</environment>
</environments>
复制代码
MyBatis对缓存提供支持,可是在没有配置的默认状况下,它只开启一级缓存。
一级缓存只是相对于同一个SqlSession而言的。使用SqlSession第一次查询后,MyBatis会将其放在缓存中,之后再查询时,若是没有声明须要刷新,且缓存未超时的状况下,SqlSession都只会取出当前缓存的数据,而不会再次发送Sql到数据库。
二级缓存是在SqlSessionFactory层面上的,能够将缓存提供给各个SqlSession对象共享。
<settings>
<!-- 二级缓存配置(默认开启,此行可省略) -->
<setting name="cacheEnabled" value="true"/>
</settings>
复制代码
Mapper.xml文件中
<mapper namespace="cn.dintalk.dao.UserMapper">
<cache/> <!-- 开启二级缓存,使用默认配置 -->
</mapper>
<!-- 使用默认配置意味着:
映射语句文件中的全部select语句将会被缓存。
映射语句文件中的全部insert、update和delete语句会刷新缓存。
缓存使用默认的Least Recently Used(LRU,最近最少使用的)回收策略。
缓存会存1024个列表集合或对象(不管查询方法返回什么)
缓存会被视为是read/write(可读可写)的缓存
-->
复制代码
Tips:
一级缓存中存放的是对象自己,是同一个对象!
二级缓存中存放的是对象的拷贝,对象所属类必须实现jav.io.Serializable接口!
<cache evicition="LRU" flushInterval="100000" size="1024" readOnly=true/>
复制代码
eviction: 表明的是缓存回收策略,目前MyBatis提供如下策略:
(1)LRU, 最近最少使用的,移除最长时间不用的对象。
(2)FIFO, 先进先出,按对象进入缓存的顺序来移除它们。
(3)SOFT,软引用,移除基于垃圾回收器状态和软引用规则的对象。
(4)WEAK,弱引用,更积极地移除基于垃圾收集器状态和弱引用规则的对象。
flushInterval: 刷新间隔时间,单位为毫秒。
size: 引用数目,表明缓存最多能够存储多少个对象。
readOnly: 只读,意味着缓存数据只读。
系统缓存是MyBatis应用机器上的本地缓存,咱们也可使用缓存服务器来定制缓存,如比较流行的Redis缓存。咱们须要实现MyBatis为咱们提供的接口org.apache.ibatis.cache.Cache,缓存接口简介:
//获取缓存编号
String getId();
//保存key值缓存对象
void putObject(Object key,Object value);
//经过key获取缓存对象
Object getObject(Object key);
//经过key删除缓存对象
Object removeObject(Object key);
//清空缓存
void clear();
//获取缓存对象大小
int getSize();
//获取缓存的读写锁
ReadWriterLock getReadWriterLock();
复制代码
因为每种缓存都有其不一样的特色,上面的接口都须要咱们去实现。假设咱们已经有一个实现类:cn.dintalk.MyCache。则配置以下:
<cache type="cn.dintalk.MyCache"/>
复制代码
完成上述配置,就能使用自定义的缓存了。MyBatis也支持在缓存中定义经常使用的属性,如:
<cache type="cn.dintalk.MyCache">
<property name="host" value="localhost"/>
</cache>
复制代码
若是咱们在MyCache这个类中增长setHost(String host) 方法,那么它在初始化的时候就会被调用,这样咱们能够对自定义的缓存设置一些外部参数。
Tips: 咱们也可配置Sql层面的缓存规则,来决定它们是否须要刷新或使用缓存。
<insert ...flushCache="true"/>
<delete ...flushCache="true"/>
<update ...flushCache="true"/>
<select ...flushCache="false" useCache="true"/>
复制代码
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 1.引入外部的配置文件 -->
<properties resource="jdbc.properties"/>
<!-- 2.配置延迟加载,即sql优化 -->
<settings>
<!-- 启用懒加载策略 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 覆盖掉延迟加载的触发方法 -->
<setting name="lazyLoadTriggerMethods" value=""/>
<!-- 二级缓存配置(默认开启,此行可省略) -->
<!-- 使用二级缓存,在对应的mapper.xml中加入cache便可 -->
<!--<setting name="cacheEnabled" value="true"/>-->
</settings>
<!-- 3.类别名的配置 -->
<typeAliases>
<!-- 单个类的配置 -->
<!--<typeAlias type="cn.dintalk.domain.User" alias="user"/>-->
<!-- 配置druid数据源工厂类别名 -->
<typeAlias type="cn.dintalk.dataSource.DataSourceFactory" alias="DRUID"/>
<!-- 给包中全部的类配置默认别名, 即类名首字母小写-->
<package name="cn.dintalk.domain"/>
</typeAliases>
<!-- 4.使用默认的环境配置(能够是多个) -->
<environments default="mysql">
<environment id="mysql">
<!-- 事务管理器,此处配置 为JDBC -->
<transactionManager type="JDBC"></transactionManager>
<!-- 数据源配置,此处配置为 POOLED-->
<!--<dataSource type="POOLED">-->
<!-- 配置druid数据源 -->
<dataSource type="DRUID">
<!-- 配置数据库链接:name由数据源中的setXXX而定,value是外部配置的key -->
<property name="driverClassName" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</dataSource>
</environment>
</environments>
<!-- 5.注册映射文件 -->
<mappers>
<!-- 指定资源文件路径 -->
<!--<mapper resource="cn/dintalk/dao/UserMapper.xml"></mapper>-->
<!--<mapper resource="cn/dintalk/dao/LoginInfoMapper.xml"></mapper>-->
<!-- 基于Mapper接口的开发:指定类名-->
<!--<mapper class="cn.dintalk.dao.UserMapper"/>-->
<!-- 指定基于Mapper接口开发的包:(需类名和xml文件名一致,包名一致)-->
<package name="cn.dintalk.dao"/>
</mappers>
</configuration>
复制代码
<?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">
<mapper namespace="cn.dintalk.dao.UserMapper">
<cache/> <!-- 开启二级缓存 -->
</mapper>
复制代码