mybatis基础知识回顾
1. mybatis是什么？
- mybatis是一个持久层框架，是Apache下的开源项目，前身是ibatis，是一个不完全的ORM框架，mybatis提供输入和输出的映射，需要程序员自己手动写SQL语句，mybatis重点对SQL语句进行灵活操作。
- 适用场合：需求变化频繁，数据模型不固定的项目，例如：互联网项目。
2.mybatis架构：
- SqlMapConfig.xml(名称不固定)，配置内容:数据源、事务、properties、typeAliases、settings、mappers配置。
- SqlSessionFactory:会话工厂，作用是创建SqlSession，实际开发中以单例模式管理SqlSessionFactory。
- SqlSession:会话，是一个面向用户(程序员)的接口，使用mapper代理方法开发是不需要程序员直接调用Sqlsession的方法。它是线程不安全的，最佳使用场合是方法体内。
3.mybatis开发DAO的方法
3.1 原始DAO开发方法，需要程序员编写Dao接口和实现类，此方法在当前企业中还有使用因为ibatis用的就是这种原始的Dao开发方式。
3.2 mapper代理方法，程序员只需要编写mapper接口(相当于DAO接口)，mybatis自动根据mapper接口和mapper接口对应的statement自动生成代理对象(接口实现类对象)，注意使用mapper代理方法开发需要遵循以下规则：
- mapper.xml中namespace是mapper接口的全限定名。
- mapper.xml中statement的id为mapper接口的方法名。
- mapper.xml中statement输入类型(parameterType)和mapper接口方法输入参数类型一致。
- mapper.xml中statement输出类型(resultType)和mapper接口方法返回结果类型一致。
resultType和resultMap都可以完成输出映射：
resultType映射要求SQL查询的列名和输出映射pojo类型的属性名一致。
resultMap映射时对SQL查询的列名和输出映射pojo类型的属性名做一个对应关系。
4.动态SQL：
#{}和${}完成输入参数的属性值获取，通过OGNL获取parameterType指定的pojo的属性名。
#{}:占位符号，好处是防止SQL注入。
${}: SQL拼接符号，无法防止SQL注入。
if、where以及foreach的使用。
mybatis重点高级知识清单
1.使用resultMap完成高级映射(重点)
—|学习商品订单数据模型(一对一、一对多、多对多)
—|resultMap实现一对一、一对多、多对多
—|延迟加载
2.查询缓存(重点)
—|一级缓存
—|二级缓存
3.mybatis和Spring的整合(重点)
4.mybatis逆向工程(常用)
商品订单数据模型
技巧总结：学会在企业中如何去分析陌生表的数据模型
1.学习单表记录了什么东西(去学习理解需求)
2.学习单表重要字段的意义(优先学习不能为空的字段)
3.学习表与表之间的关系(一对一、一对多、多对多)
通过表的外键分析表之间的关系。
注意：分析表与表之间的关系是建立在业务意义基础之上的。
用户表user：记录了购买商品的用户
订单表orders：记录了用户所创建的订单信息
订单明细表orderdetail：记录了用户所创建订单的详细信息
商品信息表items：记录了商家提供的商品信息。
分析表与表之间的订单关系：
(1) 用户表user和订单orders：
user—>orders: 一个用户可以创建多个订单 多对多
orders—>user: 一个订单只能由一个用户创建 一对一
(2) 订单表orders和订单明细表orderdetail：
orders—>orderdetail: 一个订单可以包括多个订单明细 一对多
orderdetail—>orders: 一个订单明细只能属于一个订单 一对一
(3)订单明细orderdetail和商品信息items
orderdetail—>items: 一个订单明细只能对应一个商品信息 一对一
items—>orderdetail: 一个商品对应多个订单明细 一对多
一对一查询
需求
查询订单信息关联查询用户信息
sql语句
查询语句：
先确定主查询表：订单信息表
再确定关联查询表：用户信息
通过orders关联穿用户使用user_id一个外键，根据一条订单数据只能查询出一条用户记录就可以使用内连接
SELECT
orders.*, user.username, user.sex
FROM
orders,
user
WHERE
orders.user_id = user.id;
使用resultType实现
创建PO类
创建基础表单的PO类
一对一查询映射的pojo
创建pojo包括 订单信息和用户信息，resultType才可以完成映射
创建OrderCustom作为自定义pojo，继承 SQL查询中列最多的POJO类
public class OrderCustom extends Orders {
//补充用户信息
private String username;
private String sex;
private String address;
//提供对应的setter和getter方法
......
}mapper.xml
<!-- 一对一查询使用resultType完成
查询订单关联查询用户信息
-->
<select id="findOrderUserList" resultType="orderCustom">
SELECT
orders.*, user.username, user.sex
FROM
orders,
user
WHERE
orders.user_id = user.id;
</select>mapper.java
public interface OrdersMapperCustom {
//一对一查询，查询订单关联查询用户，使用resultType
public List<OrderCustom> findOrderUserList() throws Exception;
}测试代码
@Test
public void testFindOrderUserList() throws Exception{
SqlSession sqlSession = sqlSessionFactory.openSession();
//创建mapper代理对象
OrdersMapperCustom ordersMapperCustom = sqlSession.getMapper(OrdersMapperCustom.class);
// 调用方法
List<OrderCustom> list = ordersMapperCustom.findOrderUserList();
System.out.println(list);
}使用resultMap实现一对一
resultMap映射思路
resultMap提供一对一关联查询映射和一对多关联查询映射，一对一映射思路：将关联查询的信息映射到pojo中，如下：
在Orders类中创建一个user属性，将关联查询到的信息映射到User属性中。如下所示：
public class Orders {
private Integer id;
private Integer userId;
private String number; //商品编号
private Date createtime;
private String note;
//关联用户信息
private User user;
.....mapper.xml
<!-- 一对一查询使用resultMap完成
查询订单关联查询用户信息
-->
<select id="findOrderUserListResultMap" resultMap="ordersUserResultMap">
SELECT
orders.*, user.username, user.sex
FROM
orders,
user
WHERE
orders.user_id = user.id;
</select>resultMap定义
<!-- 一对一查询resultMap -->
<resultMap type="test.lx.mybatis.po.Orders" id="ordersUserResultMap">
<!-- 完成了订单信息的映射配置 -->
<!-- id:订单关联用户查询的唯一标识 -->
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
<!-- 下边完成关联信息的映射
association: 用于对关联信息映射到单个pojo
property: 要将关联信息映射到orders的哪个属性中
javaType: 关联信息映射到orders的属性类型，是user类型
-->
<association property="user" javaType="user">
<!-- id:关联信息的唯一标识 -->
<!-- property:要映射到所关联表中的哪个属性 -->
<id column="user_id" property="id"/>
<!-- result就是普通列的映射 -->
<result column="username" property="username"/>
<result column="sex" property="sex"/>
</association>
</resultMap>
mapper.java
// 一对一查询，查询订单关联查询用户，使用resultMap
public List<Orders> findOrderUserListResultMap() throws Exception;小结
resultType：要自定义pojo 保证SQL查询列名要和pojo的属性对应，这种方法相对较简单，所以应用广泛。
resultMap：使用association完成一对一映射需要配置resultMap，过程有点复杂，如果要实现延迟加载就只能使用resultMap来进行实现，如果为了方便对关联信息的解析，也可使用association将关联信息映射到pojo中方便解析。
一对多查询
需求
查询所有订单信息及订单下的订单明细信息
SQL语句
主查询表：订单表
关联查询表：订单明细
SELECT
orders.*,
user.username,
user.sex ,
orderdetail.id orderdetail_id,
orderdetail.items_num,
orderdetail.items_id
FROM
orders,
USER,
orderdetail
WHERE orders.user_id = user.id AND orders.id = orderdetail.orders_id
需要将订单明细内容设置到对应的订单中
resultMap进行一对多映射思路
resultMap提供collection完成关联信息映射到集合对象中。
在orders类中创建集合属性orderdetails：
public class Orders {
private Integer id;
private Integer userId;
private String number; //商品编号
private Date createtime;
private String note;
//关联用户信息
private User user;
//订单明细
private List<OrderDetail> orderDetails;
//
......mapper.xml
<!-- 一对多查询使用resultMap完成
查询订单关联查询订单明细
-->
<select id="findOrderAndOrderdetails" resultMap="orderAndOrderDetails">
SELECT
orders.*,
user.username,
user.sex ,
orderdetail.id orderdetail_id,
orderdetail.items_num,
orderdetail.items_id
FROM
orders,
USER,
orderdetail
WHERE orders.user_id = user.id AND orders.id = orderdetail.orders_id
</select>resultMap定义
<!-- 一对多，查询订单以及订单明细 -->
<resultMap type="orders" id="orderAndOrderDetails" extends="ordersUserResultMap">
<!-- 映射订单信息，和用户信息，这里使用继承 ordersUserResultMap-->
<!-- 映射订单明细信息
property: 要将关联信息映射到orders的哪个属性中
ofType: 集合中的pojo属性
-->
<collection property="orderDetails" ofType="test.lx.mybatis.po.OrderDetail">
<!-- id: 关联信息订单明细的唯一标识
property: Orderdetail的属性名
-->
<id column="orderdetail_id" property="id"/>
<result column="items_num" property="itemsNum"/>
<result column="items_id" property="itemsId"/>
</collection>
</resultMap>mapper.java
// 一对多查询，查询订单关联查询订单明细，使用resultMap
public List<Orders> findOrderAndOrderdetails() throws Exception;测试代码
//一对多查询使用resultMap
@Test
public void testFindOrderAndOrderdetails() throws Exception{
SqlSession sqlSession = sqlSessionFactory.openSession();
//创建mapper代理对象
OrdersMapperCustom ordersMapperCustom = sqlSession.getMapper(OrdersMapperCustom.class);
//调用方法
List<Orders> list = ordersMapperCustom.findOrderAndOrderdetails();
for (Orders orders : list) {
System.out.println(orders.getUser().getUsername()+" "+orders.getOrderDetails().size());
}
System.out.println(list);
}一对多查询[复杂]
需求
查询所有用户信息，关联查询订单及商品信息，订单明细信息中关联查询查商品信息。
SQL语句
主查询表：用户信息
关联查询：订单、订单明细、商品信息
SELECT
orders.*,
user.username,
user.sex ,
orderdetail.id orderdetail_id,
orderdetail.items_num,
orderdetail.items_id,
items.name items_name,
items.detail items_detail
FROM
orders,
USER,
orderdetail,
items
WHERE orders.user_id = user.id AND orders.id = orderdetail.orders_id AND items.id = orderdetail.items_id
pojo定义
在User.java中创建映射的属性：集合List<Orders> orderlist;
在Orders中创建映射属性：集合List<Orderdetail> orderdetails;
在Orderdetail中创建商品属性：pojo Items items;
mapper.xml
<!-- 一对多查询使用resultMap完成
查询用户及订单和订单明细，关联商品的信息
-->
<select id="findUserOrderDetail" resultMap="userOrderDetailResultMap">
SELECT
orders.*,
user.username,
user.sex ,
orderdetail.id orderdetail_id,
orderdetail.items_num,
orderdetail.items_id,
items.name items_name,
items.detail items_detail
FROM
orders,
USER,
orderdetail,
items
WHERE orders.user_id = user.id AND orders.id = orderdetail.orders_id AND items.id = orderdetail.items_id
</select>resultMap定义
<!-- 一对多查询，查询用户及订单明细和商品信息 -->
<resultMap type="user" id="userOrderDetailResultMap">
<!-- 用户信息映射 -->
<id column="user_id" property="id"/>
<result column="username" property="username"/>
<result column="sex" property="sex"/>
<!-- 订单信息 -->
<collection property="orderlist" ofType="test.lx.mybatis.po.Orders">
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
<!-- 订单明细映射 -->
<collection property="orderDetails" ofType="test.lx.mybatis.po.OrderDetail">
<!-- id: 关联信息订单明细的唯一标识
property: Orderdetail的属性名
-->
<id column="orderdetail_id" property="id"/>
<result column="items_num" property="itemsNum"/>
<result column="items_id" property="itemsId"/>
<!-- 商品信息 -->
<association property="items" javaType="test.lx.mybatis.po.Items">
<id column="item_id" property="id"/>
<result column="items_name" property="name"/>
<result column="items_detail" property="detail"/>
</association>
</collection>
</collection>
</resultMap>mapper.java
// 一对多查询，查询订单关联查询订单明细以及商品信息，使用resultMap
public List<User> findUserOrderDetail() throws Exception;多对多查询
需求1：
查询显示字段：用户账号、用户名称、用户性别、商品名称、商品价格(最常见)
企业开发中常见明细列表，用户购买商品明细列表，
使用resultType将上边查询列映射到pojo输出。
需求2：
查询显示字段：用户账号、用户名称、购买商品数量、商品明细（鼠标移上显示明细）
使用resultMap将用户购买的商品明细列表映射到user对象中。
实现方法和一对多一样。
延迟加载
使用延迟加载的意义
在进行数据查询时，为了提高数据库查询性能，尽量使用单表查询，因为单表查询比多表关联查询速度快。
如果查询单表就可以满足需求，一开始先查询单表，当需要关联信息时，再关联查询。当需要关联信息时才进行查询就叫做延迟加载。mybatis中resultMap提供延迟加载功能，通过resultMap配置延迟加载。
<!-- 全局配置参数 -->
<settings>
<!-- 延迟加载总开关 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 设置按需加载 -->
<setting name="aggressiveLazyLoading" value="false"/>
</settings>延迟加载实现
实现思路
需求：查询订单及用户信息，一对一查询
刚开始只查询订单信息，当需要用户信息时调用Orders类中的getUser()方法执行延迟加载，向数据库发出SQL。
mapper.xml
<!-- 一对一查询延迟加载
开始只查询订单，对用户信息进行延迟加载
-->
<select id="findOrderUserListLazyLoading" resultMap="orderCustomLazyLoading">
SELECT
orders.*
FROM
orders
</select>resultMap
<!-- 一对一查询延迟加载的配置 -->
<resultMap type="orders" id="orderCustomLazyLoading">
<!-- 完成了订单信息的映射配置 -->
<!-- id:订单关联用户查询的唯一标识 -->
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
<!--
select：延迟加载执行的sql所在的statement的id，如果不在同一个namespace需要加namespace
sql：根据用户id查询用户信息 column：关联查询的列
property:将关联查询的用户信息设置到Orders的哪个属性 -->
<association property="user" select="test.lx.mybatis.mapper.UserMapper.findUserById" column="user_id">
</association>
</resultMap>mapper.java
// 一对一查询，查询订单延迟加载用户信息，使用resultMap
public List<Orders> findOrderUserListLazyLoading() throws Exception;测试代码
//一对一查询 延迟加载
@Test
public void testFindOrderUserListLazyLoading() throws Exception{
SqlSession sqlSession = sqlSessionFactory.openSession();
//创建mapper代理对象
OrdersMapperCustom ordersMapperCustom = sqlSession.getMapper(OrdersMapperCustom.class);
// 调用方法
List<Orders> list = ordersMapperCustom.findOrderUserListLazyLoading();
//这里执行延迟加载，要发出SQL
User user = list.get(0).getUser();
System.out.println(user);
}
一对多查询延迟加载
resultType、resultMap、延迟加载使用场景总结
延迟加载：延迟加载实现的方法多种多样，在只查询单表就可以满足需求，为了提高数据库查询性能使用延迟加载，再查询关联信息。
注意：mybatis提供的延迟加载的功能用于Service。
resultType：
作用：将查询结果按照sql列名和pojo属性名的一致性映射到pojo中。
场合：常见一些明细记录的展示，将关联信息全部展示到页面上时，此时可直接使用resultType将每一条记录映射到pojo中，在前端页面遍历list(list中是pojo即可)
resultMap：使用association和collection完成一对一和一对多高级映射。
association：
作用：将关联查询信息映射到一个pojo类中。
场合：为了方便获取关联信息可以使用association将关联订单映射为pojo，比如：查询订单关联查询用户信息。
collection：
作用：将关联查询信息映射到一个list集合中。
场合：为了方便获取关联信息可以使用collection将关联信息映射到list集合中，比如：查询用户权限范围模块和功能，可以使用collection将模块和功能列表映射到list中。
查询缓存
缓存的意义
将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)去查询，从缓存中进行查询，从而提高查询效率，解决了高并发系统的性能问题。
mybatis持久层缓存
mybatis提供一级缓存和二级缓存
mybatis一级缓存是一个Sqlsession级别，SqlSession只能访问自己的一级缓存数据，二级缓存是跨SqlSession的，是mapper级别的缓存，对于mapper级别的缓存 不同的SqlSession是可以共享的。
一级缓存
原理
第一次发出一个查询sql，sql查询结果写入SqlSession一级缓存中，缓存使用的数据结构是一个map<key,value>
key: hashcode+sql+sql输入参数+sql输出参数 (作为SQL的唯一标识)
value: 用户信息。
同一个sqlSession再次发出相同的sql，就从缓存中取数据，不再查询数据库。如果两次中间出现commit操作(修改、添加、删除)，此SqlSession中的一级缓存数据全部清空，下次再去缓存中就会查询不到数据再从数据库查询，从数据库查询到后再写入缓存。
每次查询都先从缓存进行查询。
注意：清空时会清空当前sqlsession缓存区域中的全部内容。
一级缓存配置
mybatis默认支持一级缓存不需要配置
注意：mybatis和Spring整合后进行mapper代理开发，不支持一级缓存，mybatis和Spring整合，Spring按照mapper的模板去生成mapper代理对象，模板中在最后统一关闭sqlsession。
一级缓存测试
//一级缓存
@Test
public void testCache1() throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
//第一次查询用户id为1的用户
User user = userMapper.findUserById(1);
User userX = userMapper.findUserById(2);
System.out.println(user);
//中间修改用户要清空缓存，目的防止查询出脏数据
/*user.setUsername("测试用户2");
userMapper.updateUser(user);
sqlSession.commit(); */
//第二次查询用户id为1的用户
User user2 = userMapper.findUserById(1);
User userX2 = userMapper.findUserById(2);
System.out.println(user2);
sqlSession.close();
}测试可以发现，当前SQLSession只要执行任意一个commit()，id为1和2的用户都会在缓存中被清空，所以说，commit后会清空当前sqlsession缓存区域中的全部内容。
二级缓存
二级缓存原理
二级缓存的范围是mapper级别(mapper同一个命名空间)，mapper以命名空间为单位创建缓存数据结构，结构为map<key,value>
每次查询先看是否开启二级缓存，如果开启先从二级缓存中数据结构中取缓存数据。
如果从二级缓存中没有取到，再从一级缓存中进行查找，如果一级缓存也没有，从数据库查询。
mybatis二级缓存配置
在核心配置文件SqlMapConfig.xml中全局设置中加入
<setting name="cacheEnabled" value="true"/>
cacheEnabled: 对此配置文件下的所有cache进行全局性开/关设置。允许值true/false，默认为true。
然后在Mapper的映射文件中添加一行：<cache/>, 表示此mapper开启二级缓存。
查询结果映射的pojo序列化
mybatis二级缓存需要将查询结果映射的pojo实现 java.io.serializable接口，如果不实现则抛出异常：org.apache.ibatis.cache.CacheException: Error serializing object. Cause: java.io.NotSerializableException
二级缓存可以将内存中的数据写到硬盘，存在对象的序列和反序列化，所以要实现java.io.serializable接口。如果结果映射的pojo中还关联了别的pojo，那么它和它所关联的pojo也都要实现java.io.serializable接口。
二级缓存的禁用
对于变化频率较高的sql，需要禁用二级缓存：
在statement中设置useCache=false可以禁用当前select语句的二级缓存，即每次查询都会发出sql去查询，默认情况是true，即该sql使用二级缓存。
<select id="findOrderListResultMap" resultMap="ordersUserMap" useCache="false">
在statement中设置useCache=false可以禁用当前select语句的二级缓存，即每次查询都会发出sql去查询，默认情况是true，即该sql使用二级缓存。
<select id="findOrderListResultMap" resultMap="ordersUserMap" useCache="false">
刷新缓存
如果SqlSession操作commit操作，对二级缓存进行刷新(全局清空)
设置与commit相关statement(insert,update,delete等标签)的flushCache属性是否刷新缓存，默认值是true，如果设置了为false，即使后台数据库发生了变化，只要缓存没有过期，也只会读取缓存中数据 就会获取不到最新数据。
测试代码
//二级缓存的测试
@Test
public void testCache2() throws Exception {
SqlSession sqlSession1 = sqlSessionFactory.openSession();
SqlSession sqlSession2 = sqlSessionFactory.openSession();
SqlSession sqlSession3 = sqlSessionFactory.openSession();
UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
UserMapper userMapper3 = sqlSession3.getMapper(UserMapper.class);
//第一次查询用户id为1的用户
User user = userMapper1.findUserById(1);
System.out.println(user);
sqlSession1.close();
//中间修改用户要清空缓存，目的防止查询出脏数据
/*user.setUsername("测试用户2");
userMapper3.updateUser(user);
sqlSession3.commit();
sqlSession3.close();*/
//第二次查询用户id为1的用户
User user2 = userMapper2.findUserById(1);
System.out.println(user2);
sqlSession2.close();
}mybatis自带的cache参数属性(了解)
mybatis的cache参数只适用于mybatis维护缓存。
flushInterval（刷新间隔）可以被设置为任意的正整数，而且它们代表一个合理的毫秒形式的时间段。默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新。
size（引用数目）可以被设置为任意正整数，要记住你缓存的对象数目和你运行环境的可用内存资源数目。默认值是1024。
readOnly（只读）属性可以被设置为true或false。只读的缓存会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。可读写的缓存会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是false。
如下例子：
<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>
这个更高级的配置创建了一个 FIFO 缓存,并每隔 60 秒刷新,存数结果对象或列表的 512 个引用,而且返回的对象被认为是只读的,因此在不同线程中的调用者之间修改它们会导致冲突。可用的收回策略有, 默认的是 LRU:
LRU – 最近最少使用的:移除最长时间不被使用的对象。
FIFO – 先进先出:按对象进入缓存的顺序来移除它们。
SOFT – 软引用:移除基于垃圾回收器状态和软引用规则的对象。
WEAK – 弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。
flushInterval（刷新间隔）可以被设置为任意的正整数，而且它们代表一个合理的毫秒形式的时间段。默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新。
size（引用数目）可以被设置为任意正整数，要记住你缓存的对象数目和你运行环境的可用内存资源数目。默认值是1024。
readOnly（只读）属性可以被设置为true或false。只读的缓存会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。可读写的缓存会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是false。
如下例子：
<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>
这个更高级的配置创建了一个 FIFO 缓存,并每隔 60 秒刷新,存数结果对象或列表的 512 个引用,而且返回的对象被认为是只读的,因此在不同线程中的调用者之间修改它们会导致冲突。可用的收回策略有, 默认的是 LRU:
LRU – 最近最少使用的:移除最长时间不被使用的对象。
FIFO – 先进先出:按对象进入缓存的顺序来移除它们。
SOFT – 软引用:移除基于垃圾回收器状态和软引用规则的对象。
WEAK – 弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。
mybatis和ehcache缓存框架整合
mybatis二级缓存通过ehcache维护缓存数据。
分布缓存
将缓存数据进行分布式管理
mybatis和ehcache思路
通过mybatis和ehcache框架进行整合，既可以将缓存数据的管理托管给ehcache。
在mybatis中提供了一个cache接口，只要实现cache接口就可以把缓存数据灵活的管理起来。
mybatis中的默认实现
下载和ehcache整合的jar包
ehcache对cache接口的实现类
在calsspath下配置ehcache.xml
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
<!--diskStore：缓存数据持久化的目录 地址 -->
<diskStore path="/Users/liuxun/Desktop/ehcache" />
<defaultCache
maxElementsInMemory="1000"
maxElementsOnDisk="10000000"
eternal="false"
overflowToDisk="false"
diskPersistent="true"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU">
</defaultCache>
</ehcache>整合ehcache
在mapper.xml下添加ehcache配置
<!-- 开启二级缓存 -->
<!-- 单位：毫秒 -->
<cache type="org.mybatis.caches.ehcache.EhcacheCache">
<property name="timeToIdleSeconds" value="12000"/>
<property name="timeToLiveSeconds" value="3600"/>
<!-- 同ehcache参数maxElementsInMemory -->
<property name="maxEntriesLocalHeap" value="1000"/>
<!-- 同ehcache参数maxElementsOnDisk -->
<property name="maxEntriesLocalDisk" value="10000000"/>
<property name="memoryStoreEvictionPolicy" value="LRU"/>
</cache>
二级缓存的应用场景
对于查询频率高，变化频率低的数据建议使用二级缓存。
对于访问多的查询请求且用户对查询结果的实时性要求不高，此时可采用mybatis二级缓存技术降低数据库的访问量，提高访问速度，业务场景比如：耗时较高的统计分析sql、电话账单查询sql等。
实现方法如下：通过设置刷新时间间隔，由mybatis每隔一段时间自动清空缓存，根据数据变化频率设置缓存刷新时间间隔flushInterval，比如设置30分钟、60分钟、24小时等，根据需求而定。
mybatis局限性
项目代码
完整代码已经上传GitHub（https://github.com/LX1993728/mybatisDemo_2）
OrdersMapperCustom.java
package test.lx.mybatis.mapper;
import java.util.List;
import test.lx.mybatis.po.OrderCustom;
import test.lx.mybatis.po.Orders;
import test.lx.mybatis.po.User;
/**
* 订单自定义的mapper接口
*
* @author liuxun
*
*/
public interface OrdersMapperCustom {
// 一对一查询，查询订单关联查询用户，使用resultType
public List<OrderCustom> findOrderUserList() throws Exception;
// 一对一查询，查询订单关联查询用户，使用resultMap
public List<Orders> findOrderUserListResultMap() throws Exception;
// 一对一查询，查询订单延迟加载用户信息，使用resultMap
public List<Orders> findOrderUserListLazyLoading() throws Exception;
// 一对多查询，查询订单关联查询订单明细，使用resultMap
public List<Orders> findOrderAndOrderdetails() throws Exception;
// 一对多查询，查询订单关联查询订单明细以及商品信息，使用resultMap
public List<User> findUserOrderDetail() throws Exception;
}
OrdersMapperCustom.xml
<?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="test.lx.mybatis.mapper.OrdersMapperCustom">
<!-- 一对一查询resultMap -->
<resultMap type="orders" id="ordersUserResultMap">
<!-- 完成了订单信息的映射配置 -->
<!-- id:订单关联用户查询的唯一标识 -->
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
<!-- 下边完成关联信息的映射
association: 用于对关联信息映射到单个pojo
property: 要将关联信息映射到orders的哪个属性中
javaType: 关联信息映射到orders的属性类型，是user类型
-->
<association property="user" javaType="user">
<!-- id:关联信息的唯一标识 -->
<!-- property:要映射到所关联表中的哪个属性 -->
<id column="user_id" property="id"/>
<!-- result就是普通列的映射 -->
<result column="username" property="username"/>
<result column="sex" property="sex"/>
</association>
</resultMap>
<!-- 一对一查询延迟加载的配置 -->
<resultMap type="orders" id="orderCustomLazyLoading">
<!-- 完成了订单信息的映射配置 -->
<!-- id:订单关联用户查询的唯一标识 -->
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
<!--
select：延迟加载执行的sql所在的statement的id，如果不在同一个namespace需要加namespace
sql：根据用户id查询用户信息 column：关联查询的列
property:将关联查询的用户信息设置到Orders的哪个属性 -->
<association property="user" select="test.lx.mybatis.mapper.UserMapper.findUserById" column="user_id">
</association>
</resultMap>
<!-- 一对多，查询订单以及订单明细 -->
<resultMap type="orders" id="orderAndOrderDetails" extends="ordersUserResultMap">
<!-- 映射订单信息，和用户信息，这里使用继承 ordersUserResultMap-->
<!-- 映射订单明细信息
property: 要将关联信息映射到orders的哪个属性中
ofType: 集合中的pojo属性
-->
<collection property="orderDetails" ofType="test.lx.mybatis.po.OrderDetail">
<!-- id: 关联信息订单明细的唯一标识
property: Orderdetail的属性名
-->
<id column="orderdetail_id" property="id"/>
<result column="items_num" property="itemsNum"/>
<result column="items_id" property="itemsId"/>
</collection>
</resultMap>
<!-- 一对多查询，查询用户及订单明细和商品信息 -->
<resultMap type="user" id="userOrderDetailResultMap">
<!-- 用户信息映射 -->
<id column="user_id" property="id"/>
<result column="username" property="username"/>
<result column="sex" property="sex"/>
<!-- 订单信息 -->
<collection property="orderlist" ofType="test.lx.mybatis.po.Orders">
<id column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<result column="note" property="note"/>
<!-- 订单明细映射 -->
<collection property="orderDetails" ofType="test.lx.mybatis.po.OrderDetail">
<!-- id: 关联信息订单明细的唯一标识
property: Orderdetail的属性名
-->
<id column="orderdetail_id" property="id"/>
<result column="items_num" property="itemsNum"/>
<result column="items_id" property="itemsId"/>
<!-- 商品信息 -->
<association property="items" javaType="test.lx.mybatis.po.Items">
<id column="item_id" property="id"/>
<result column="items_name" property="name"/>
<result column="items_detail" property="detail"/>
</association>
</collection>
</collection>
</resultMap>
<!-- 一对一查询使用resultType完成
查询订单关联查询用户信息
-->
<select id="findOrderUserList" resultType="orderCustom">
SELECT
orders.*, user.username, user.sex
FROM
orders,
user
WHERE
orders.user_id = user.id;
</select>
<!-- 一对一查询使用resultMap完成
查询订单关联查询用户信息
-->
<select id="findOrderUserListResultMap" resultMap="ordersUserResultMap">
SELECT
orders.*, user.username, user.sex
FROM
orders,
user
WHERE
orders.user_id = user.id;
</select>
<!-- 一对多查询使用resultMap完成
查询订单关联查询订单明细
-->
<select id="findOrderAndOrderdetails" resultMap="orderAndOrderDetails">
SELECT
orders.*,
user.username,
user.sex ,
orderdetail.id orderdetail_id,
orderdetail.items_num,
orderdetail.items_id
FROM
orders,
USER,
orderdetail
WHERE orders.user_id = user.id AND orders.id = orderdetail.orders_id
</select>
<!-- 一对多查询使用resultMap完成
查询用户及订单和订单明细，关联商品的信息
-->
<select id="findUserOrderDetail" resultMap="userOrderDetailResultMap">
SELECT
orders.*,
user.username,
user.sex ,
orderdetail.id orderdetail_id,
orderdetail.items_num,
orderdetail.items_id,
items.name items_name,
items.detail items_detail
FROM
orders,
USER,
orderdetail,
items
WHERE orders.user_id = user.id AND orders.id = orderdetail.orders_id AND items.id = orderdetail.items_id
</select>
<!-- 一对一查询延迟加载
开始只查询订单，对用户信息进行延迟加载
-->
<select id="findOrderUserListLazyLoading" resultMap="orderCustomLazyLoading">
SELECT
orders.*
FROM
orders
</select>
</mapper><ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
<!--diskStore：缓存数据持久化的目录 地址 -->
<diskStore path="/Users/liuxun/Desktop/ehcache" />
<defaultCache
maxElementsInMemory="1000"
maxElementsOnDisk="10000000"
eternal="false"
overflowToDisk="false"
diskPersistent="true"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU">
</defaultCache>
</ehcache><?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命名空间，为了对SQL语句进行隔离，方便管理，mapper可开发dao方式，使用namespace有特殊作用
mapper代理开发时将namespace指定为mapper接口的全限定名 -->
<mapper namespace="test.lx.mybatis.mapper.UserMapper">
<!-- 在mapper.xml文件中配置很多的SQL语句，执行每个SQL语句时，封装为MappedStatement对象
mapper.xml以statement为单位管理SQL语句
-->
<!-- 开启二级缓存 -->
<!-- 单位：毫秒 -->
<cache type="org.mybatis.caches.ehcache.EhcacheCache">
<property name="timeToIdleSeconds" value="12000"/>
<property name="timeToLiveSeconds" value="3600"/>
<!-- 同ehcache参数maxElementsInMemory -->
<property name="maxEntriesLocalHeap" value="1000"/>
<!-- 同ehcache参数maxElementsOnDisk -->
<property name="maxEntriesLocalDisk" value="10000000"/>
<property name="memoryStoreEvictionPolicy" value="LRU"/>
</cache>
<!-- 将用户查询条件定义为SQL片段
建议对单表的查询条件单独抽取成SQL片段，提高公用性
注意：不要讲where标签放在SQL片段,因为where条件中可能有多个SQL片段进行结合
-->
<sql id="query_user_where">
<!-- 如果userQueryVo中传入查询条件，在进行SQL拼接 -->
<!-- test中userCustom.username表示从userQueryVo中读取属性值 -->
<if test="userCustom!=null">
<if test="userCustom.username!=null and userCustom.username.trim().length() > 0">
and username like '%${userCustom.username.trim()}%'
</if>
<if test="userCustom.sex!=null and userCustom.sex!=''">
and sex = #{userCustom.sex}
</if>
<!-- 根据id集合查询用户信息 -->
<!-- 最终拼接的效果：
SELECT id,username,birthday FROM USER WHERE username LIKE '%小明%' AND id IN (16,22,25)
collection: pojo中的表示集合的属性
open: 开始循环拼接的串
close: 结束循环拼接的串
item: 每次循环从集合中取到的对象
separator: 没两次循环中间拼接的串
-->
<if test="ids != null and ids.size()>0">
<foreach collection="ids" open=" AND id IN (" close=")" item="id" separator=",">
#{id}
</foreach>
</if>
<!--
SELECT id ,username ,birthday FROM USER WHERE username LIKE '%小明%' AND (id = 16 OR id = 22 OR id = 25)
<foreach collection="ids" open=" AND id IN (" close=")" item="id" separator=" OR ">
id=#{id}
</foreach>
-->
<!-- 还可以添加更多的查询条件 -->
</if>
</sql>
<!-- 定义resultMap，列名和属性名映射配置
id: mapper.xml中唯一标识
type: 最终要映射的pojo类型
-->
<resultMap id="userListResultMap" type="user">
<!-- 列名
id,username_,birthday_
id:要映射结果集的唯一标识，称为主键
column: 结果集的列名
property:type指定pojo中的某个属性
-->
<id column="id_" property="id" />
<!-- result就是普通列的映射配置 -->
<result column="username_" property="username"/>
<result column="birthday_" property="birthday"/>
</resultMap>
<!-- 根据id查询用户信息 -->
<!--
id: 唯一标识一个statement
#{}：表示一个占位符，如果#{} 中传入简单类型的参数，#{}中的名称随意
parameterType: 输入参数的类型，通过#{}接收parameterType输入的参数
resultType：输出结果类型，不管返回是多条还是单条，指定单条记录映射的pojo类型
-->
<select id="findUserById" parameterType="int" resultType="user">
SELECT * FROM USER WHERE id=#{id};
</select>
<!-- 根据用户名称查询用户信息，可能返回多条
${}:表示SQL的拼接，通过${}接收参数，将参数的内容不加任何修饰的拼接在SQL中
-->
<select id="findUserByName" parameterType="java.lang.String" resultType="test.lx.mybatis.po.User">
select * from user where username like '%${value}%'
</select>
<!-- <select id="findUserByName" parameterType="java.lang.String" resultType="test.lx.mybatis.po.User">
select * from user where username like #{username}
</select> -->
<!-- 自定义查询条件查询用户信息
parameterType: 指定包装类型
%${userCustom.username}%: userCustom是userQueryVo中的属性，通过OGNL获取属性的值
-->
<select id="findUserList" parameterType="userQueryVo" resultType="user">
select * from user
<!-- where标签相当于where关键字，可以自动除去第一个and -->
<where>
<!-- 引用sql片段，如果sql片段和引用处不在同一个mapper 必须在前边加namespace. -->
<include refid="query_user_where"></include>
<!-- 下边还有很多其它的条件 -->
<!-- <include refid="其它的sql片段"></include> -->
</where>
</select>
<!-- 使用resultMap作为结果映射
resultMap: 如果引用resultMap的位置和resultMap的定义在同一个mapper.xml中，
直接使用resultMap的id,如果不在同一个mapper.xml中，要在引用resultMap的id前边加namespace
-->
<select id="findUserListResultMap" parameterType="userQueryVo" resultMap="userListResultMap">
select id id_,username username_,birthday birthday_ from user where username like '%${userCustom.username}%'
</select>
<!-- 输出简单类型
功能：自定义查询条件，返回查询记录个数，通常用于实现查询分页
-->
<select id="findUserCount" parameterType="userQueryVo" resultType="int">
select count(*) from user
<!-- where标签相当于where关键字，可以自动除去第一个and -->
<where>
<!-- 引用sql片段，如果sql片段和引用处不在同一个mapper 必须在前边加namespace. -->
<include refid="query_user_where"></include>
<!-- 下边还有很多其它的条件 -->
<!-- <include refid="其它的sql片段"></include> -->
</where>
</select>
<!-- 添加用户
parameterType:输入参数的类型，User对象包括username,birthday,sex,address
#{}接收pojo数据,可以使用OGNL解析出pojo的属性值
#{username}表示从parameterType中获取pojo的属性值
<selectKey>:用于进行主键返回，定义了主键值的SQL
order：设置selectKey标签中SQL的执行顺序，相对于insert语句而言
keyProperty： 将主键设置到哪个属性上
resultType：select LAST_INSERT_ID()的结果类型
-->
<insert id="insertUser" parameterType="test.lx.mybatis.po.User">
<selectKey keyProperty="id" order="AFTER" resultType="int">
select LAST_INSERT_ID()
</selectKey>
INSERT INTO USER(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})
</insert>
<!-- mysql的uuid()函数生成主键 -->
<!-- <insert id="insertUser" parameterType="test.lx.mybatis.po.User">
<selectKey keyProperty="id" order="BEFORE" resultType="string">
select uuid()
</selectKey>
INSERT INTO USER(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})
</insert> -->
<!-- oracle
在执行insert之前执行select 序列.nextval() from dual取出序列最大值，将值设置到user对象的id属性中
-->
<!-- <insert id="insertUser" parameterType="test.lx.mybatis.po.User">
<selectKey keyProperty="id" order="BEFORE" resultType="int">
select 序列.nextval() from dual
</selectKey>
INSERT INTO USER(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})
</insert> -->
<!-- 用户删除 -->
<delete id="deleteUser" parameterType="int" >
delete from user where id=#{id}
</delete>
<!-- 用户更新
要求：传入的user对象包括id属性值
-->
<update id="updateUser" parameterType="test.lx.mybatis.po.User">
update user set username = #{username},birthday=#{birthday},sex=#{sex},address=#{address} where id=#{id}
</update>
</mapper><?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>
<!-- 属性定义
加载一个properties文件
在properties标签中配置属性值
-->
<properties resource="db.properties">
<!-- <property name="" value=""/> -->
</properties>
<!-- 全局配置参数 -->
<settings>
<!-- 延迟加载总开关 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 设置按需加载 -->
<setting name="aggressiveLazyLoading" value="false"/>
<!-- 开启二级缓存 -->
<setting name="cacheEnabled" value="true"/>
</settings>
<!-- 定义别名 -->
<typeAliases>
<!--
单个别名定义
alias:别名, type:别名映射类型
<typeAlias type="test.lx.mybatis.po.User" alias="user"/>
-->
<!-- 批量别名定义
指定包路径，自动扫描包内的pojo,定义别名，别名默认为类名(首字母小写或大写)
-->
<package name="test.lx.mybatis.po"/>
</typeAliases>
<!-- 和Spring整合后environments配置将废除 -->
<environments default="development">
<environment id="development">
<!-- 使用jdbc事务管理 -->
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</dataSource>
</environment>
</environments>
<!-- 加載mapper映射
如果和Spring整合后，可以使用整合包中的mapper扫描器，到那时此处的mapper就不用配置了
-->
<mappers>
<!-- 通过resource映入mapper的映射文件 -->
<mapper resource="sqlmap/User.xml" />
<!-- <mapper resource="test/lx/mybatis/mapper/UserMapper.xml"/> -->
<!-- 通过class引用mapper接口
class：配置mapper接口的全限定名
要求：需要mapper.xml和mapper.java同名并且在同一目录中
-->
<!-- <mapper class="test.lx.mybatis.mapper.UserMapper"/> -->
<!-- 批量mapper配置
通过package进行自动扫描包下边的mapper接口
要求：需要mapper.xml和mapper.java同名并在同一目录中
-->
<package name="test.lx.mybatis.mapper"/>
</mappers>
</configuration>
mybatis和Spring的整合
mybatis和Spring整合的思路
1.让Spring管理SqlSessionFactory
2.让Spring管理mapper对象和DAO
使用Spring和mybatis整合开发mapper代理对象以及原始Dao接口
自动开启事务，自动关闭sqlSession
3.让Spring管理数据源(数据库连接池)
创建整合工程
加入的jar包
1.mybatis3.2.7自身的jar包
2.数据库驱动包
3.spring3.2.0
4.spring和mybatis整合包
从mybatis的官方下载Spring和mybatis整合包
log4j.properties(略)
SqlMapConfig.xml
mybatis配置文件：别名、settings、数据源都不在这里进行配置
applicationContext.xml
1.数据源(dbcp连接池)
2.SqlSessionFactory
2.mapper或DAO
整合开发原始Dao接口
配置SqlSessionFactory
在applicationContext.xml中配置SqlSessionFactory
<!-- SqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 数据源 -->
<property name="dataSource" ref="dataSource"/>
<!-- mybatis配置文件 -->
<property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml"/>
</bean>开发原始DAO
public class UserDaoImpl extends SqlSessionDaoSupport implements UserDao {
public User findUserById(int id) throws Exception {
// 创建SqlSession
SqlSession sqlSession = this.getSqlSession();
// 根据id查询用户信息
User user = sqlSession.selectOne("test.findUserById", id);
return user;
}
}配置原始DAO
<!-- 配置dao -->
<bean id="userDao" class="test.lx.mybatis.dao.UserDaoImpl">
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>测试原始DAO接口
public class UserDaoImplTest {
// 会话工厂
private ApplicationContext applicationContext;
//创建工厂
@Before
public void init() throws IOException{
// 创建Spring容器
applicationContext = new ClassPathXmlApplicationContext("spring/applicationContext.xml");
}
@Test
public void testFindUserById() throws Exception{
UserDao userDao = (UserDao) applicationContext.getBean("userDao");
User user = userDao.findUserById(1);
System.out.println(user);
}
}整合开发mapper代理方法
开发mapper.xml和mapper.java
使用MapperFactoryBean
<!-- 配置mapper -->
<!-- MapperFactoryBean：用于生成mapper代理对象 -->
<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
<property name="mapperInterface" value="test.lx.mybatis.mapper.UserMapper"/>
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean> 使用MapperScannerConfigurer(扫描mapper)
<!--
MapperScannerConfigurer: mapper扫描器，将包下的mapper接口自动创建代理对象，
自动创建到Spring容器中，bean的id是mapper的类名(首字母小写)
-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!-- 配置扫描包的路径
如果要扫描多个包，中间使用半角逗号 , 隔开
-->
<property name="basePackage" value="test.lx.mybatis.mapper"/>
<!-- 使用sqlSessionFactoryBeanName -->
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
</bean>测试mapper接口
public class UserMapperTest {
// 会话工厂
private ApplicationContext applicationContext;
//创建工厂
@Before
public void init() throws IOException{
// 创建Spring容器
applicationContext = new ClassPathXmlApplicationContext("spring/applicationContext.xml");
}
@Test
public void testFindUserById() throws Exception {
UserMapper userMapper = (UserMapper) applicationContext.getBean("userMapper");
User user = userMapper.findUserById(1);
System.out.println(user);
}
}mybatis逆向工程(Mybatis Generator)
什么是mybatis的逆向工程
mybatis官方为了提高开发效率，提供自动对表单生成SQL，包括：mapper.xml,mapper.java, 表名.java(po类)
在企业开发中通常是在设计阶段对表进行设计、创建。
在开发阶段根据表结构创建对应的po类。
mybatis逆向工程的方向：由数据表—>java代码
逆向工程使用配置
运行逆向工程 方法：
逆向工程运行所需要的jar包
xml配置
需要使用配置的地方
需要注意的是：涉及到路径时，一定要写绝对路径，相对路径有时是不起作用的。
1.连接数据库的地址和驱动
<!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
<jdbcConnection driverClass="com.mysql.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/mybatis" userId="root"
password="root">
</jdbcConnection><!-- targetProject:生成PO类的位置 -->
<javaModelGenerator targetPackage="test.lx.mybatis.po"
targetProject="/Users/liuxun/Workspaces/MyEclipse_2017_CI/Mybatis_generatorSqlMapCustom/src">
<!-- enableSubPackages:是否让schema作为包的后缀 -->
<property name="enableSubPackages" value="false" />
<!-- 从数据库返回的值被清理前后的空格 -->
<property name="trimStrings" value="true" />
</javaModelGenerator><!-- targetProject:mapper映射文件生成的位置 -->
<sqlMapGenerator targetPackage="test.lx.mybatis.mapper"
targetProject="/Users/liuxun/Workspaces/MyEclipse_2017_CI/Mybatis_generatorSqlMapCustom/src">
<!-- enableSubPackages:是否让schema作为包的后缀 -->
<property name="enableSubPackages" value="false" />
</sqlMapGenerator>
<!-- targetPackage：mapper接口生成的位置 -->
<javaClientGenerator type="XMLMAPPER"
targetPackage="test.lx.mybatis.mapper"
targetProject="/Users/liuxun/Workspaces/MyEclipse_2017_CI/Mybatis_generatorSqlMapCustom/src">
<!-- enableSubPackages:是否让schema作为包的后缀 -->
<property name="enableSubPackages" value="false" />
</javaClientGenerator><!-- 指定数据库表 -->
<table tableName="items"></table>
<table tableName="orders"></table>
<table tableName="orderdetail" ></table>xml配置使用详解
<?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>java程序
通过Java程序生成mapper类、po类public class GeneratorSqlmap {
public void generator() throws Exception{
List<String> warnings = new ArrayList<String>();
boolean overwrite = true;
//指定 逆向工程配置文件
File configFile = new File("generatorConfig.xml");
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 {
try {
GeneratorSqlmap generatorSqlmap = new GeneratorSqlmap();
generatorSqlmap.generator();
} catch (Exception e) {
e.printStackTrace();
}
}
}使用逆向工程生成代码
第一步：配置generatorConfig.xml
第二步配置执行Java程序
执行Java程序后，所生成的代码已经在当前项目中
第三步：将生成的代码拷贝到项目工程中
mybatis逆向工程源代码
此完整代码已上传GitHub（https://github.com/LX1993728/Mybatis_generatorSqlMapCustom）
generatorConfig.xml
<?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>
<context id="testTables" targetRuntime="MyBatis3">
<commentGenerator>
<!-- 是否去除自动生成的注释 true：是 ： false:否 -->
<property name="suppressAllComments" value="true" />
</commentGenerator>
<!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
<jdbcConnection driverClass="com.mysql.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/mybatis" userId="root"
password="root">
</jdbcConnection>
<!-- <jdbcConnection driverClass="oracle.jdbc.OracleDriver"
connectionURL="jdbc:oracle:thin:@127.0.0.1:1521:yycg"
userId="yycg"
password="yycg">
</jdbcConnection> -->
<!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL 和
NUMERIC 类型解析为java.math.BigDecimal -->
<javaTypeResolver>
<property name="forceBigDecimals" value="false" />
</javaTypeResolver>
<!-- targetProject:生成PO类的位置 -->
<javaModelGenerator targetPackage="test.lx.mybatis.po"
targetProject="/Users/liuxun/Workspaces/MyEclipse_2017_CI/Mybatis_generatorSqlMapCustom/src">
<!-- enableSubPackages:是否让schema作为包的后缀 -->
<property name="enableSubPackages" value="false" />
<!-- 从数据库返回的值被清理前后的空格 -->
<property name="trimStrings" value="true" />
</javaModelGenerator>
<!-- targetProject:mapper映射文件生成的位置 -->
<sqlMapGenerator targetPackage="test.lx.mybatis.mapper"
targetProject="/Users/liuxun/Workspaces/MyEclipse_2017_CI/Mybatis_generatorSqlMapCustom/src">
<!-- enableSubPackages:是否让schema作为包的后缀 -->
<property name="enableSubPackages" value="false" />
</sqlMapGenerator>
<!-- targetPackage：mapper接口生成的位置 -->
<javaClientGenerator type="XMLMAPPER"
targetPackage="test.lx.mybatis.mapper"
targetProject="/Users/liuxun/Workspaces/MyEclipse_2017_CI/Mybatis_generatorSqlMapCustom/src">
<!-- enableSubPackages:是否让schema作为包的后缀 -->
<property name="enableSubPackages" value="false" />
</javaClientGenerator>
<!-- 指定数据库表 -->
<table tableName="items"></table>
<table tableName="orders"></table>
<table tableName="orderdetail" ></table>
<!-- <table schema="" tableName="sys_user"></table>
<table schema="" tableName="sys_role"></table>
<table schema="" tableName="sys_permission"></table>
<table schema="" tableName="sys_user_role"></table>
<table schema="" tableName="sys_role_permission"></table> -->
<!-- 有些表的字段需要指定java类型
<table schema="" tableName="">
<columnOverride column="" javaType="" />
</table> -->
</context>
</generatorConfiguration>
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.exception.XMLParserException;
import org.mybatis.generator.internal.DefaultShellCallback;
public class GeneratorSqlmap {
public void generator() throws Exception{
List<String> warnings = new ArrayList<String>();
boolean overwrite = true;
//指定 逆向工程配置文件
File configFile = new File("generatorConfig.xml");
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 {
try {
GeneratorSqlmap generatorSqlmap = new GeneratorSqlmap();
generatorSqlmap.generator();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Spring与mybatis整合源代码
代码已上传GitHub (https://github.com/LX1993728/spring_mybatis)
package test.lx.mybatis.dao;
import java.util.List;
import test.lx.mybatis.po.User;
/**
* 用户DAO
*
* @author lx
*
*/
public interface UserDao {
// 根据id查询用户信息
public User findUserById(int id) throws Exception;
}package test.lx.mybatis.dao;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import test.lx.mybatis.po.User;
public class UserDaoImpl extends SqlSessionDaoSupport implements UserDao {
public User findUserById(int id) throws Exception {
// 创建SqlSession
SqlSession sqlSession = this.getSqlSession();
// 根据id查询用户信息
User user = sqlSession.selectOne("test.findUserById", id);
return user;
}
}
SqlMapConfig.xml
<?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>
<!-- 定义别名 -->
<typeAliases>
<!-- 批量别名定义 指定包路径，自动扫描包内的pojo,定义别名，别名默认为类名(首字母小写或大写) -->
<package name="test.lx.mybatis.po" />
</typeAliases>
<mappers>
<!-- 加载原始Dao使用的user.xml -->
<mapper resource="sqlmap/User.xml" />
<package name="test.lx.mybatis.mapper" />
</mappers>
</configuration>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">
<!-- 加载配置文件 -->
<context:property-placeholder location="classpath:db.properties" />
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<property name="maxActive" value="10" />
<property name="maxIdle" value="5" />
</bean>
<!-- SqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 数据源 -->
<property name="dataSource" ref="dataSource"/>
<!-- mybatis配置文件 -->
<property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml"/>
</bean>
<!-- 配置dao -->
<bean id="userDao" class="test.lx.mybatis.dao.UserDaoImpl">
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>
<!-- 配置mapper -->
<!-- MapperFactoryBean：用于生成mapper代理对象 -->
<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
<property name="mapperInterface" value="test.lx.mybatis.mapper.UserMapper"/>
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>
<!--
MapperScannerConfigurer: mapper扫描器，将包下的mapper接口自动创建代理对象，
自动创建到Spring容器中，bean的id是mapper的类名(首字母小写)
-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!-- 配置扫描包的路径
如果要扫描多个包，中间使用半角逗号 , 隔开
-->
<property name="basePackage" value="test.lx.mybatis.mapper"/>
<!-- 使用sqlSessionFactoryBeanName -->
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
</bean>
</beans>package test.lx.mybatis.dao;
import java.io.IOException;
import java.io.InputStream;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import test.lx.mybatis.po.User;
public class UserDaoImplTest {
// 会话工厂
private ApplicationContext applicationContext;
//创建工厂
@Before
public void init() throws IOException{
// 创建Spring容器
applicationContext = new ClassPathXmlApplicationContext("spring/applicationContext.xml");
}
@Test
public void testFindUserById() throws Exception{
UserDao userDao = (UserDao) applicationContext.getBean("userDao");
User user = userDao.findUserById(1);
System.out.println(user);
}
}package test.lx.mybatis.mapper;
import java.io.IOException;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import test.lx.mybatis.po.User;
public class UserMapperTest {
// 会话工厂
private ApplicationContext applicationContext;
//创建工厂
@Before
public void init() throws IOException{
// 创建Spring容器
applicationContext = new ClassPathXmlApplicationContext("spring/applicationContext.xml");
}
@Test
public void testFindUserById() throws Exception {
UserMapper userMapper = (UserMapper) applicationContext.getBean("userMapper");
User user = userMapper.findUserById(1);
System.out.println(user);
}
}package test.lx.mybatis.mapper;
import static org.junit.Assert.*;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import test.lx.mybatis.po.Items;
import test.lx.mybatis.po.ItemsExample;
/**
* 切记：
* 不管是查询还是更新，只要涉及到多条记录 不带withBlobs后缀的方法 默认都不会对大文本字段进行操作
* 接口方法名中包含Selective的 表示有选择性的进行操作(只查询、更新、添加为参数复制过的属性对应的字段)
* 接口方法名中包含Example的 表示可以带有条件筛选
*
* @author liuxun
*
*/
public class ItemsMapperTest {
private ApplicationContext applicationContext;
private ItemsMapper itemsMapper;
@Before
public void setUp() throws Exception {
// 创建Spring容器
applicationContext = new ClassPathXmlApplicationContext("spring/applicationContext.xml");
itemsMapper = (ItemsMapper) applicationContext.getBean("itemsMapper");
}
// 自定义条件筛选数量查询
@Test
public void testCountByExample() {
ItemsExample itemsExample = new ItemsExample();
ItemsExample.Criteria criteria = itemsExample.createCriteria();
criteria.andPriceBetween(300.f, 10000.f);
int count = itemsMapper.countByExample(itemsExample);
System.out.println(count);
}
// 自定义条件删除
@Test
public void testDeleteByExample() {
ItemsExample itemsExample = new ItemsExample();
ItemsExample.Criteria criteria = itemsExample.createCriteria();
criteria.andNameLike("%冰箱%"); // 使用like相关属性时 参数外要包括 %%
itemsMapper.deleteByExample(itemsExample);
}
// 根据主键进行删除
@Test
public void testDeleteByPrimaryKey() {
itemsMapper.deleteByPrimaryKey(6);
}
// 表示插入全部字段，若某字段对应属性没有复制，默认插为NULL(自增主键例外)
@Test
public void testInsert() {
Items items = new Items();
items.setName("电视机");
items.setPrice(3000.f);
items.setDetail("乐视高清");
itemsMapper.insert(items);
}
// 选择性插入，插入记录时只对赋值属性对应的字段进行插入
@Test
public void testInsertSelective() {
Items items = new Items();
items.setName("电冰箱");
items.setPrice(2500.f);
items.setDetail("三年包换");
itemsMapper.insertSelective(items);
}
// 自定义条件查询多条记录，包含大文本字段
@Test
public void testSelectByExampleWithBLOBs() {
ItemsExample itemsExample = new ItemsExample();
ItemsExample.Criteria criteria = itemsExample.createCriteria();
criteria.andNameIsNotNull();
List<Items> list = itemsMapper.selectByExampleWithBLOBs(itemsExample);
for (Items items : list) {
System.out.println(items.getDetail());
}
}
// 自定义条件查询多条记录，不对大文本字段进行查询
@Test
public void testSelectByExample() {
ItemsExample itemsExample = new ItemsExample();
ItemsExample.Criteria criteria = itemsExample.createCriteria();
criteria.andNameIsNotNull();
List<Items> list = itemsMapper.selectByExample(itemsExample);
for (Items items : list) {
System.out.println(items.getDetail()); // 大文本字段值为null
}
}
// 按照主键值进行查询单条记录
@Test
public void testSelectByPrimaryKey() {
Items items = itemsMapper.selectByPrimaryKey(1);
System.out.println(items.getDetail());
}
// 自定义条件更新(为POJO赋值过的属性对应的字段)，不对PO类中的大文本字段进行更新
// 如果PO类对象中的一些属性未赋值，不做任何改变，只更新赋值过的属性 即有选择性的更新
@Test
public void testUpdateByExampleSelective() {
// 此处方法名后缀Selective：表示只对参数record中设置过的属性对应的字段进行更新 没有设置过的不做任何改变
// record:封装更新后的结果值
// example: 封装 筛选更新记录条件
ItemsExample example = new ItemsExample();
ItemsExample.Criteria criteria = example.createCriteria();
Items record = new Items();
record.setPrice(2500.f);
criteria.andNameLike("%机%");
itemsMapper.updateByExampleSelective(record, example);
}
// 根据外键强制全部更新数据(没有赋值的映射为NULL) 包含大文本字段
@Test
public void testUpdateByExampleWithBLOBs() {
}
// 根据外键强制全部更新数据(没有赋值的映射为NULL) 不包含大文本字段
@Test
public void testUpdateByExample() {
}
// 根据外键有选择性的更新数据 不包含大文本字段 必须为参数items设置主键值
@Test
public void testUpdateByPrimaryKeySelective() {
}
// 根据外键全部更新数据(没有赋值的映射为NULL) 包含大文本字段 必须为参数items设置主键值
@Test
public void testUpdateByPrimaryKeyWithBLOBs() {
}
// 根据外键有全部更新数据(没有赋值的映射为NULL) 不包含大文本字段 必须为参数items设置主键值
@Test
public void testUpdateByPrimaryKey() {
}
}
340
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
